Si eres desarrollador iOS y has buscado empleo recientemente, seguramente has visto un patrón repetitivo en las ofertas laborales: “Se requiere conocimiento sólido en principios SOLID y programación orientada a objetos”. Es casi un estándar de la industria. Sin embargo, hay algo que pocas empresas y reclutadores parecen considerar: Swift no fue diseñado para ser un lenguaje orientado a objetos 😱.

En 2015, durante la WWDC, Dave Abrahams pronunció una frase que marcó un antes y un después en el ecosistema Apple: “Swift is a Protocol-Oriented Programming language”. Desde entonces, la filosofía de desarrollo en el ecosistema iOS tomó un rumbo diferente al del resto de la industria. Este artículo busca aclarar esas diferencias y reflexionar sobre por qué, como desarrolladores, deberíamos replantear las preguntas y respuestas sobre SOLID en una entrevista técnica.

SOLID: El estándar de la industria

Los principios SOLID, formulados por Robert C. Martin (uncle Bob), son cinco reglas de diseño pensadas para escribir software mantenible y escalable dentro del paradigma de la programación orientada a objetos:

• S — Single Responsibility Principle (Responsabilidad única)
• O — Open/Closed Principle (Abierto/Cerrado)
• L — Liskov Substitution Principle (Sustitución de Liskov)
• I — Interface Segregation Principle (Segregación de interfaces)
• D — Dependency Inversion Principle (Inversión de dependencias)

Estos principios nacieron en un contexto donde la herencia de clases y las jerarquías profundas eran la norma. Lenguajes como Java, C++ y C# los adoptaron como guía fundamental, y con razón: en un mundo dominado por clases y herencia, SOLID resuelve problemas reales de acoplamiento y rigidez.

El problema surge cuando trasladamos estos principios de forma literal a Swift. No es que SOLID sea incompatible con Swift, sino que Swift ofrece herramientas nativas que resuelven muchos de esos problemas de forma más natural y elegante, sin necesidad de recurrir a los patrones clásicos de POO.

POO vs POP: Dos filosofías distintas

Programación Orientada a Objetos (POO)

La POO se fundamenta en cuatro pilares: encapsulamiento, herencia, polimorfismo y abstracción. Todo gira en torno a clases (tipos por referencia), y la reutilización de código se logra principalmente mediante herencia vertical. Una clase hija hereda comportamiento de una clase padre, y así se construyen jerarquías.

El problema clásico de este enfoque es conocido: las jerarquías crecen, se vuelven rígidas y difíciles de modificar. Además, la herencia múltiple no está permitida en la mayoría de lenguajes, lo que limita la composición de comportamientos.

Programación Orientada a Protocolos (POP)

POP propone un cambio de mentalidad. En lugar de preguntarse “¿qué es este objeto?”, se pregunta “¿qué puede hacer este objeto?”. La unidad fundamental no es la clase, sino el protocolo, y la reutilización de código se logra mediante composición horizontal: un tipo puede conformar múltiples protocolos, cada uno con su implementación por defecto a través de extensiones.

Las diferencias clave son:

En Swift, los protocolos con extensiones permiten definir comportamiento compartido sin crear jerarquías de clases. Las structs, al ser tipos por valor, eliminan problemas de estado compartido y efectos secundarios inesperados. Esto no es simplemente una preferencia estilística; es una decisión de diseño del lenguaje respaldada por Apple.

La perspectiva de un desarrollador iOS con más de 10 años de experiencia.

Después de más de una década desarrollando aplicaciones iOS, he visto la evolución completa del ecosistema: desde los días de Objective-C y MVC puro, pasando por la llegada de Swift en 2014, hasta el presente con SwiftUI y structured concurrency.

Si hay algo que esa experiencia me ha enseñado es que Swift se disfruta de verdad cuando dejas de escribirlo como si fuera Java.

Durante los primeros años de Swift, muchos desarrolladores (incluido yo) seguíamos pensando en clases, herencia y patrones GOF porque era lo que conocíamos. Funcionaba, sí, pero no aprovechábamos lo que el lenguaje realmente ofrecía. El cambio llegó cuando empecé a diseñar con protocolos como base: el código se volvió más modular, más testeable y significativamente más fácil de mantener.

Con la llegada de SwiftUI, este enfoque se consolidó definitivamente. SwiftUI está construido casi en su totalidad sobre structs y protocolos. El protocolo View, por ejemplo, es el corazón de todo el framework. No hay clases. No hay herencia. No hay UIViewController. Es POP en su forma más pura:

struct MiVista: View {
    var body: some View {
        Text("Hola, POP")
    }
}

Combinado con el modelo de concurrencia moderno de Swift — actors, async/await, Sendable — , los tipos por valor y los protocolos no solo son convenientes, sino que son la forma segura y recomendada de escribir código concurrente.

¿Significa esto que SOLID no tiene lugar en Swift? No. Sus principios siguen siendo valiosos como guía conceptual. Pero la forma de aplicarlos cambia radicalmente. El principio de segregación de interfaces se cumple naturalmente con protocolos pequeños y específicos. La inversión de dependencias se logra inyectando protocolos, no clases abstractas.

Mi recomendación para la industria es simple: cuando busquemos talento iOS, preguntemos por Protocol-Oriented Programming, composición sobre herencia y dominio de tipos valor. Eso nos dice mucho más sobre un candidato que recitar los cinco principios SOLID de memoria.

Swift tiene su propia identidad. Es hora de que nuestras entrevistas la reflejen.

Dejame un comentario con tus opiniones. Nos leemos en la próxima publicación 🚀

Como desarrollador iOS con más de 10 años de experiencia, desde Objective-C hasta SwiftUI en proyectos fintech y de salud, he explorado herramientas como Claude AI para optimizar flujos de trabajo.

Claude, de Anthropic, se destaca por su capacidad para generar código y asistir en tareas repetitivas, como se detalla en su manual oficial “The Complete Guide to Building Skills for Claude”. Este guía enfatiza la creación de “skills” — flujos personalizados — para code generation, como vistas SwiftUI o integración con Xcode.

Ventajas de Utilizar Claude en Desarrollo iOS
Claude acelera la productividad al generar código boilerplate, como vistas en SwiftUI o manejadores de API con Combine, manteniendo consistencia en estilos y mejores prácticas. Sus “skills” permiten workflows repetibles, reduciendo tokens y esfuerzo manual. Para iOS, es ideal para prototipos rápidos, depuración lógica y optimización de UI, integrando guías de Apple sin reinvención. Beneficios clave incluyen portabilidad entre interfaces (web, API) y eficiencia en equipos, donde un asistente AI maneja tareas mundanas, liberando tiempo para arquitectura compleja.

Beneficios de un Asistente AI para Desarrolladores iOS
Un AI como Claude actúa como co-piloto: acelera aprendizaje de frameworks nuevos (e.g., RealityKit), sugiere optimizaciones de rendimiento y valida código contra leaks o concurrency issues. En mi experiencia, mejora la innovación, permitiendo iteraciones rápidas en apps como wallets cripto, mejorando calidad sin sacrificar creatividad.

Desventajas para Juniors y Seniors
Para juniors, Claude puede fomentar dependencia, limitando comprensión profunda de conceptos como ARC o async/await, resultando en código “copiado” sin depuración manual. También, prompts mal estructurados llevan a outputs inexactos, retrasando el mastery de Xcode.

Para seniors, las limitaciones incluyen over-triggering de skills o problemas de contexto grande, que degradan performance en proyectos escalables. Dependencia en MCP (para integraciones como GitHub) introduce fallos si no se configura bien, y carece de testing automatizado nativo, obligando validación manual.

En resumen, Claude es una herramienta valiosa para iOS dev, pero debe usarse con criterio: juniors para un desarrollo guiado, seniors para workflows avanzados. Recomiendo empezar con el manual para skills personalizados — transforma el desarrollo, pero no reemplaza expertise humana.

El pasado 11 de febrero de 2026, Apple liberó la versión estable de iOS 26.3, marcando el último hito importante antes del lanzamiento de la esperada actualización que integrará una nueva generación de Siri potenciada por Google Gemini. Lejos de ser una versión con grandes funciones de consumo — esa revolución quedará para iOS 26.4 — , iOS 26.3 representa un avance crítico en estabilidad, seguridad, compatibilidad entre plataformas y preparación de la plataforma para lo que viene.

En mis más de diez años desarrollando para iPhone — desde los tiempos del iPhone 5 — he aprendido a leer cada actualización con dos lentes: ¿qué aporta hoy y qué prepara para mañana? iOS 26.3 es, sin duda, una actualización de madurez cuyo impacto va más allá de lo que Apple destaca en sus notas oficiales. Aquí te explico por qué.

🔐 Seguridad y correcciones: la base de toda actualización responsable

Antes que ninguna novedad visible al usuario, iOS 26.3 incluye decenas de correcciones de seguridad que Apple considera críticas. Entre ellas se encuentran parches para vulnerabilidades que podrían permitir ejecución arbitraria de código o acceso indebido a información sensible — incluyendo al menos una que ya ha sido explotada en el mundo real — según análisis independientes.

Para desarrolladores y empresas que gestionan dispositivos con MDM, esta actualización también corrige problemas con la autenticación básica en cuentas de correo y mejora la estabilidad de la gestión de software entre dispositivos gestionados.

Lección para desarrolladores: mantener tu equipo y tus dispositivos en la última versión no sólo es una cuestión de nuevas APIs, sino de proteger tus datos, tus builds firmados y tus certificados de distribución de amenazas reales.

📱 Interoperabilidad: Apple empieza a cruzar puentes

Una de las novedades más comentadas de iOS 26.3 es la herramienta nativa para transferir datos de un iPhone a un dispositivo Android. Por primera vez Apple ofrece un flujo integrado sin necesidad de apps externas, permitiendo migrar fotos, mensajes, contactos, notas, contraseñas y más — simplificando considerablemente el proceso de cambio de ecosistema.

Este cambio histórico no solo responde a las demandas de los usuarios: es también una señal clara de la presión regulatoria global (como la Ley de Mercados Digitales en Europa) para facilitar la interoperabilidad entre plataformas.

Además, en regiones como la Unión Europea (donde resido la mayor parte del año), iOS 26.3 añade soporte para reenvío de notificaciones a relojes o dispositivos terceros y mecanismos de emparejamiento de proximidad con accesorios no-Apple, acercando la experiencia iPhone a estándares más abiertos.

Como desarrollador, esto abre nuevas posibilidades: wearable frameworks más compatibles, menos bloqueos en flujos de entrada y salida de datos, y maneras más eficientes de sincronizar experiencias entre Apple y otros ecosistemas.

📍 Privacidad reforzada: control granular sobre tu ubicación

Apple ha añadido un nuevo ajuste para limitar el nivel de precisión con el que las redes celulares pueden rastrear tu ubicación. Esta funcionalidad es especialmente útil si te preocupa compartir coordenadas exactas con tu operador, optando por una precisión mayoritariamente por barrio en lugar de por dirección.

Aunque esta característica depende del hardware de red (disponible en modelos como iPhone 16e o iPhone Air con módem C1/C1X), es un ejemplo claro de cómo Apple sigue afinando la privacidad por diseño, incluso en capas del sistema que suelen quedar fuera del foco principal de los usuarios.

🎨 Mejoras menores pero significativas en la experiencia de uso

iOS 26.3 también incluye ajustes de UX que, aunque sutiles, hacen que el sistema se sienta más coherente y refinado:

• Galería de fondos de pantalla reorganizada: separa las secciones de Clima y Astronomía para facilitar la selección.
• Actualizaciones a RCS en Mensajes: mejora la interoperabilidad avanzada en chats con usuarios Android (sujeto a soporte de los operadores).
• Optimización de animaciones y rendimiento: reportes tempranos de usuarios indican una sensación más fluida y consistente comparado con versiones anteriores.

Estas mejoras pueden parecer menores por separado, pero contribuyen a una experiencia de uso más refinada en el día a día.

🚀 Mirando hacia iOS 26.4 y el futuro de Siri con Gemini (la parte que mas me emociona 😎)

Quizá el aspecto más interesante de iOS 26.3 no es lo que tiene, sino lo que está preparando para el futuro.

Apple ha confirmado que **iOS 26.4 introducirá una versión de Siri potenciada por Google Gemini, lo que promete una IA conversacional más contextual, potente y capaz de ejecutar acciones complejas directamente desde el sistema operativo.

Aunque esta funcionalidad no se activa en iOS 26.3, esta versión ha sido clave para sentar las bases: ajustes de estabilidad, compatibilidad de servicios, gestión de permisos de IA y optimizaciones de rendimiento que serán esenciales para que la nueva Siri funcione de forma eficiente y segura.

Como desarrolladores debemos prepararnos para:

• Integrar intentos avanzados de Siri y shortcuts más inteligentes.
• Adoptar eventos de interacción basados en IA.
• Revisar nuestras apps para rendir con nuevos modelos de lenguaje en tiempo real, manteniendo privacidad y rendimiento.

🧠 Conclusión: una actualización que no hace mucho ruido, pero mueve bastante

Si te soy sincero, iOS 26.3 no es de esas actualizaciones que te hacen decir “¡qué bestia, esto cambia todo!”. No trae una interfaz nueva ni una función que se vuelva viral en TikTok. Pero ojo — eso no significa que no sea importante.

Esta versión es de esas que trabajan calladitas. Ajusta, corrige, fortalece y deja todo listo para lo que realmente se viene pesado: la nueva generación de Siri con Gemini.

Y los que llevamos años desarrollando en iOS sabemos algo clarito: cuando Apple empieza a ordenar la casa, es porque algo grande está por entrar. No es coincidencia que refuercen seguridad, mejoren interoperabilidad y optimicen rendimiento justo antes de meter un motor de IA mucho más potente dentro del sistema.

Desde mi experiencia — desde el iPhone 5 hasta hoy — estas versiones “intermedias” suelen ser las más estratégicas. No brillan por fuera, pero por dentro están preparando el terreno.

Así que mi recomendación es simple:
Actualiza. Prueba. Revisa tus apps. Optimiza.

Porque cuando Siri con Gemini llegue oficialmente, los que ya estén listos no van a estar corriendo… van a estar aprovechando.

Y ahí es donde realmente se nota la diferencia.

Nos leemos en la próxima actualización 🚀

As an iOS developer since 2012, I’ve watched the App Store evolve from a tightly controlled environment into an increasingly open ecosystem for innovation and monetization. What just happened with SaruTobi — and its integration of Lightning payments via ZBD — isn’t just newsworthy; it’s foundational for mobile Web3 within the Apple ecosystem.

Apple has officially approved the first iOS game to implement in-app purchases using Bitcoin’s Lightning Network directly within the app, without requiring external wallets or browser-based redirects. From a technical standpoint, this kind of integration would have been unthinkable just a couple of years ago.

Originally launched in 2013, SaruTobi is now back in the App Store with a completely rearchitected payment flow. Players can now purchase power-ups and earn in-game rewards using satoshis, the smallest unit of Bitcoin. Through ZBD’s SDK, these microtransactions are instant, low-cost, and fully contained within the app’s runtime environment, offering a seamless UX without breaking Apple’s sandbox.

I tried myself a few years ago, after covid, to upload a Bitcoin wallet app in Europe, just for testing purposes and I got rejected by Apple because of regulations. I needed some permissions to run Bitcoin apps in every single country. Now it seems they have realized that no companie, state or corporation can stop Bitcoin adoption because is a protocol, like TCPIP is a protocol for internet.

📱 Why This Matters for iOS Developers

Apple has long been restrictive about alternative payment methods. This approval signals a subtle yet significant shift in how in-app economies might function going forward — particularly when it comes to decentralized and programmable value.

As developers, this means:

• Real interoperability with cryptoassets within iOS’s sandbox, without violating App Store policies.
• New user engagement and retention models, where players can earn real (albeit fractional) value through gameplay and in-app actions.
• A clear opportunity to rethink in-app economies, especially in emerging markets where traditional micro-transactions are less viable.

⚖️ Regulatory Context: The Rulebook Is Being Rewritten

This isn’t happening in a vacuum. It follows increased regulatory pressure from the EU’s Digital Markets Act (DMA), the ripple effects of the Epic vs. Apple case, and a global push for greater openness in platform economies.

Apple isn’t fully opening the gates — but it’s evolving. And as a developer, that’s an invitation to explore new boundaries.

In summary

SaruTobi’s approval isn’t just a comeback for a nostalgic game. It’s a signal that the future of iOS monetization will be more decentralized, programmable, and directly tied to real-world value. For those of us who were writing Objective-C before Swift was even announced, this moment feels like another major inflection point.

Apple’s latest iOS update, 18.2, is a significant step forward, particularly in the realm of AI integration. This update brings a host of new features and improvements, many of which are powered by Apple’s advanced AI technology.

Key Features and Improvements:

• Enhanced Siri with ChatGPT Integration: One of the most notable additions is the integration of ChatGPT into Siri. This allows users to ask more complex questions and receive more detailed and informative responses. Siri can now access real-time information and even share screenshots with ChatGPT to provide more accurate and relevant answers.
• Advanced Writing Tools: Building on the foundation laid in iOS 18.1, iOS 18.2 further expands the capabilities of Writing Tools. Users can now leverage AI-powered features like text summarization, tone adjustment, and creative writing assistance.
• Revolutionary Image Generation with Image Playground: This new app allows users to generate images based on text prompts, opening up a world of creative possibilities. While the images aren’t hyperrealistic, they offer a fun and innovative way to express ideas visually.
• Customizable Genmoji: With iOS 18.2, users can create personalized emojis, known as Genmoji, using AI. These custom emojis can be based on real people, objects, or even imaginary concepts, adding a unique touch to messaging.
• Enhanced Camera Control: The Camera Control on iPhone 16 models gains new features, including adjustable double-click speed and AE/AF Lock. Additionally, users can now activate the Camera app even when the screen is off, providing quick access to capture moments.
• Improved Performance and Stability: As with any major update, iOS 18.2 brings various performance optimizations and bug fixes to enhance the overall user experience.

The Future of AI-Powered Mobile Experiences

iOS 18.2 showcases the potential of AI to revolutionize the way we interact with our devices. By seamlessly integrating AI into various aspects of the operating system, Apple is setting a new standard for mobile experiences. As AI technology continues to advance, we can expect even more innovative and exciting features in future iOS updates.

What are your thoughts on the latest iOS 18.2 features? Are you excited about the AI integration? Let me know in the comments below!

At its WWDC 24 keynote, Apple unveiled “Intelligence,” its groundbreaking personal AI system. Built for iPhone, iPad,and Mac, Intelligence leverages on-device processing powered by Apple silicon. This translates to privacy-focused AI features that work seamlessly within the Apple ecosystem.

Intelligence personalizes your experience by understanding and creating language, taking actions across apps, and drawing from your context. Imagine smarter dictation, real-time translation in conversations, and proactive suggestions in Mail — all happening directly on your device.

If you want to lear more about on-device AI, you can take a look to Introduction to On-Device AI free course.

This innovative approach offers potential benefits like faster response times and enhanced privacy. While still in its early stages (exclusive to iOS 18, iPadOS 18, and the unreleased macOS Sequoia), Intelligence marks a significant step towards powerful on-device AI, shaping the future of how we interact with our Apple devices.

Here I’m going to list some key features that differentiate Apple Intelligence vs Chat GPT (OpenAI)

1. Approach to Processing:

Apple Intelligence: Focuses on on-device processing. This means AI models run directly on your iPhone, iPad, or Mac, without relying on the cloud. This offers advantages like:

• Privacy: User data stays on your device, potentially offering greater privacy compared to cloud-based processing.
• Offline Functionality: Certain features might work even without an internet connection, as the processing happens locally.
• Potentially Lower Latency: Processing on the device can be faster than sending data to the cloud and receiving a response.

ChatGPT: Relies on cloud-based processing. User requests are sent to powerful servers with large AI models, and the response is sent back to the user. This approach offers:

• Potentially More Powerful AI: Cloud-based processing allows access to more powerful AI models that might not be feasible to run on individual devices due to resource limitations.
• Scalability: Cloud infrastructure can handle a larger volume of user requests compared to on-device processing.

2. Integration:

• Apple Intelligence: Integrates deeply with Apple’s ecosystem. It works seamlessly with existing Apple apps like Mail, Notes, and Safari, enhancing them with AI functionalities.
• ChatGPT: Primarily functions as a standalone chatbot or API. Integration with other applications might require additional development effort.

3. Focus:

• Apple Intelligence: Focuses on enhancing user experience within the Apple ecosystem. It provides features like improved dictation, smarter suggestions in Mail, and real-time translation.
• ChatGPT: Offers a broader range of capabilities beyond user experience enhancement. It can be used for tasks like creative text generation, code writing, and translation in various contexts.

4. Availability:

• Apple Intelligence: Currently in its initial stages and is exclusive to Apple devices running iOS 18, iPadOS 18, and macOS Sequoia (not yet publicly released).
• ChatGPT: More widely available through OpenAI’s API and can be integrated into various applications and platforms.

In summary:

• Choose Apple Intelligence if you prioritize privacy, offline functionality, and a seamless experience within the Apple ecosystem.
• Choose ChatGPT if you need a more powerful AI with broader capabilities and wider availability.

The “better” choice depends on your specific needs and priorities. Both Apple Intelligence and ChatGPT represent advancements in on-device and cloud-based AI, respectively. As these technologies evolve, we can expect them to offer even more powerful and versatile functionalities.

If you want to learn more about AI, dont forget to take a look to DeepLearning free courses.

Key differences between Apple Intelligence vs ChatGPT was originally published in Mobile App Circular on Medium, where people are continuing the conversation by highlighting and responding to this story.

When I used to develop my firsts mobile apps back then in 2011 using Xcode and Objective-C, I was the only one in my University class room working in this technology. At that time, as a sole developer, there was no necessity to include git in my iOS projects, but when I had to work in bigger projects with multiple developers in remote locations, Git became a mandatory part of all mobile app projects.

In this post I’ll explain what is Git, GitFlow and why its important to integrate it into your Mobile App Projects.

What is Git?

Git, in the context of mobile software development, is a distributed version control system that is widely used to manage source code, track changes, and facilitate collaboration among developers. It is a fundamental tool in the development process, allowing teams to work on mobile applications efficiently and effectively.

What is GitFlow?

GitFlow is a widely adopted branching model and workflow that offers a structured approach to version control and collaboration in mobile software development. It provides a robust framework for managing and organizing code changes, facilitating team collaboration, and ensuring the stability and quality of mobile applications.

In the context of mobile software development, GitFlow enables developers to work on different features, bug fixes, and releases concurrently while maintaining a clear and controlled development process. It leverages the power of Git, a distributed version control system, to streamline the development lifecycle and support efficient collaboration among team members.

Key Concepts of GitFlow:

1. Branching Model: GitFlow employs a branching model that consists of two main branches — master and develop. The master branch represents the stable and production-ready code, while the develop branch serves as the main development branch where new features are integrated.
2. Feature Branches: When working on a new feature or enhancement, developers create feature branches branching off from the develop branch. These branches are dedicated to specific tasks, enabling developers to work on features independently without affecting the main codebase.
3. Release Branches: Once the development of new features is complete, a release branch is created from the develop branch to prepare for a new release. Bug fixes, documentation updates, and final testing take place in this branch before merging into the master branch.
4. Hotfix Branches: In the event of critical bugs or issues discovered in the production environment, hotfix branches are created from the master branch. These branches allow for quick fixes without disturbing ongoing development on the develop branch.

Benefits of GitFlow in Mobile Software Development:

1. Clear Code Isolation: GitFlow promotes isolation of different features, making it easier to manage and merge code changes without introducing conflicts or breaking the existing codebase.
2. Seamless Collaboration: By utilizing feature branches, GitFlow allows team members to work on different features simultaneously. This parallel development approach enhances collaboration and accelerates the delivery of new features.
3. Version Control: GitFlow provides a reliable version control system, allowing developers to easily track changes, revert to previous versions if needed, and maintain a well-documented history of the project.
4. Stability and Quality Assurance: With the introduction of release branches and thorough testing before merging into the master branch, GitFlow ensures the stability and quality of the software before it reaches the production environment.
5. Flexibility and Scalability: GitFlow is highly adaptable and scalable, making it suitable for both small and large mobile development teams. It provides a structured workflow that accommodates the complexity of mobile app development projects.

GitFlow example

In this example we have 2 main branches: Master and Develop

Master Branch.

In Git, the “master” branch is the default and primary branch in a repository. It serves as the main branch that represents the stable and production-ready version of the codebase. The master branch typically contains the latest release or the most up-to-date version of the project.

Key Characteristics of the Master Branch:

1. Production-Ready Code: The master branch is intended to hold the code that is considered stable, tested, and ready for deployment. It represents the version of the codebase that is expected to be in a state suitable for production use.
2. Release Tagging: When a significant milestone or release is achieved in the project, developers often create a “tag” on the master branch to mark that specific version. These tags serve as a reference point, allowing easy access to specific releases in the repository’s history.
3. Restricted Direct Commit: It is generally recommended to enforce a code review process and restrict direct commits to the master branch. This helps maintain code quality, consistency, and collaboration by ensuring that changes undergo thorough review before being merged into the main branch.
4. Continuous Integration/Continuous Delivery (CI/CD): The master branch often plays a crucial role in CI/CD workflows. It serves as the source for automated build and deployment processes, ensuring that the latest stable version of the application is deployed to the production environment.

Note: It’s worth mentioning that the use of the term “master” for the primary branch has received scrutiny due to potential racial connotations. As a result, many development communities and platforms have started transitioning to alternative branch names, such as “main” or “default,” to promote inclusivity and eliminate any unintended associations.

Develop Branch

In Git, the “develop” branch is a common branch used in the GitFlow workflow and other branching models. It serves as the main branch for ongoing development, integration, and collaboration among team members. The develop branch acts as a staging area where new features, bug fixes, and other changes are integrated before being merged into the master branch.

Key Characteristics of the Develop Branch:

1. Ongoing Development: The develop branch is where most of the active development takes place. It contains the latest code changes and serves as a workspace for developers to collaborate on new features, enhancements, and bug fixes.
2. Feature Integration: Developers create feature branches branching off from the develop branch. Each feature branch represents a specific task or feature being developed independently. Once a feature is completed, it is merged back into the develop branch for integration with other features.
3. Continuous Integration: The develop branch is often associated with continuous integration (CI) practices. CI involves automatically building and testing the code whenever changes are pushed to the develop branch. This ensures early detection of integration issues and helps maintain code quality and stability.
4. Preparing for Releases: The develop branch is where code changes are accumulated and prepared for future releases. It undergoes rigorous testing, bug fixing, and quality assurance before creating release branches for specific releases or versions.
5. Code Review and Collaboration: The develop branch facilitates code review processes, where team members review each other’s code changes before merging them into the branch. This promotes collaboration, knowledge sharing, and adherence to coding standards within the development team.
6. Integration Testing: Integration testing is commonly performed on the develop branch to validate the compatibility and functionality of the integrated code changes. This ensures that different features and components work together as expected before being merged into the main branch.
7. Stable but Not Production-Ready: While the develop branch is expected to be relatively stable, it is not considered production-ready on its own. It serves as an intermediate stage before merging into the master branch, where the production-ready code resides.

By utilizing the develop branch in Git, development teams can maintain a controlled and structured workflow, facilitate collaboration, and ensure that code changes are thoroughly tested and integrated before reaching the production environment

Supporting branches

Next to the main branches master and develop, our development model uses a variety of supporting branches to aid parallel development between team members, ease tracking of features, prepare for production releases and to assist in quickly fixing live production problems. Unlike the main branches, these branches always have a limited life time, since they will be removed eventually.

The different types of branches we can use are: feature branches, release branches and hotfixes.

Feature branch

In Git, a feature branch is a separate branch created from a main branch (such as develop or master, in our diagram its coming from develop) that is dedicated to developing a specific feature or implementing a particular task. Feature branches allow developers to work on new features or changes independently without affecting the main codebase. They promote isolation, parallel development, and collaboration within a development team.

Key Characteristics of Feature Branches:

1. Isolation of Work: Feature branches provide a dedicated space for developers to work on specific features or tasks. Each feature branch is independent of the main branch, allowing developers to make changes and experiment without impacting the stability of the main codebase.
2. Parallel Development: Feature branches enable multiple team members to work on different features simultaneously. This parallel development approach accelerates the development process and allows for efficient utilization of resources within the team.
3. Code Review and Collaboration: Feature branches facilitate code review processes, where team members review and provide feedback on each other’s code changes. This promotes collaboration, knowledge sharing, and helps maintain code quality and adherence to coding standards.
4. Testing and Bug Fixing: Developers can perform testing and bug fixing within their feature branches, ensuring that the new feature or task meets the desired requirements and quality standards before merging it into the main branch.
5. Iterative Development: Feature branches support an iterative development approach. Developers can make incremental changes and commit them to the feature branch, enabling them to iterate and refine the implementation until the feature is considered complete.
6. Merge into the Main Branch: Once the feature development is completed and the code changes in the feature branch have been reviewed and tested, the feature branch is merged back into the main branch (e.g., develop or master) to incorporate the new functionality into the application.
7. Cleanup and Branch Deletion: After merging a feature branch into the main branch, it is common practice to delete the feature branch to keep the repository clean and avoid clutter. This helps maintain a clear history of the codebase and reduces the chances of confusion or conflicts in the future.

Using feature branches in Git promotes a structured and organized development process, enabling developers to work on features independently, collaborate effectively, and maintain a clean and stable main branch that represents the production-ready code.

According to our diagram, feature branches may branch off from develop and must merge back into develop.

Creating a feature branch.

When starting work on a new feature, branch off from the develop branch with the following command:

git checkout -b myfeature develop
//Switched to a new branch "myfeature"

Incorporating a finished feature on develop:

$ git checkout develop
//Switched to branch 'develop'

$ git merge --no-ff myfeature
//Updating ea1b82a..05e9557
//(Summary of changes)

$ git branch -d myfeature
//Deleted branch myfeature (was 05e9557).

$ git push origin develop

Release branch

In Git, a release branch is a branch created from a main branch (such as develop) to prepare for a specific release or version of a software project. Release branches serve as a dedicated space for finalizing and stabilizing the codebase before it is deployed to production or made available to end-users.

Key Characteristics of Release Branches:

1. Release Preparation: Release branches are created to isolate the codebase for a specific release. They provide a controlled environment where final testing, bug fixing, and other release-related activities can take place.
2. Stability and Bug Fixes: Release branches are typically used for ensuring stability and addressing any critical bugs or issues discovered during the testing phase. Only essential bug fixes and necessary changes are made on the release branch to avoid introducing new features or risky modifications.
3. Documentation and Release Notes: Release branches are an ideal place to update documentation, release notes, and other relevant information related to the specific release. It allows for the inclusion of accurate and up-to-date information about the changes and improvements made in that release.
4. Testing and Quality Assurance: Release branches undergo thorough testing, including regression testing and user acceptance testing, to ensure the quality and reliability of the codebase before it is released. This helps identify and address any potential issues or regressions that may have occurred during development.
5. Code Freeze: Release branches typically observe a code freeze period, during which no new features are added, and only critical bug fixes are allowed. This freeze ensures that the codebase remains stable and focused on finalizing the release without the introduction of additional changes that may cause complications.
6. Release Deployment: Once the release branch is deemed stable and ready for deployment, it is merged into the main branch (e.g., master) to incorporate the release changes into the production-ready codebase. From there, the release can be packaged, deployed, or distributed to end-users.
7. Lifecycle of Release Branches: After the release branch is merged into the main branch, it may be deleted to maintain a clean and concise repository history. However, it is often recommended to retain a record of release branches or create tags associated with specific releases for reference and auditing purposes.

Release branches in Git help ensure that the codebase is thoroughly tested, stabilized, and documented before reaching the production environment. They provide a controlled space for finalizing releases and assist in maintaining a reliable and high-quality software product.

According to our diagram, release branches should branch off from developer and must merge back into develop and master.

Creating a release branch

$ git checkout -b release-1.2 develop
//Switched to a new branch "release-1.2"

$ git commit -a -m "Release v1.2"
//[release-1.2 74d9424] version number to 1.2
//1 files changed, 1 insertions(+), 1 deletions(-)

Finishing a release branch

$ git checkout master
//Switched to branch 'master'

$ git merge --no-ff release-1.2
//Merge made by recursive.
//(Summary of changes)

$ git tag -a 1.2
//tag the branch

$ git checkout develop
//Switched to branch 'develop'

$ git merge --no-ff release-1.2
//Merge made by recursive.
//(Summary of changes)

$ git branch -d release-1.2
//Deleted branch release-1.2 (was ff452fe).

Hotfix branch

In Git, a hotfix branch is a branch created from the main branch (typically master) to address critical issues or bugs discovered in the production environment. Hotfix branches allow developers to quickly develop and deploy emergency fixes without disrupting ongoing development on other branches.

Key Characteristics of Hotfix Branches:

1. Addressing Critical Issues: Hotfix branches are specifically created to tackle urgent and critical issues found in the production environment. These issues may include severe bugs, security vulnerabilities, or other problems that require immediate attention and cannot wait for the regular development cycle.
2. Isolated Development: Hotfix branches provide a separate space for developers to work on fixing the identified issue. This isolation ensures that the main codebase remains stable and unaffected by ongoing development on other branches.
3. Expedited Development and Testing: Hotfix branches focus solely on resolving the critical issue at hand, allowing for faster development and testing cycles. The scope of changes in a hotfix branch is limited to addressing the specific problem, minimizing the chances of introducing unintended side effects.
4. Minimal Changes: Hotfix branches generally avoid introducing new features or significant modifications to the codebase. The focus is on fixing the problem as quickly as possible and keeping the changes minimal to reduce the risk of introducing new issues.
5. Merging into Main Branches: Once the hotfix is developed, tested, and validated, it is merged back into the main branch (e.g., master) to incorporate the fix into the production-ready codebase. From there, the fix can be deployed to the production environment to address the critical issue.
6. Version Compatibility: Hotfix branches may need to consider version compatibility if the issue affects multiple versions of the software. In such cases, separate hotfix branches may be created for different affected versions to ensure the fix is applied appropriately.
7. Cleanup and Branch Deletion: After the hotfix is successfully merged into the main branch and deployed, the hotfix branch is typically deleted to maintain a clean repository history and avoid unnecessary clutter.

Hotfix branches in Git allow development teams to respond quickly to critical issues and provide timely fixes to the production environment. By isolating the development of hotfixes, teams can address urgent problems while minimizing disruptions to ongoing development efforts.

According to our diagram, hotfix branches should branch off from master and must merge back into develop and master.

Creating the hotfix branch

$ git checkout -b hotfix-1.2.1 master
//Switched to a new branch "hotfix-1.2.1"
//Don’t forget to bump the version number after branching off!

$ git commit -a -m "New version number to 1.2.1"
//[hotfix-1.2.1 41e61bb] Bumped version number to 1.2.1
//1 files changed, 1 insertions(+), 1 dele

Then, fix the bug and commit the fix in one or more separate commits.

$ git commit -m "Fixed severe production problem"
//[hotfix-1.2.1 abbe5d6] Fixed severe production problem
//5 files changed, 32 insertions(+), 17 deletions(-)

Finishing a hotfix branch

$ git checkout master
//Switched to branch 'master'

$ git merge --no-ff hotfix-1.2.1
//Merge made by recursive.
//(Summary of changes)

$ git tag -a 1.2.1
//create a tag for the branch

$ git checkout develop
//Switched to branch 'develop'

$ git merge --no-ff hotfix-1.2.1
//Merge made by recursive.
//(Summary of changes)

Finally, remove the temporary branch:

$ git branch -d hotfix-1.2.1
//Deleted branch hotfix-1.2.1 (was abbe5d6).

Conclusion

By following the GitFlow methodology, mobile software development teams can streamline their development process, enhance collaboration, and deliver high-quality mobile applications in a controlled and efficient manner.

I hope you have enjoyed this blog. If you’ve any questions, comments or suggestions please hit me up on Twitter, Linkedin or Linktr.ee.

Git Branching model for Mobile app development 📲 was originally published in Mobile App Circular on Medium, where people are continuing the conversation by highlighting and responding to this story.

What is passive income?

Passive income refers to the earnings generated with minimal effort or ongoing involvement after the initial setup or investment. It is income that continues to be earned even when you’re not actively working. Unlike active income, which requires consistent time and effort, passive income allows you to earn money on an ongoing basis without constant direct involvement.

Passive income can be generated through various sources such as investments, real estate rentals, online businesses, royalties, or intellectual property. The key characteristic of passive income is that it continues to generate revenue even when you’re not actively working on it, giving you more flexibility and the potential to earn money while pursuing other ventures or enjoying your free time.

It’s important to note that creating a passive income stream often requires an initial investment of time, money, or both, to set up the income-generating asset or system. Once established, it can provide a source of income that is less dependent on traditional employment or active labor, offering greater financial freedom and flexibility.

Why do I want passive income as mobile developer?

I consider that, as software developers we have one of the best professions at this moment, because after a pandemia, remote work and software development has been increasing exponentially, allowing us to work from remote like never before. And actually it was during pandemia when I finished some books about Bitcoin and I learned a new concept: financial freedom, and one of the ways to archive financial freedom also is generating passive income even when you sleep, not only during your working time at the office for a salary at the end of the month.

So I hope you realice that most of the professions out there can’t do that, for example, most of doctors have to be at the hospital to help patients, chefs can’t cook in remote, cleaners neither, etc. So, as Will.I.Am said “coders are the new rockstars”, so why not to take advantage of that? 🤔

Ideas to generate passive income.

As a mobile software developer, there are several ways you can earn passive income online. Here are a just a few ideas and I’m sure depending on your area of software expertise you would have more ideas:

1. Create and sell mobile apps: Develop useful mobile applications and release them on popular app stores. You can generate income through app sales, in-app purchases, or advertisements within the app.

2. Develop and sell app templates: Design and build mobile app templates that can be customized and used by other developers. Platforms like CodeCanyon allow you to sell your templates to a wide audience.

3. In-app advertising: If you have an existing app with a significant user base, consider integrating advertisements. Ad networks like Google AdMob or Facebook Audience Network can help you monetize your app and earn passive income based on ad impressions and clicks. Actually, this is how I get some revenue in one of my apps about football championships in Latam: futbolecuador app

4. Create premium content or features: Offer additional premium content or features within your app that users can purchase. This can include exclusive in-app items, access to advanced functionality, or subscription-based services.

5. Affiliate marketing: Promote relevant products or services within your app and earn a commission for each sale or referral. Research affiliate programs related to your app’s niche and integrate affiliate links or banners.

6. Mobile app reskinning: Purchase existing app templates or source code and modify them with new designs and themes. Reskinned apps can be published under your own brand and generate revenue through downloads, in-app purchases, or advertisements.

7. Provide app development services: Offer your expertise as a mobile app developer by freelancing or taking on client projects. This can provide a steady stream of income as you work on various projects.

Summary

Remember, earning passive income requires initial effort to create and market your products or services. It’s important to choose ideas that align with your skills, interests, and target audience.

I hope you have enjoyed this blog. If you’ve any questions, comments or suggestions please hit me up on Twitter, Linkedin or Linktr.ee.

How to generate passive income as a mobile developer? 📲💰 was originally published in Mobile App Circular on Medium, where people are continuing the conversation by highlighting and responding to this story.

As a mobile developers, most of the time we just forget to test apps in real environment's like poor network conditions (EDGE, GPRS, 3G) because our MacBooks are always connected to reliable Wi-Fi or Ethernet connections at home or office, and trust me, this happened to me a lot of times and it will blow your mind when you test your app in this scenarios, including 3G.

In this article I’ll show you how to test your apps on the simulator or on your real device using Network Link Conditioner, an additional tool that you can install on Xcode.

But first lets talk a little bit about Network Link Conditioner

What is Network Link Conditioner?

The Network Link Conditioner (NLC) is a tool that comes with Xcode, the integrated development environment for macOS. It allows developers to simulate various network conditions such as latency, packet loss, and limited bandwidth to test how their applications perform under different network conditions.

NLC provides a graphical user interface (GUI) that allows users to create custom profiles that simulate network conditions such as 3G, EDGE, DSL, and Wi-Fi. The tool also includes a set of pre-configured profiles that simulate different network conditions, including a very poor network connection with high latency and packet loss.

Using NLC, developers can test their applications under different network conditions without leaving their development environment. This tool is particularly useful for developers who need to test their applications under poor network conditions or for those who need to optimize their applications for low-bandwidth or high-latency networks.

How to install Network Link Conditioner?

To install the Network Link Conditioner on macOS, you will need to have Xcode installed on your system. Xcode is a free development environment provided by Apple, which includes the Network Link Conditioner as one of its developer tools.

Here are the steps to install the Network Link Conditioner on macOS:

1. Open the App Store on your Mac and search for “Xcode.”
2. Click on the “Get” button to download and install Xcode on your Mac.
3. Once Xcode is installed, launch it.
4. From the Xcode menu, go to “Open Developer Tool” and then select “More Developer Tools.”
5. This will take you to the Apple Developer Downloads page. Search for “Additional Tools for Xcode” and download the version that matches your Xcode version.
6. After downloading the Additional Tools, locate the file “Hardware IO Tools for Xcode” and double-click it to extract its contents.
7. Open the extracted folder, then double-click on the “Network Link Conditioner.prefPane” file to install it.
8. Follow the prompts to complete the installation process.

How to simulate a Network Connection using NLC on macOS?

Once you have installed the Network Link Conditioner, you can access it from the System Preferences pane on your Mac, under the “Other” section. From there, you can configure the network conditions you want to simulate.

1. Select a profile from the “Profile” drop-down menu, such as “3G” or “100% Loss.”
2. Click on the “Turn On” button to enable the profile.

You can also create a custom profile by clicking on the “+” button in the bottom left corner and configuring the following settings:

• Bandwidth: The maximum bandwidth allowed for the simulated network connection.
• Delay: The delay time before packets are transmitted over the simulated network connection.
• Jitter: The variation in the delay time between packets.
• Packet Loss: The percentage of packets that are lost over the simulated network connection.

Once you have configured the settings for your custom profile, you can save it by clicking on the “Save” button.

Now, with a profile selected, you can just run the app from Xcode on your physical device or simulator using one of the NLC profiles and test your app under different conditions.

How to simulate a Network Connection using NLC on iOS?

But, what if you want to use NLC directly on your iPhone? You can do it if you have the “Developer menu” active in Settings.

Go to Settings, Developer, Network Link Conditioner, choose the profile you want to test and enable it. Don’t forget to deactivate the selected profile once you’ve finished testing your apps 😉.

Summary.

In summary, using the Network Link Conditioner tool on macOS, you can simulate different network conditions to test how your applications perform under various network scenarios.

I hope you have enjoyed this blog. If you’ve any questions, comments or suggestions please hit me up on Twitter, Linkedin or Linktr.ee.

How to simulate network conditions on iOS and macOS ? 🤔 was originally published in Mobile App Circular on Medium, where people are continuing the conversation by highlighting and responding to this story.

Xcode is a powerful integrated development environment (IDE) developed by Apple for creating software applications for macOS, iOS, iPadOS, watchOS, and tvOS. It provides a comprehensive suite of tools and features to help developers design, build, and debug their applications. Xcode includes a code editor, a graphical user interface (GUI) builder, a debugger, performance analysis tools, and a wide range of frameworks and libraries that make it easier to build complex applications.

With Xcode, developers can create apps using a variety of programming languages, including Swift, Objective-C, and C++. The IDE comes with a built-in source code editor that offers features such as syntax highlighting, auto-completion, and code folding. The GUI builder, Interface Builder, allows developers to create and design user interfaces visually, without writing code.

Xcode also includes a suite of debugging tools that make it easy to find and fix bugs in your code. It offers features such as breakpoints, which allow developers to pause the execution of their code at a specific line to inspect variables and debug the application. Xcode also offers tools for analyzing application performance, identifying memory leaks, and optimizing code.

Overall, Xcode is a powerful tool that helps developers build high-quality, robust, and scalable applications for Apple’s various operating systems.

If you’re working everyday with Xcode, let me tell you that keyboard shortcuts will be you best friends when developing apps for the Apple enviroment.

Why are keyboard shortcuts hepful?

Keyboard shortcuts are useful for several reasons:

1. Efficiency: Keyboard shortcuts can save a lot of time by allowing you to quickly perform tasks without having to move your hands away from the keyboard to use the mouse or touchpad. This can be especially helpful for repetitive tasks or when working with large amounts of data.
2. Accuracy: Keyboard shortcuts can also increase accuracy by reducing the likelihood of errors that can occur when using a mouse or touchpad. With keyboard shortcuts, you can perform tasks more quickly and accurately, which can lead to a more efficient workflow.
3. Accessibility: Keyboard shortcuts can be helpful for individuals who have difficulty using a mouse or touchpad due to physical limitations. Keyboard shortcuts can provide an alternative means of performing tasks that might otherwise be difficult or impossible.
4. Consistency: Keyboard shortcuts can help ensure consistency across applications and platforms. Many applications use similar or identical keyboard shortcuts for common tasks, which can make it easier to switch between applications and platforms without having to learn new ways of doing things.

Xcode shortcuts

Here are some useful keyboard shortcuts in Xcode:

1. Command + N: Create a new file, project, workspace, or playground.
2. Command + S: Save the current file.
3. Command + Shift + O: Open a file quickly by typing its name.
4. Command + Shift + J: Reveal the current file in the Project Navigator. (this is one of my favorites 😉)
5. Command + Shift + A: Open the Assistant Editor.
6. Command + R: Run the current scheme.
7. Command + B: Build the current scheme.
8. Command + . (period): Stop the current task.
9. Command + Shift + K: Clean the project.
10. Command + Shift + Y: Show or hide the Debug area.
11. Command + Option + Enter: Enter or exit full-screen mode.
12. Command + /: Comment or uncomment selected lines of code.
13. Control + Command + Up/Down arrow: Move between header and implementation files.
14. Control + Command + Left/Right arrow: Move between open tabs.
15. Control + Command + Shift + Left/Right arrow: Move between editor and assistant editor.
16. Shift + Command + [ : Gives extra indentation space for the selected code.
17. Shift + Command + ]: Delete extra indentation space for the selected code.

These are just a few of the many keyboard shortcuts available in Xcode. By learning and using keyboard shortcuts, you can speed up your workflow and become a more productive Xcode user.

Conclusion.

Overall, keyboard shortcuts can make you a more efficient and productive computer user by allowing you to quickly perform tasks without having to rely on a mouse or touchpad. By learning and using keyboard shortcuts, you can save time, increase accuracy, and reduce the risk of errors.

I hope you have enjoyed this blog. If you’ve any questions, comments or suggestions please hit me up on Twitter, Linkedin or Linktr.ee.

Xcode shortcuts that every iOS Developer should know was originally published in Mobile App Circular on Medium, where people are continuing the conversation by highlighting and responding to this story.