DEV Community: Silvia España Gil

The 5 Stages of Grief in Tech Layoffs - a story

Silvia España Gil — Wed, 11 Dec 2024 23:00:00 +0000

^{This is my personal journey through tech layoffs and how the classic stages of grief showed up in unexpected ways. No psychology degree, just my story}

Hola Mundo!

Theory says that when we lose something important, we go through 5 stages of grief. And yes, I know that losing my job is not equal from losing a loving one, however, I discovered that going through a layoff is surprisingly similar.

So get ready for this emotional rollercoaster ride of getting laid off. 🎢

1. Denial: "This can't be happening to me" 🙈

If you read my previous post, I said that the first stage of the layoff was the rumors. And this stage was really tied up with that moment.

"These rumors must be false"
"They can't get rid of insert here your project"
"My performance is great surely I will be saved"
"Changes are normal, surely they won't layoff too many people"

Spoiler alert: Yes, the rumors can be true. Yes, they can get rid of any project or professional if they want to.

2. Anger: "They can't do this" 🤬

Sadly, yes, they can.

Anger was weird to me. I was angry but I didn't want to give them the power to make me angry.

In this stage I promise I thought about all the bad decisions I thought the company took. Trying to answer myself why they did what they did, and how everything developed until this situation.

I'm angry at the company
I'm angry at the C-levels
I'm angry at my past self for not noticing before.

The deal is that, it's normal to be angry. My best advice here would be to speak up to your friends, family or mental health provider and be careful with what you post on social media or in your slack channel. Screenshots are forever 🙃.

3. Bargaining: "If only I had" 🤔

Here we feel like we could have done something different to avoid this. And don't get me wrong, I knew I couldn't change this for the company but yes for me.

Thoughts like "If I had not be so confortable maybe I would have search another job before...". But truth is that, there are no ifs, this is sooo out of our reach.

Nothing I could have done, would have changed anything. Company decisions rarely have anything to do with you or me, unless you are a C-level!

4. Depression: "I won't find another job" 😔

This stage was TOUGH.

If any of my close friends or family are reading this. Thank you, I survived thanks to all the support I had.

Mind you this was my first job in the industry so my thoughts were pretty much like this:

"What if I was only good here?"
"What if I bomb all the interviews"
"We are mid summer, I won't find anything"
"I can't compete with my ex peers"

Remember: This is ok. Is ok to feel bad, even is ok to feel that you are not enough, but remember that not all you think is true.

Try to sleep, be kind to yourself and then be objective. For me it helped to try new things, to remember the things I did and excelled in the past.

5. Acceptance: "Finally, is official" 😌

Acceptance for me came with at end of the process. So it was pretty much 2-3 months until I was here.

And don't get me wrong, I knew the layoff was going to happen, but I was in a different stage of my grief.

I started to do some numbers to get my financials in order
Did a couple of job interviews and felt myself again
Remembered that life was not only this that I was living
Told myself that this was an opportunity and good things will happen

Bonus Track: The Revival 🌱

This was another experience. I was not alone and after some exercise I also shushed that voice that was loud during the depression stage.

There are more companies and I do have good skills. So yes, is scary, and definitely a change I was not expecting, however, this is a wave I can ride.

If you are going through this, it's okay not to be okay. Maybe you will go through all these stages, or maybe yours will be different.

I promise you, this will pass. An while it does, here's a post to remind you that you're not alone on this emotional rollercoaster 🎢❤️.

^{P.S.: If this post made you smile even a little bit or helped you in the midst of chaos, my work here is done. Share it with someone who needs it! 🙌}

Anatomía de un Layoff: del rumor al paro

Silvia España Gil — Mon, 09 Dec 2024 11:58:05 +0000

^{This post deviates from my blog's usual English content as I will be addressing the specific legal framework and emotional journey of corporate layoffs in Spain. The information and procedures discussed are particular to Spanish labor law.}

Hola Mundo!

Este año, la empresa para la que trabajaba decidió hacer un layoff. Uno de entre muchos que han estado ocurriendo en distintas empresas del sector, pero algo que se veía bastante lejano para mí, me afectó.

Y te voy a ser 100% honesta. No esperaba que me tocara esta carta, pero me tocó vivir la experiencia de primera mano en HD 😔. Así que para mantener la costumbre decidí reflexionar un poco sobre el caos, las emociones y las lecciones que trajo esta experiencia consigo e hice este post.

^{Este post está basado en mi experiencia personal y no es en lo absoluto consejo legal. No soy abogada, por lo que te recomiendo encarecidamente que busques asesoramiento profesional si te enfrentas a un despido.}

De los rumores a la realidad👂

Dice el dicho que cuando el río suena es porque piedras trae. Primero fue una reestructuración, luego alguno puestos redundantes, luego un CEO que cambia y se le sumó un cambio de estrategia.

La realidad es que estábamos pasando por una tómbola trimestral, no sabíamos qué tocaría.

Sin embargo llegó momento en el que ya se podía sentir venir, plannings con poco que planear, proyectos "on-hold" mientras se redefinía una estrategia que nadie sabía quién estaba definiendo. El amigo de Pepito se enteraba que había una lista. Los calendarios de la nada tenían reuniones con bufetes de abogados, empresas de RRHH y similares.

Se sentía.

En las sabias palabras de Gandalf: "Es la respiración profunda antes de la zambullida" 🧙‍♂️

¿Qué hacer en esta etapa? 📋

En lo personal, si existiese el árbol de la ansiedad, yo sería su fruta. Así que empecé a hacer lo que mejor hago cuando siento que pierdo el control: planificar para el peor de los casos

Infórmate: Lee el estatuto de trabajadores. Habla con gente que conozcas que haya pasado por este proceso La información es poder💡.
Mira el mercado: ¿Cómo está el mercado?, ¿qué están pidiendo?, ¿mi CV o mis conocimientos se amoldan a lo que se busca?.
Actualiza tu CV/LinkedIn: Actualiza tus perfiles, déjale reviews a tus compis y pídeles que te dejen alguna recomendación también.
Decide qué quieres hacer: Pondera si quieres esperar a que te echen o si prefieres buscar trabajo e irte si lo consigues. Para esto haz cuentas, toma una decisión racional.
Mantente activa: En mi caso decidí hacer proyectos pequeños 💻, tocar cosas que no me había atrevido antes, actualizarme un poco según lo que vi que el mercado pedía. En resumen, no me estuve quieta.

La confirmación: Bienvenido a un ERE ⚖️

^{En esta parte hablaré de cosas legales, no soy abogada, busca siempre asesoría}

En España, si nos quieren hacer un despido colectivo la empresa debe hacer un ERE. Pero cuidado que algunas empresas son listas y despiden a la gente de a poquito. Si tu empresa en 3 meses despide al 10% de su plantilla eso es un ERE, si ellos no lo dicen como tal DENUNCIEN🚨.

Recuerda también que si tu empresa intenta ofrecer regalos o algún bono, a cambio de que renuncies, no lo hagas. Si te están ofreciendo esto quiere decir que en el ERE vas a poder negociar más, esto para ellos es mas barato, les permite enmascarar el hecho de que están haciendo un despido colectivo y tu además te quedas sin paro.

Pero bueno, partamos del supuesto que la empresa hace un ERE de forma abierta. El primer paso es siempre avisar a los empleados que habrá un ERE. Y ahora viene lo bueno.

¿Qué hacer durante la confirmación del ERE?

Elegir los representantes:

Una vez la empresa avisa a los empleados su intención de hacer un ERE, nosotros tenemos, por ley, 15 días para decidir los representantes.

Ten en cuenta que los representantes son trabajadores, tus compis o tu. Y la cantidad depende del tamaño de la empresa, nosotros debíamos decidir tres representantes.

Los representantes de los trabajadores estarán en todas las reuniones de negociación con la empresa y legalmente tienen el poder de aceptar o rechazar lo que la empresa proponga.

Decidan por personas que se den a escuchar, que sean comunicativas ya que tendrán que compartir con el resto lo que se hable en estas reuniones y que tengan el tiempo y disposición de hacer esto.

¿Cómo hicimos nosotros? pues se creó el grupo de WhatsApp mas loco que he visto en mi vida, la gente se postuló e hicimos una votación por Drive.

Elegir abogados:

Con los representantes de los trabajadores elegidos, el siguiente paso es buscar abogados que nos ayuden.

Ten en cuenta que esto debe estar definido en los 15 días que da la ley ya que el día que empiezan las negociaciones ya deben estar presentes los abogados y representantes de ambas partes.

Si tu empresa dice "no se gasten el dinero, les vamos a dar un buen acuerdo" no confíen. Si la empresa les propone regalos o acuerdos extras para que renuncien no confíen.

En este momento, no confíes en la empresa, piensa que ellos ahora tienen que iniciar un proceso legal ante el estado, en el que deben por ley indemnizarte y ellos sí que están asesorándose con abogados para intentar ahorrar la mayor cantidad de dinero posible.

Nuestro grupo decidió conversar con dos grupos, los representantes nos dijeron que nos proponían esos abogados y realizamos una votación según lo que nos dijeron.

Nosotros contratamos al Colectiú Ronda, y estuvimos muy felices. En general estos abogados cobran una tarifa fija cuando inicia el proceso y luego un porcentaje por sobre lo que ellos consiguen en la negociación.

¿Qué quiere decir esto?, que mientras ellos más consiguen, más cobras tu y también ellos, claro. Entonces es un ganar-ganar.

Por ejemplo, si tu empresa les ofrece 1000€ de indemnización y los abogados te consiguen 2000€. Pues ellos cobran un porcentaje sobre los 1000€ extras que consiguieron.

Antes de que las negociaciones empiecen, trasladaremos a nuestros abogados que es lo que desearíamos obtener. Esto es una carta a los reyes magos, un ideal. Los abogados nos dirán también qué es lo normal que se ofrezca en estos casos y luego en las negociaciones intentarán obtener nuestro ideal.

Aquí hablamos de por ejemplo, incluir quedarnos los portátiles o que extiendan visas, que se tomen ciertas consideraciones con personas embarazadas o de baja, extender el seguro etc. A ver, aquí entra de todo. Podemos pedir lo que queramos, los abogados nos darán una guía e intentarán negociar todo lo que puedan.

Nosotros también definimos con los abogados dos canales de comunicación. Uno era un drive de preguntas generales, que nos podían valer a todos. Nosotros dejábamos la pregunta, ellos la respondían ahí o hacíamos una reunión para responder preguntas.

Y un segundo canal de comunicación para particularidades. Por ejemplo, si tienes jornada reducida quizás tienes dudas de cómo te afecta esto a ti. Al ser una pregunta muy específica usabas este canal para que ellos pudiesen darte respuesta a tus inquietudes. De esa forma si querías hablar de algo mas privado o personal, tenías también este espacio.

Las negociaciones 🤝

Terminados los 15 días iniciales empieza un mes de negociaciones. En este mes no hay mucho que hacer. Los abogados hablarán entre ellos.

En la primera reunión seguro la empresa dará la oferta inicial que normalmente es ABSURDAMENTE MALA. Y los abogados harán un requerimiento inicial que normalmente es ABSURDAMENTE BUENO.

Este proceso es bastante frustrante😓, pero nuestros abogados nos lo advirtieron. Ellos nos dijeron que normalmente la empresa niega todo durante 3 semanas de la negociación y es en los últimos 3 días que realmente empieza la negociación.

Mi experiencia fue 100% esa. La empresa negó TODO lo que pedimos y su oferta era mala. Finalmente el acuerdo se logró el último día de negociación.

¿Qué hacer durante las negociaciones?

Paciencia: No hay nada peor de que te digan "tranquila". Pero este proceso dura un mes. Y los avances, como comenté previamente son lentísimos. Intenta descansar, hacer cursos, lo que prefieras pero que mantenga tu mente un poco ocupada.
Confianza: Contrataste abogados, ellos harán lo mejor posible porque mientras mejor lo hagan, mejor cobran. Así que confía en lo que dicen, en lo que hacen y en la información que te brindan.
Se considerada: Durante este mes habrán reuniones para actualizar sobre las negociaciones. Nuestros representantes nos contarán cosas. Por favor se considerada, no les presiones, se respetuosa. Ellos están viviendo esto también y no es fácil.
Arma una red de apoyo: Yo hice un grupo paralelo con mis amigas. Este proceso es largo y es una montaña rusa. Apóyales cuando estén nerviosas o se sientan mal, comparte con ellas como te sientes tu. Todos somos personas, nos sentimos de formas diferentes y poder pasar por esto en compañía y no solas es un beneficio invaluable.

El desenlace: Aceptar - o no - el acuerdo 💭

Como grupo teníamos mas o menos definido que era lo mínimo que aceptaríamos. Para esto es importante escuchar y confiar en los abogados que nos mantuvieron con los pies en la tierra.

Ellos nos dijeron que era lo normal en estos procesos, lo mas esperable y así también tuvimos algunos planteamientos base que eran lógicos. Y luego los extras que todos sabíamos que si los conseguíamos sería maravilloso.

Cuando la negociación termina, nuestros abogados y representantes nos informaron de la oferta final de la empresa.

Este día también nos enteramos de quienes estábamos en la lista de despedidos y quiénes no.

Se supone que por ley nuestros representantes podrían aceptar o no el acuerdo. Sin embargo los abogados que escogimos ponen como condición de contratación que se haga una votación, la decisión final es lo que vote la mayoría.

Esto en lo particular nos gustó mucho porque de esa forma se siente un poco más transparente. Y en nuestro caso hablamos de una centena de personas que nos veíamos perjudicadas. Así que realizamos una votación en la que solo las personas perjudicadas decidían si se tomaba o no el acuerdo final.

Nosotros llegamos a un acuerdo. Si no se llega a un acuerdo el ERE igual ocurre, solo que podrás hablar con tus abogados para denunciar y llevar la decisión de la remuneración a un juzgado.

¿Qué hacer durante el desenlace?

Pregunta: Si tienes dudas, aprovecha a los abogados. ¿Está bien lo que conseguimos?, ¿podemos conseguir más si vamos a juicio?, ¿se puede negociar la lista de los que se quedan?.
Prepárate: Seguramente pronto pierdas accesos a tu cuenta de trabajo. Descarga toda la documentación que puedas necesitar luego, como nóminas o similares.
Recopila: Recopila aquellas cosas que te puedan ayudar en el futuro: tus objetivos cumplidos o proyectos exitosos, guarda tus performance reviews, métricas que demuestran tu impacto, descarga certificados de formaciones.

Fin del ere: hora de paro 🏁

Una vez se llega a un acuerdo la empresa enviará a cada persona su carta de despido. También deberán abonarte la indemnización acordada, las vacaciones pendientes y enviarte esta nómina final.

Si decides cobrar el paro es importante que sepas que debes esperar a que terminen las vacaciones pendientes. Es decir, el despido es efectivo a final de mes, pero te quedaban pendientes 10 días de vacaciones. Podrás iniciar el proceso de paro el día 11.

Esto ocurre porque la baja se hace efectiva el día que finalizan las vacaciones que ya están pagas.

Mi reflexión 🌱

Este es un proceso bastante desagradable y difícil pero tenemos la suerte de tener una legislación que nos protege como trabajadores. Recuerda siempre que, las malas decisiones empresariales no son tu responsabilidad y si te ves afectada por un ERE no es tu culpa.

No me cansaré de decirlo pero busca un grupo de abogados que te acompañen. Se buena persona siempre e intenta buscar una red de apoyo en medio de este caos🤗.

Finalmente si este post te fue de alguna utilidad, no dudes en compartirlo con otras personas ❤️🙏.

Swift 101: Control flow - Loops, conditions, switch

Silvia España Gil — Wed, 20 Nov 2024 12:50:22 +0000

Hola Mundo!

Welcome to a new article into my Swift 101 series 📝. In this new chapter I'll be sharing a little bit about Control Flow.

Today, we'll learn how to work with the data that we have stored in collections to use it and to make our code make decisions and repeat actions - just like we do in real life!

Think of it this way: when you're following a recipe 👩🏽‍🍳, sometimes you repeat actions (like stirring), make decisions (like checking if it’s cooked enough?), or choose between different options (What if I don’t have an ingredient?). Control flow in programming helps us do just that: make decisions, repeat actions, and choose paths for our code to follow.

So, let's get to it 💪!

What is Control Flow?

Control flow is the order in which our code's instructions will be executed. It's like being the conductor of an orchestra 🎭, telling each part when to play and under what conditions.

It's our code structure and it will make decisions according to the conditions that are presented.

In Swift, we have several ways to control our code's flow:

Loops for repeating tasks 🔁
Conditionals for making decisions ⚖️
Switch statement for handling multiple options 🔀

Loops: When You Need to Repeat Yourself 🔁

Loops are Swift's way of doing something multiple times. It's like when you're doing exercises - "repeat this 10 times!" 🏋️‍♀️

They are particularly powerful when working with collections. Remember those Arrays, Sets, and Dictionaries we learned about? Loops help us process each element in these collections efficiently, making it easy to perform operations on multiple pieces of data.

There are many ways to do a loop in Swift: for-in, while, and repeat

- for-in loops:

In a for-in loop, we iterate over a collection (like an array or set) and access each item one by one.

The syntax in for-in loops is pretty simple: for itemName in collectionName { what will happen }


let ingredients = ["flour", "sugar", "eggs", "milk"]
for ingredient in ingredients {
    print("Found \(ingredient) ✓")
}

// Output: 
// Found flour ✓
// Found sugar ✓
// Found eggs ✓
// Found milk ✓

- while loops:

The while loops allow us to check a condition, so Swift will keep looping on our collection while the condition is true, and will stop once the condition fails.


var temperature = 100
while temperature > 75 {
    print("Still too hot! Cooling down...")
    temperature -= 10
}
print("Ready to serve! 🍽️")

// Output:
// Still too hot! Cooling down...
// Still too hot! Cooling down...
// Still too hot! Cooling down...
// Ready to serve! 🍽️

In the example, the code inside the loop will execute while the temperature is greater than 75, when the 75 is reached then it will stop looping.

- repeat loops:

Not that common, repeat loops work similar to while loops but the condition is checked at the end.


var tastings = 1
repeat {
    print("Tasting the sauce...")
    print("Adding seasoning")
    tastings += 1
} while tastings < 3

// Output:
// Tasting the sauce...
// Adding seasoning
// Tasting the sauce...
// Adding seasoning

- Break and continue:

We may want to exit a loop during the iteration, maybe because one of many conditions are achieved. To do so we only need to write the word break. This will stop the loop.

On the other hand, we may want our loop to skip a specific condition, number, or value and continue iterating over the rest of the collection. And for this we may use the word continue.


// Use of continue. Checking spoiled ingredients
let ingredients = ["flour", "expired_milk", "eggs", "sugar"]
for ingredient in ingredients {
    if ingredient.contains("expired") {
        print(" \(ingredient) is spoiled. Skipping...")
        continue
    }
    print("Adding \(ingredient) to mixture")
}
// Output:
// Adding flour to mixture
// Milk is spoiled. Skipping...
// Adding eggs to mixture
// Adding sugar to mixture

// Use of break. Finding the first available cook
let cooks = ["busy", "busy", "available", "busy"]
for status in cooks {
    if status == "available" {
        print("Found available cook!")
        break
    }
}
// Output:
// Found available cook

Conditional Statements

As the name implies conditional statements help us to execute the code if those conditions are met or not. In Swift there are two type of conditionals: if statement and switch.

👍 By using conditionals, we can make our code more intelligent and responsive!

- if statement

if statement help us check if a condition is true, if this happens the code will get executed if not it will jump to the next condition that is true.

Imagine you want to go out hiking, you may say, "if tomorrow is sunny, I will go to the mountain". Exactly like that will work on your code, if the condition is meet, then whatever you write down, will happen!

🔎 When declaring if statement there are a couple of rules you may need to follow

if statement must be followed by a condition which value must return a boolean.
The condition must be followed by a piece of code to be executed between braces {}
This code will only be executed if the returned value is true.
else statement are optional and can be used to indicate a piece of code that will be executed when the if condition is false.
In the event that we could have many paths we can use else if to check another possible condition.

Simplified will be

if condition {
  do this
} else {
  do that
}


let ovenTemperature = 180
if ovenTemperature > 200 {
    print("Temperature too high! Lower it")
} else if ovenTemperature < 150 {
    print("Temperature too low! Increase it")
} else {
    print("Temperature is perfect!")
}
// Output:
// Temperature is perfect!

In the example we have a piece of code that checks on the oven temperature. if the temperature is over 200, will print that is too high, if is down 150 will say is too cold, if none of those conditions are meet that means that the temperature is perfect.

The else statement is optional, so you may only want something to happen and if the condition is not meet you don't want the code to do anything.


let bakingTime = 30

if bakingTime == 30 {
    print("Open the oven")
} 

// Output:
// Open the oven

- Multiple conditions for an `if`

There's the possibility that we may need to check multiple conditions for something to happen. In this case we could use logical operators like && (AND) and || (OR) to combine conditions in our if condition.

let hasIngredients = true
let hasRecipe = true

if hasIngredients && hasRecipe {
    print("Let's start cooking!")
} else {
    print("We need to prepare better")
}
// Output:
// Let's start cooking!

In the example we want to check if both conditions are meet. So if we have both ingredients and recipe, we can start cooking. Otherwise we can't.

- Ternary operators

Ternary operators are if statements but with a one line syntax. The syntax is A ? B : C

✨ Where ✨

A is the condition we want to check
B is the code to execute if A is true (the if)
C is the code to execute if A is false (the else)

let kitchenIsClean = true
kitchenIsClean ? print("Ready to cook!") : print("Clean kitchen first!")
// Output:
// Ready to cook!

Switch

switch statements allow us to compare the value of a condition with many cases until it finds one that matches.

To use a switch statement there are some things to take into consideration:

The conditional must be initiated with the switch word
Each case we want to evaluate goes with a name and two points to be executed case caseName:
When the condition matches a case the code will be executed and the switch will end. This means that no other conditions will be checked
Similar to an else statement, the default code will be executed if no case matches.

let mealType = "dessert"
switch mealType {
    case "breakfast":
        print("Serving from 7-11 AM")
    case "lunch":
        print("Serving from 12-3 PM")
    case "dinner":
        print("Serving from 6-10 PM")
    case "dessert":
        print("Available all day!")
    default:
        print("Kitchen closed")
}
// Output:
// Available all day!

In the example, Swift will check each case until it finds the one that matches the condition and will execute the code, in this case, a print.

- Switch with Interval Matching

One of the switch characteristics is that it allows us to check inside intervals for a match.

let temperature = 175
switch temperature {
    case 1...100:
        print("Too cold!")
    case 101...160:
        print("Getting there...")
    case 161...180:
        print("Perfect temperature!")
    case 181...300:
        print("Too hot!")
    default:
        print("Check thermometer!")
}
// Output:
// Perfect temperature!

This demonstrates how you can use switch statements in Swift to match ranges of values, which is a very powerful way to handle different conditions that fall within specific intervals.

- Compound cases

Just as the interval matching allows us to check a range, compound cases allow us to add many values to a same case.

let cookingMethod = "baking"
switch cookingMethod {
    case "baking", "roasting":
        print("Use the oven")
    case "frying", "sautéing":
        print("Use the stove")
    case "steaming", "boiling":
        print("Use a pot with water")
    default:
        print("Check recipe for method")
}
// Output:
// Use the oven

- Switch with Enums

Remember the Enums we learned in the previous article? switch statements work great with them! In fact, when using switch with enums, Swift requires us to handle all possible cases or include a default case this gives an extra layer of security, knowing that you are handling all cases in your enum.

This combination of enum and switch is one of the most powerful features in Swift. Since enums have a finite set of cases, and switch must be exhaustive, Swift can guarantee at compile time that we're handling all possible scenarios - making our code safer and more maintainable.

enum CookingStatus {
    case preparing
    case cooking
    case ready
    case burned
}

let status = CookingStatus.cooking
switch status {
    case .preparing:
        print("Getting ingredients ready")
    case .cooking:
        print("Keep an eye on the temperature!")
    case .ready:
        print("Time to serve!")
    case .burned:
        print("Order takeout...")
}
// Output:
// Keep an eye on the temperature!

When using switch with enums🕵🏽‍♀️:

You don't need to specify the enum type in each case (writing .cooking)
Swift will verify that you covered all possible cases
If you don't want to handle all cases, you must include a default
The compiler will give you an error if you miss a case and don't have a default

By using control flow statements, we can enhance the logic and functionality of our code. They provide a clear way to handle different scenarios and repetitive tasks, making your code more organized and expressive.

I hope this overview helps you appreciate the power of control flow in Swift and inspires you to continue learning this amazing language! 🤍

Want to keep learning about Swift?

This a full series on Swift 101, the next chapter will be Functions and closures, so I hope to see you there!

Remember that you can always go further into this information by checking the official documentation and courses here

If you enjoyed this, please share, like, and comment. I hope this can be useful to someone and that it will inspire more people to learn and code with Swift

How to Easily Use Feature Flags in Swift with Firebase

Silvia España Gil — Mon, 16 Sep 2024 10:36:42 +0000

Hola mundo!

I always like to start my posts by explaining why I’m writing an article, but feel free to skip this part if you’re in a hurry🏃🏽‍♀️.

Back at my first job, there were these refinement sessions where they’d say, "Should we protect this with a Feature Flag?" At that time, I had no idea what a Feature Flag was. When I finally asked a team member and learned about it, my mind was blown🤯. It felt like magic 🔮 – a way to safely roll out changes without fear of breaking the app. If something went wrong, you could just flip the Feature Flag. Simple as that!

In that project, we used LaunchDarkly for managing Feature Flags. However, I recently discovered that Firebase has a feature for setting Feature Flags too, and the setup is ✨ SO EASY and user-friendly ✨ that I immediately fell in love with it. I couldn’t wait to share this with you!

Today, I’m excited to show you how to implement Feature Flags in an iOS app using SwiftUI and Firebase Remote Config.

If you’ve never used Feature Flags before, you’re in for a treat. This powerful tool lets you control your app’s features in real-time, without pushing updates to the App Store 🙌!

So, let's get to it 💪!

What’s a Feature Flag?.

Before getting into the code, let’s quickly cover what a Feature Flag is. Imagine you’re working on an awesome new feature for your app, but you’re unsure whether to roll it out to all users or just a select few.

Or perhaps the feature is quite big, and you want to start with the UI first, then add the business logic in stages.

Feature Flags are your best friends here! They’re like switches you can toggle to turn functionalities on or off in real-time. No need to create new app versions and submit them to the Store.

They’re fantastic for A/B testing, gradual rollouts, or controlling features during special events. Sounds amazing, right?

Let’s get it set up!💻

📢For the complete code used in this tutorial, be sure to check out my GitHub repository📢

👉🏽 Step 1: Set Up Firebase in your iOS Project.

First, you need to add Firebase to your project. Here’s how:

1) Add Firebase to Your Xcode Project:

Open your project in Xcode.
Go to "File" > "Add Packages..." and enter the Firebase repository URL: https://github.com/firebase/firebase-ios-sdk.
Choose the Firebase Remote Config package and add it to your project.

2) Configure Firebase in Your App:

Go to the Firebase Console and create a new project.
Follow the instructions to add an iOS app to your Firebase project (the guide is pretty straightforward).
Download the GoogleService-Info.plist file provided and add it to your Xcode project.

👉🏽Step 2: Initialise Firebase.

Now that Firebase is set up we have to initialise it and use it. Let’s create a simple Proof of Concept (PoC) to see the power of Feature Flags in action.

1) Initialise Firebase in your app

Add this code to your AppDelegate. You can check the official Firebase documentation if you need more details.



class AppDelegate: NSObject, UIApplicationDelegate {

  func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {

    FirebaseApp.configure()

    return true
  }
}

Now in your app entry point, use UIApplicationDelegateAdaptor to link your AppDelegate



@main
struct FirebaseFeatureFlagsApp: App {
    @UIApplicationDelegateAdaptor(AppDelegate.self) var delegate

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

👉🏽Step 3: Configure Remote Config in Firebase

Now, let’s set up the Feature Flags in the Firebase Remote Config Console:

1) Add parameters in Firebase Console:

Go to your Firebase Console and select the Remote Config option.
Once in Remote Config, select the button Add parameter
- Choose the parameter name and the data type for the param
- Optional you can add a description, this is always a good idea
- Now set the default value that you want.
- Publish the changes

👉🏽Step 4: Create a view that will use the Feature Flag

To visualize it, let’s create a simple view where the background colour changes based on the Feature Flag. As you may see in the code there's a boolean value isBlueBackgroundEnabled that changes certain things including the background and the text colour.

This value is my Feature Flag.




struct ContentView: View {
    @State private var isBlueBackgroundEnabled = false

    var body: some View {
        ZStack {
            (isBlueBackgroundEnabled ? Color.blue.opacity(0.5) : Color.pink.opacity(0.5))
                .edgesIgnoringSafeArea(.all)

            HStack {
                Text("Hello, Feature Flags!")
                    .font(.title)
                    .foregroundColor(isBlueBackgroundEnabled ? .white : .black)

                Image(systemName: "heart")
                    .imageScale(.large)
                    .foregroundColor(isBlueBackgroundEnabled ? .white : .black)
                    .onTapGesture {
                        fetchRemoteConfig()
                    }
            }
        }
        .onAppear {
            fetchRemoteConfig()
        }
    }
}

👉🏽Step 5: Fetch the Feature Flag value from Firebase

🔎Please note the .onAppear method in the previous example 🔎

As you see in our view I've called fetchRemoteConfig() this method retrieves the current Feature Flag configuration from Firebase.

Here’s how it works:



extension ContentView {
    private func configureRemoteConfig(_ remoteConfig: RemoteConfig) {
        let settings = RemoteConfigSettings()
        settings.minimumFetchInterval = 0 
        remoteConfig.configSettings = settings
        remoteConfig.setDefaults([
            "isBlueBackgroundEnabled": NSNumber(value: false),
            "isNewFeatureEnabled": NSNumber(value: false)
        ])
    }

    private func fetchRemoteConfig() {
        let remoteConfig = RemoteConfig.remoteConfig()
        configureRemoteConfig(remoteConfig)

        remoteConfig.fetch { status, error in
            if status == .success {
                remoteConfig.activate { _, _ in
                    // Access your Feature Flags here
                    self.isBlueBackgroundEnabled = remoteConfig["isBlueBackgroundEnabled"].boolValue
                    // Add all your Feature Flags
                }
            } else {
                print("Error fetching remote config: \(String(describing: error))")
            }
        }
    }
}

🤔Curious about how these methods work? Let me break it down a bit for you🤔

1) configureRemoteConfig(_:): This method sets up the Remote Config instance with settings. The minimumFetchInterval of 0 is for development purposes, meaning you can fetch data from Firebase without waiting.
setDefaults sets a default value for the Feature Flag, which is used if there’s no configuration fetched.

2) fetchRemoteConfig(): This method is where the magic happens. It starts by fetching the latest configuration from Firebase. If the fetch is successful, it activates the new configuration and updates the Feature Flag state based on the fetched value. If something goes wrong, it prints an error message.

📢For the complete code used in this tutorial, be sure to check out my GitHub repository📢

🎉Check what you did

Now for the fun part. 🏗️Build your code.

If you set your Feature Flag to false, you should see a lovely pink background. Change the value to true in the Remote Config Console, and voila 🪄 your background colour will change!

And there you have it! Implementing Feature Flags with Firebase Remote Config is straightforward and incredibly powerful🔥. You can toggle features in real-time without needing to update the app, which makes your development process more flexible and efficient.

I hope this guide helps you make your apps more dynamic and lets you experiment with new features with confidence🚀.

If you enjoyed this, please share, like, and comment. I hope this can be useful to someone and that it will inspire more people to learn and code with Swift 💻✨

Swift 101: Enumerations

Silvia España Gil — Thu, 05 Sep 2024 10:35:17 +0000

Hola Mundo!

Welcome to a new article in a series of Swift 101 notes 📝 I created these notes while learning the language and decided to share them because why not?

If you're new to Swift or interested in learning more about this language, I invite you to follow my series! 🙊

In my last post, I shared the third part of collections which was Tuples and Dictionaries. And this week is the time for Enumerations, one of my favourites collection types.

So, let's get to it 💪!

As a quick refresher, "Collections" are types that store multiple values of the same type in an organized structure. These include Arrays, Sets, Tuples, and Dictionaries, which we have discussed in previous articles.

Today, we'll focus on Enumerations. While not a collection in the traditional sense, enums group related values together in a type-safe manner, making them a powerful tool for modelling sets of options or states in your code.

Think of it like a fruit basket with many fruits in it. Similarly, arrays in Swift store multiple values of the same type in an ordered list, like a line of apples, oranges, and bananas neatly arranged in your basket 🍎🍊🍌

There are many types of Collections, like Arrays, Sets, Tuples and Dictionaries which we already discussed. Today, let's talk about ✨Enumerations✨.

Enumerations

Enums (short for enumerations) in Swift are a powerful type that allows you to group related values together in a type-safe way. They are commonly used to model a set of related choices or states in your code.

By default, Swift will assume that our enum is a String unless we indicate otherwise.

Here are some important characteristics and rules about Enums in Swift:

Fixed Set of Values: Enums define a finite set of possible values (called cases). Once an enum is defined, you cannot add or remove cases, unless you change the Enum.
Type Safety: Enums provide type safety by ensuring that any value associated with an enum is one of the predefined cases. This makes your code safer and easier to read.

How to declare an Enum

To declare an Enum you will have to use the enum keyword followed by the enum's name and define the possible cases inside curly braces. Each case is introduced with the case keyword.

By default, Swift will assume that our enum is a String unless we indicate otherwise.

Here's an example of how to declare and use an enum:


enum Movement {
    case forward, back, left, right
}

enum Movement {
    case forward
    case back
    case left
    case right
}

🔎Please note that you can declare it in one or many lines. 🔎

Enum RawValue

When declaring an enum, we can decide to initialise it with an initial value. This allows the enum to work with these raw values and gives us the possibility to either use the enum case or map the values itself.

Here’s how to define and use an enum with raw values:

enum Movement: String {
    case forward = "Move Forward"
    case back = "Go Back"
    case left = "Turn Left"
    case right = "Turn Right"
}

let action = Movement.right
print(action.rawValue)
// Output: Turn Right

When setting a type for the RawValue we can use any of the types that we have available in Swift.

enum StatusCode: Int {
    case success = 200
    case notFound = 404
    case serverError = 500
}

let code = StatusCode.notFound
print(code.rawValue) // Output: 404

Enums Managing: Using Enums Effectively

Modifying Enum

Enums in Swift are immutable by definition, meaning once they are declared with a case, they cannot change. However, you can assign a different case to the enum type.

For example:


enum Movement {
    case forward
    case back
    case left
    case right
}

// Assign to a variable an initial case
var currentMovement = Movement.forward
// Change the variable value to another case
currentMovement = .left

In the example, we never change the value of the enum itself, but we do change the variable's value to use another declared case.

Attempting to assign a non-existent case or trying to set a new value to an existing case results in an error:

❌ currentMovement = .up  
//  error: type 'Movement' has no member 'up'
// This error occurs because 'Movement' does not define a case named 'up'.

❌ Movement.forward = .up
// error: cannot assign to property: 'forward' is not settable
// This error occurs because enum cases are constants and cannot be reassigned.

Accessing and using Enums

To access a specific case of an enum, you simply use the variable and the enum case as shown before. Enums in Swift are type-safe and provide a clear way to handle different states or values.

var currentMovement = Movement.forward
print(currentMovement)
// Output: forward

Enums can be also used to execute a code depending on each case. This brings a lot of flexibility and allows us to create more complex interfaces.

switch currentMovement {
case .forward:
    print("Moving forward")
case .back:
    print("Moving back")
case .left:
    print("Turning left")
case .right:
    print("Turning right")
}
// Output: Moving forward

Enum methods

Enums in Swift can also have methods associated with them, which allows you to define behaviours based on the enum cases. Methods inside an enum can provide additional functionality related to the enum's state.

enum AccountState {
    case active
    case onHold
    case inactive
    case deleted

    func description() -> String {
        switch self {
        case .active:
            return "Active account"
        case .onHold:
            return "Pending approval"
        case .inactive:
            return "Inactive account"
        case .deleted:
            return "Deleted account"
        }
    }

    func color() -> UIColor {
        switch self {
        case .active:
            return .green
        case .onHold:
            return .yellow
        case .inactive:
            return .gray
        case .deleted:
            return .red
        }
    }
}

// Example of using the methods
let state = AccountState.active
print(state.description())  // Output: Active account
print(state.color())        // Output: green

Methods in Enums: We can define methods within an enum to encapsulate specific behaviour to the cases. The methods can use the switch statement to handle each case and provide different functionalities based on the current case.
Multiple Methods: We can create as many methods as needed within an enum. Each method should cover all possible cases of the enum or provide a default case to handle any unforeseen cases.

👍By defining methods in enums, you can make your code more organized and expressive, as the enum can encapsulate both its data and behaviour cohesively.👍

By using enums, we can enhance the safety and readability of our code. They provide a clear way to handle different states or values, making your code more organised and expressive.

Enums encapsulate both data and behaviour, allowing us to define methods that operate based on the enum's cases. This results in more maintainable and understandable code.

I hope this overview helps you appreciate the power of enums in Swift and helps you keep learning this amazing language!🤍

Want to keep learning about Swift?

This a full series on Swift 101, the next chapter will be Control Flow: Loops, Conditionals and Switch in Swift, so I hope to see you there!

Remember that you can always go further into this information by checking the official documentation and courses here

If you enjoyed this, please share, like, and comment. I hope this can be useful to someone and that it will inspire more people to learn and code with Swift

Swift 101: Collections part III - Tuples and Dictionaries

Silvia España Gil — Mon, 17 Jun 2024 13:38:39 +0000

Hola Mundo!

Welcome to a new article in a series of Swift 101 notes 📝 I created these notes while learning the language and decided to share them because why not?

If you're new to Swift or interested in learning more about this language, I invite you to follow my series! 🙊

Last week I shared a post with the second part of collections which was sets. Next week, I'll share the last part of collections with Enums!

So, let's get to it 💪!

As a quick refresher, "Collections" are types that store multiple values. They arrange all those values in certain ways so we can access them in the future.

There are many types of Collections, like Arrays and Sets which we already discussed. Today, let's talk about ✨Tuples and Dictionaries✨.

Tuples

Tuples are a collection type that allows us to group multiple values into a single compound value. These values can be of different types, making tuples a flexible way to group related values together.

Here are some important characteristics and rules about tuples in Swift:

Fixed Size: The number of elements in a tuple is fixed when you create it. You cannot add or remove elements after the tuple is created.
Immutable Types: While you can change the values within a tuple, you cannot change the types of the elements. The types of the elements are defined when the tuple is created and must remain the same.

How to declare a Tuple

Declaring a tuple in Swift is really easy. You simply enclose the elements in parentheses and separate them by commas. You can also name the elements for easier access.

Here's an example of how to declare and use a tuple:


var character = (name: "Aragorn", nickname: "Strider", ageOfDeath: 219)
print(character) 
// Output: (name: "Aragorn", nickname: "Strider", ageOfDeath: 219)

❌ You can't declare an empty tuple, because of the characteristics previously explained. Doing so will show an error in Xcode❌

Tuples Managing: Accessing Values

Modifying Tuples

As with any variable, we can change the values of our Tuple. However, one of the main characteristics of the Tuples is that we cannot change their elements or types.

To update a Tuple, we can do:


✅ character = (name: "Arwen", nickname: "Undomiel", ageOfDeath: 2901)

Attempting to assign values differently will result in an error:


❌ character = (name: "Frodo")
// Error: cannot assign value of type '(name: String)' to type '(name: String, nickname: String, ageOfDeath: Int)'

Accessing Tuples

To access a tuple value, we must only take the name of the variable and reference the element we want to access.

var character = (name: "Aragorn", nickname: "Strider", ageOfDeath: 219)
print(character.name)
// Output: Aragorn

We can also access one element of our Tuple and then change its value, while the rest of the elements remain with the old value.

var character = (name: "Aragorn", nickname: "Strider", ageOfDeath: 219)

character.name = "Aragorn, son of Arathorn"
print(character.name)
// Output: Aragorn, son of Arathorn
print(character)
// Output: (name: "Aragorn, son of Arathorn", nickname: "Strider", ageOfDeath: 219)

Tuples methods and properties

Tuples in Swift do not have any properties or methods. They are a value type that only groups values. However, there are a couple of operations possible with tuples:

Access to elements

We already showed that we can access an element using its name, but we can also do so using the index

var character = (name: "Aragorn", nickname: "Strider", ageOfDeath: 219)

print(character.name)
// Output: Aragorn

print(character.1)
// Output: Aragorn

Decomposition

You can decompose the tuple into separated variables

let (name, nickname, ageOfDeath) = character

print(name) // Output: Aragorn
print(nickname) // Output: Strider
print(ageOfDeath) // Output: 219

Comparison

You can compare tuples if the elements are comparable.

var character = (name: "Aragorn", status: "Married")

let anotherCharacter = (name: "Arwen Undomiel", status: "Married")

print(character == anotherCharacter) // Output: false

print(character.status == anotherCharacter.status) // Output: true

Dictionaries

Dictionaries are another collection type available in Swift. Dictionaries are stored not in a numeric position (index) but with a key.

How to declare a Dictionary

To declare a dictionary, we must specify the key type inside brackets [ ] and the value using a colon.

var emptyDictionary = [String: String] = [:]
emptyDictionary["keyName"] = "Value"
print(emptyDictionary) //Output:["keyName": "Value"]

var characterDetails = [
"Aragorn": "Son of Arathorn, also known as Strider",
"Frodo": "Bearer of the One Ring",
"Gandalf": "The Grey, later known as Gandalf the White"
]

print(characterDetails["Aragorn"])
// Output: Son of Arathorn, also known as Strider

Dictionaries Managing: Accessing Values

Accessing values with iterations

We can access dictionary values by iterating on their values. When iterating through a dictionary, both keys and values can be accessed if needed.


var characterDetails = [
"Aragorn": "Son of Arathorn, also known as Strider",
"Frodo": "Bearer of the One Ring"
]

for (key, value) in characterDetails {
  print("\(key) also known as \(value)")
}
/* Possible output:
Aragorn also known as Son of Arathorn, also known as Strider
Frodo also known as Bearer of the One Ring*/

💢Note that when iterating over Dictionaries in Swift, the elements may be returned in an unordered manner for efficiency reasons.💢

Accessing values using the key

We may access a dictionary using the key name if we know it in advance.

print(characterDetails["Aragorn"])
//Output: Son of Arathorn, also known as Strider

We may also store all the keys or all the values in a new collection to use.

let characterNames = characterDetails.key
print(characterNames)
//Output: ["Frodo", "Aragorn"]

let characterDescription = characterDetails.values
print(characterDescription)
//Output: ["Son of Arathorn, also known as Strider", "Bearer of the One Ring"]

Adding new values to an existing dictionary

To add a new value to an existing dictionary we should follow the next syntax dictionaryName[NewKey] = NewValue

var characterDetails = [
"Aragorn": "Son of Arathorn, also known as Strider",
"Frodo": "Bearer of the One Ring"
]

//New value
characterDetails["Galadriel"] = "Lady of Lothlórien, Nenya bearer"

print(characterDetails)
//Output: ["Frodo": "Bearer of the One Ring", "Galadriel": "Lady of Lothlórien, Nenya bearer", "Aragorn": "Son of Arathorn, also known as Strider"]

Dictionaries methods and properties

`.updateValue()`: Allows us to update the value of an existing key

characterDetails.updateValue("Just a hobbit", forKey: "Frodo")
print(characterDetails["Frodo"])
//Output: "Just a hobbit"

`.remove()`: Allows us to remove a value completely from our dictionary.

characterDetails.removeValue(forKey: "Frodo")
print(characterDetails)
//Output: ["Aragorn": "Son of Arathorn, also known as Strider", "Galadriel": "Lady of Lothlórien, Nenya bearer"]

`.removeAll()`: Allow us to remove all the values in the dictionary.

characterDetails.removeAll()
print(characterDetails)
//Output: [:]

`.isEmpty()`: Returns a boolean reflecting if the dictionary is empty or not

print(characterDetails.isEmpty)
//Output: true

`.count()`: Count all the elements inside the dictionary

var characterDetails = [
"Aragorn": "Son of Arathorn, also known as Strider",
"Frodo": "Bearer of the One Ring"
]
print(characterDetails.count)
//Output: 2

Want to keep learning about Swift?

This a full series on Swift 101, next chapter will be the final part of Collections where I will share about Enums, so I hope to see you there!

Remember that you can always go further into this information by checking the official documentation and courses here

If you enjoyed this, please share, like, and comment. I hope this can be useful to someone and that it will inspire more people to learn and code with Swift

Peerstiquette: Good Manners for Remote Collaboration

Silvia España Gil — Wed, 12 Jun 2024 09:44:48 +0000

Hola Mundo!

You might not know this, but before becoming an iOS Developer, I worked and taught Communication and Marketing for about 12 years📆!

And why is this important, you may ask yourself. Well, in my course I loved to talk about Netiquette because well, being behind a screen, people sometimes forget their manners.

Then, last year, when preparing my talk for Software Crafters Barcelona, I decided to twist the concept and adapt it for communication between peers. This is extendable to any communication between mentors and mentees and, well...basically everyone.

What is Netiquette

Before diving into Peerstiquette, I want to talk about Netiquette because this has significantly changed how we communicate online.

In 1994, Virginia Shea wrote Netiquette, a whole book with rules to communicate better in the emerging online world💾.

Virginia's rules may sound like common sense. However, a quick look at any social media platform reveals that a lot of people just skipping them all!😈 These rules are also quite general and apply to all forms of online communication.

But then in 1995, Sally Hambridge, who at that moment worked at Intel wrote the Request For Comments: 1855. As Intel began using emails for daily communication💻, the goal was to provide guidelines for effective communication in a corporate environment.

What is Peerstiquette

When I learned about Netiquette, I became obsessed🫶. I think it's an amazing concept that, sadly, most people forget. And then when I started in tech I noticed how much Netiquette helped me in my relationships with mentors.

Time passed by and I adapted Virginia's and Sally's to my day-to-day communications and then thought, maybe I could create my own Peerstiquette. So, ✨here we are✨

Peerstiquette is a decalogue of what I believe are 🎯ten essential rules for communicating with peers, mentors, and mentees in online environments🎯, especially when working fully remotely.

Each "rule" is quite self-explanatory but I'll add some context for clarity if you want to check it out!

Please notice that I have done this design and you can download it or use it if you want it. But please🙏, I really ask for respect so if you use it don't delete my name from it and if you create your own version I would love to have some credit

1. Respect the other person's time

Be mindful of your colleagues' schedules and time zones. Avoid contacting them outside of their working hours and be considerate of their time when scheduling meetings or expecting responses.

If you set a time to chat or call someone be punctual, be there. Try to not surpass the time set for the call, if you need to extend it, ask if is ok or schedule a new slot.

2. Do not call without notice or demand immediate response

Respect your peers' focus and workflow by avoiding unscheduled calls. Instead, send a message first to arrange a suitable time for a call. If possible let the person know with anticipation what the call is for, and give them context so they can go prepared if necessary.

Be patient and do not expect immediate responses to your messages or emails. Understand that if the person is busy, maybe they will see the message in a while.

3. Communicate clearly, preferably in a single message

We have all seen a chat like this...and is not nice. We don't want to hear 100 times the message sound of slack

Ensure your communication is clear and concise. Try to include all relevant information in a single message to avoid back-and-forth exchanges and to also avoid the other person receiving lots of notifications that may be interrupting.

4. Do not ask questions you haven't attempted to solve

Before asking for help, make sure you have tried to find a solution on your own. This shows initiative and respect for your colleagues' time.

If you still need some help, you could explain what you have tried so far to provide context and then work together toward solving the issue.

5. Do Not Judge

Maintain a non-judgmental attitude towards your colleagues. Everyone has different strengths, weaknesses, and ways of working. If they ask for your help, or they fail to help you with an issue try to keep a supportive and understanding environment.

This is extendable to personal decisions, never by no reason, judge anyone for their looks, religious beliefs, background, ethnicity, origin, sexuality, etc

6. Use appropriate, respectful language

Always use respectful and professional language in your communications. Avoid slang, jargon, or any language that could be misunderstood or deemed inappropriate.

Remember to use the person preferable pronouns, do not use nicknames unless are widely accepted by the other person and of course, leave out any sexist, racial, or diminishing comment.

7. Accept constructive feedback and a no as an answer

Be open to receiving constructive feedback and use it as an opportunity for growth.

Similarly, respect your colleagues' boundaries and understand that they may sometimes need to say no to a call, meeting, or request.

8. Share Your Progress and Setbacks

We love to ask for help but sometimes after we receive that help we never go back to the person to say thank you or to let the other know how was everything solved in the end.

When needed keep others informed about your progress and any setbacks you encounter.

Transparency helps in building trust and allows the team to support each other effectively. Regular updates can also prevent miscommunication and misalignment.

9. Respect the privacy of image and information when applicable

Be mindful of privacy concerns. Do not share images or sensitive information without permission.

If you take a screenshot where the other person's face is shown, or want to record a session, ask for permission. Also if you later want to publicly share that image let the other implicated know that so they can decide if they set their cams on or off.

When working with corporate information ensure that any shared data complies with privacy regulations and the company's policies.

10. Do not expect others to solve your problems

Take responsibility for your tasks and challenges. While seeking help is fine, do not rely on others to solve your problems entirely. Show initiative in addressing issues and finding solutions.

When asking for help, if the other person does not have the knowledge or tools to help you, be thankful and seek solutions in other ways.

I hope you find this decalogue interesting and that it might be helpful. Would you add another rule to it? Let me know!

And if you liked my post, please feel free to give me credit, like it or share it 🫶

Swift 101: Collections Part II - Sets

Silvia España Gil — Mon, 10 Jun 2024 16:46:53 +0000

Hola Mundo!

Welcome to a new article in a series of Swift 101 notes 📝 I created these notes while learning the language and decided to share them because, why not?

If you're new to Swift or interested in learning more about this language, I invite you to follow my series! 🙊

Last week I shared a post with the first part of collections which was arrays. Initially, I thought I would cover collections in two parts, but who wants to read that much in one go 🙅🏽‍♀️? So, this will be the second part of what will likely be four parts. Next week, I'll share and try to cover Tuples and Dictionaries.

So, let's get to it 💪!

As a quick refresher from last week's chapter, "Collections" are types that store multiple values. They arrange all those values in certain ways so we can access them in the future.

There are many types of Collections, like Arrays which we already discussed. Today I want to share about ✨Sets✨.

Sets

Sets, like arrays and other collections, allow us to store many elements of the same type in a variable. However, sets store the values without any particular order.

The main characteristics of sets are:

Order: Sets do not have a defined order; they store values in the way that Swift thinks is most effective.
Elements can’t repeat itself: On sets all element values must be unique. If there’s a duplicated one it will be ignored.

swift

let colors = Set(["red", "green", "blue"])
print(colors)
// Output: ["red", "blue", "green"]

let colors2 = Set(["red", "green", "blue", "green"])
print(colors2)
// Output: ["green", "red", "blue"]

To declare an empty set you specify the type of elements it will hold using the Set keyword followed by the type in angle brackets:
var mySet = Set<Int>()

You can also declare a set with initial values. Swift will infer the type of the set based on the type of the initial values:
var mySet: Set = [1, 2, 3, 4, 5]

or, specifying the type explicitly:

var mySet: Set<Int> = [1, 2, 3, 4, 5]

🔥 Remember that Sets do not maintain the order of elements and that repeated elements will be ignored 🔥

Sets managing: accessing values and methods

Accessing sets values

Since sets have no specific order, we must access their elements using loops or by using their methods and properties.

Iterations on sets

To iterate over a set, we can use the for-in loop. This allows us to access each element in the set one by one.

let fellowshipMembers: Set = ["Frodo", "Aragorn", "Gandalf", "Legolas", "Gimli", "Merry", "Pippin", "Boromir"]

for member in fellowshipMembers {
    print(member)
}

// Output: This will print all the members

🧐 Remember that Sets do not maintain the order of elements 🧐

Set methods and properties

Swift also provides us with some methods and properties that we may use and that can be useful for different operations.

Let's see the most used:

`.count`

This property counts how many elements are inside our Set.

let letter: Set = ["w", "e", "f", "o", "x"]
print(letter.count)
// Output: 5

`.insert()`

This method allows us to add new elements to our Set.

var groceryList: Set = ["Onions", "Apples", "Pasta"]
groceryList.insert("Bread")
print(groceryList) 
// Possible output: ["Pasta", "Onions", "Bread", "Apples"]

`.remove()`

Allows us to remove an element from the set

var groceryList: Set = ["Onions", "Apples", "Pasta"]
groceryList.remove("Pasta")
print(groceryList) 
// Possible output: ["Onions", "Apples"]

`.removeAll()`

This method empties the Set of all its values.

var groceryList: Set = ["Onions", "Apples", "Pasta"]
groceryList.removeAll()
print(groceryList) 
// Output: []

`.contains(_:)`

This method checks if the Set contains a specific element.

var numbers: Set = [3, 63, 27]
let containsTwentySeven = numbers.contains(27)
print(containsTwentySeven) 
// Output: true

`.isEmpty`

This property checks if the Set is empty and returns a boolean result.

var numbers = [3, 63, 27]
print(numbers.isEmpty) // Output: false

Sets operations

`.union(_:)`

This method returns a new set containing all elements from both sets. Since sets cannot have duplicate values, any value that appears in both sets will only appear once in the union.

let fellowshipOfTheRing: Set = ["Frodo", "Sam", "Merry", "Pippin", "Aragorn", "Legolas", "Gimli", "Boromir", "Gandalf"]
let charactersInRohan: Set = ["Aragorn", "Legolas", "Gimli", "Gandalf", "Eomer", "Eowyn", "Theoden"]
let allCharacters = fellowshipOfTheRing.union(charactersInRohan)
print(allCharacters) 
// Possible output: ["Sam", "Merry", "Pippin", "Legolas", "Aragorn", "Gimli", "Eowyn", "Frodo", "Theoden", "Eomer", "Boromir", "Gandalf"]

`.intersection(_:)`

This method returns a new set with only the elements common to both sets.

let fellowshipOfTheRing: Set = ["Frodo", "Sam", "Merry", "Pippin", "Aragorn", "Legolas", "Gimli", "Boromir", "Gandalf"]
let charactersInRohan: Set = ["Aragorn", "Legolas", "Gimli", "Gandalf", "Eomer", "Eowyn", "Theoden"]
let commonCharacters = fellowshipOfTheRing.intersection(charactersInRohan)
print(commonCharacters) 
// Possible output: ["Aragorn", "Legolas", "Gandalf", "Gimli"]

`.subtracting(_:)`

This method returns a new set with the elements of the first set that are not in the second set.

let fellowshipOfTheRing: Set = ["Frodo", "Sam", "Merry", "Pippin", "Aragorn", "Legolas", "Gimli", "Boromir", "Gandalf"]
let charactersInRohan: Set = ["Aragorn", "Legolas", "Gimli", "Gandalf", "Eomer", "Eowyn", "Theoden"]
let uniqueToFellowship = fellowshipOfTheRing.subtracting(charactersInRohan)
print(uniqueToFellowship) 
// Possible output:["Boromir", "Frodo", "Pippin", "Sam", "Merry"]

`.symmetricDifference(_:)`

This method returns a new set with elements that are in either of the sets but not in both.

let fellowshipOfTheRing: Set = ["Frodo", "Sam", "Merry", "Pippin", "Aragorn", "Legolas", "Gimli", "Boromir", "Gandalf"]
let charactersInRohan: Set = ["Aragorn", "Legolas", "Gimli", "Gandalf", "Eomer", "Eowyn", "Theoden"]
let differentCharacters = fellowshipOfTheRing.symmetricDifference(charactersInRohan)
print(differentCharacters)
// Possible output:["Pippin", "Boromir", "Eomer", "Merry", "Sam", "Frodo", "Eowyn", "Theoden"]

Resources

If you want a Cheat Sheet with some of these methods and properties, feel free to save or download this image. If you share it please do not delete or hide my name 🫶🏻

Also if you want to keep learning more about this I highly recommend checking the official documentation and courses here

Want to keep learning about Swift?

This a full series on Swift 101, next chapter will be the third part of Collections where I will share about Tuples and Dictionaries, so I hope to see you there!

If you enjoyed this, please share, like, and comment. I hope this can be useful to someone and that it will inspire more people to learn and code with Swift

Swift 101: Collections Part I - Arrays

Silvia España Gil — Wed, 29 May 2024 15:19:41 +0000

Hola Mundo!

Welcome to a new article in a series of Swift 101 notes 📝 I did while learning the language and I decided to share them because why not?.

If you're new to Swift or interested in learning more about this language, I invite you to follow my series! 🙊

In this chapter, I'll share Part I of Collections and Collection Types, where we'll dive into Arrays.

A couple of weeks ago, we discussed constants and variables, which store values for us to use in our code and some simple types. However, there are some other complex types that we will find across our apps📱.

As you may already guess, "Collections" are types that store many values. They arrange all those values in certain ways so we can access them in the future.

Arrays

Arrays are an ordered collection of values and are the most common collection type. Inside an array, we may store any kind of elements of the same type.

Arrays are one of the most commonly used collection types in Swift due to their simplicity and efficiency. Arrays maintain an ordered list of elements. This makes them ideal for scenarios where the order of elements matters, such as lists of items or sequences of tasks.

To create an array, we separate elements with commas and enclose them in square brackets.

let intArray = [1, 2, 3]
let stringArray = ["Mónica", "Rachel", "Phoebe"]

Typing our arrays

As with everything in Swift, arrays are also typed. If we don’t indicate it explicitly, Swift will infer the type for us.

However, for Swift to be able to infer the type, the values inside the array must be homogeneous, meaning all values must be of the same type. This is called array literals.

If we don't type our array, and the values are heterogeneous, we will get an error ❌, and Swift will ask us to add an explicit type to ensure the mixed types are intentional.

To set a type to an array we must indicate it after the naming just as we do in simple variables and constants.

If we want to create a heterogenous array or we don’t know which kind of values we will hold in that variable we can set the Any type -not recommendable-

Strong typing in Swift ensures that each array can only contain elements of a specific type.

This could prevent many common programming errors and make your code more predictable and easier to debug. By specifying the type of elements Swift can also optimize performance and provide better compile-time checks.

// All values are the same type
let homogenousArray: [Double] = [1.4, 2.6, 3.7]
let alsoHomogenousArray: [String] = ["Pippin", "Merry", "Frodo", "Sam"]


// Values types may be different so type is Any
let heterogenousArray: [Any] = [8, "Kobe Bryant", 24.8]

Classes and structs as types

Until now we have been using the most common types to type all of our values. However, while dealing with our apps, especially if they interact with APIs or complex data, we may need to manage arrays with heterogeneous types.

If you scroll back, I said that we can use Any as a type, but I also said that is not a really good idea🙅🏽‍♀️. But if Swift gives us that option, why is it not a good idea?

Typing makes our code more reliable, and safer🛟. We know always what kind of value we are going to find in that variable. With Any we lose that advantage. We may also cause compilation issues, overcomplicate our code, etc.

But we can overcome this by using classes or structs as types.

Let’s imagine that we have a newsletter and we need an array with the user name, email, and confirmation that it wants to receive an email. And we are going to store that in an Array. So first we could create a struct and then assign it as a type.

struct User: Identifiable, Hashable {
    let id: Int
    let name: String
    let email: String
    let permission: Bool
}
var registeredUsers: [User]

In Swift, structs and classes are both used to create complex data types, but they have some key differences. Structs are value types, which means they are copied when assigned to a new variable or constant, or when passed to a function.

Classes, on the other hand, are reference types, so they are passed by reference and can have inheritance.

Generally, is a better idea to use structs for simpler data types that do not require inheritance and classes for more complex types that benefit from inheritance.

✨Further details on classes and structs will come later on in the series, so don't forget to follow me and keep an eye on new updates.✨

Array managing: accessing values and methods

Accessing array values

We now know that an array, as a collection, can store one or many values, but to use them we will probably need them separated and to do so we need to access those values.

Using the value index

One way of accessing our array values is by calling the index. As arrays are ordered collections if nothing explicitly changes, the value in a certain position will always be the same.

let hatchNumbers = [4, 8, 15, 16, 23, 42]
let thirdHatchNumber = hatchNumbers[2]
print(thirdHatchNumber) // 15

🧐 Remember that the array index starts at 0. So the first value is index 0 and so on. 🧐

Iterations or loops: For-in and while

There are two ways to iterate an array. One you may use while using SwiftUI in the views and the other one the rest of the time, but don't worry, they are pretty similar.

If you want to know more about this, keep an eye on this series because I'll be writing about Control Flow however, in the meanwhile, we will hammer the most common here: For-in loops

Loops can be imagined as a spiral, each loop of the spiral is an item. So, when we iterate an array, we circle the array over and over.

Imagine we have an array with the Fellowship of the Rings names and I want to access the name of each one of them. We could check the array using a for in loop and print the values.


let fellowshipMembers = ["Frodo", "Sam", "Gandalf", "Aragorn", "Legolas", "Gimli", "Boromir", "Merry", "Pippin"]

// Access elements
for member in fellowshipMembers {
  print(member)
}

What is going to happen is that Swift is going to check each member inside the fellowshipMembers array and will print the nine values.

Frodo
Sam
Gandalf
Aragorn
Legolas
Gimli
Boromir
Merry
Pippin

We can also do the iteration but add a clause in it. For doing so we will have to add a where in the loops.

// Leave Frodo out
let fellowshipMembers = ["Frodo", "Sam", "Gandalf", "Aragorn", "Legolas", "Gimli", "Boromir", "Merry", "Pippin"]
for member in fellowshipMembers where member != "Frodo" {
  print(member)
}

This will print all the Fellowship members but will skip Frodo.

There’s another way to do a loop by evaluating a condition, and that is using while. Basically, we ask Swift that while a condition happens, do something.

Think of it as when you are cooking, while you see flour, whisk the mix. Then you understand that if the flour is not visible anymore you can stop whisking.

while condition {
  do this
}

Let’s imagine that we want to allow Frodo to gather 3 things

var itemsToCollect = ["Ring", "Lembas Bread", "Elven Cloak", "Light of Eärendil", "Mithril Coat"]
var thingsCollected = 0

while thingsCollected < 3 {
    print("Frodo has collected: \(itemsToCollect[thingsCollected])")
    thingsCollected += 1
}

This will print us this

Frodo has collected: Ring
Frodo has collected: Lembas Bread
Frodo has collected: Elven Cloak

While we are looping an array we may want to access to the index value of the element and call the enumerated() method with the array. For doing so we may call the index in the loop.

// Print with index
let fellowshipMembers = ["Frodo", "Sam", "Gandalf", "Aragorn", "Legolas", "Gimli", "Boromir", "Merry", "Pippin"]
for (index, member) in fellowshipMembers.enumerated() {
  print("Member number \(index + 1): \(member)")
}

This will print

Member number 1: Frodo
Member number 2: Sam
Member number 3: Gandalf
Member number 4: Aragorn
Member number 5: Legolas
Member number 6: Gimli
Member number 7: Boromir
Member number 8: Merry
Member number 9: Pippin

🧐 Remember that the array index starts at 0. So the first value is index 0 and so on. 🧐

Array methods and properties

We already know how fundamental are Arrays, they allow us to store multiple values in a single variable, making it easier to manage collections of data.

But to truly harness the 💪power of arrays💪, it's essential to understand the various methods and properties that Swift provides for working with them. And that also makes it so much easier to work with them.

What are Array Methods and Properties?

Properties are characteristics of an array that provide information about the array itself. For instance, properties can tell you the number of elements in an array or whether the array is empty.

Methods are functions that perform actions on the array. They can help you add, remove, or find elements within the array, and perform other useful operations.

By learning these methods and properties, you can effectively manipulate arrays and make your code more efficient and readable.

Let's see the most used:

`.count`

This property counts how many elements are inside an array.

var numbers = [1, 2, 3, 4]
print(numbers.count) 
// Output: 4

`.append()`

This method allows us to add new elements to the end of the array.

var groceryList = ["Onions", "Apples", "Pasta"]
groceryList.append("Bread")
print(groceryList) 
// Output: ["Onions", "Apples", "Pasta", "Bread"]

`.insert()`

This method allows us to add new values to the array at a specific index.

var groceryList = ["Onions", "Apples", "Pasta"]
groceryList.insert("Bread", at: 1)
print(groceryList) 
// Output: ["Onions", "Bread", "Apples", "Pasta"]

`.remove(at:)`

This method removes the element at a specific index in the array.

var groceryList = ["Onions", "Apples", "Pasta"]
groceryList.remove(at: 0)
print(groceryList) 
// Output: ["Apples", "Pasta"]

`.removeAll()`

This method empties the array of all its values.

var groceryList = ["Onions", "Apples", "Pasta"]
groceryList.removeAll()
print(groceryList) 
// Output: []

`.filter()`

This method, filters our array. It creates a new array with the values that satisfy a condition.
For example, let's filter our array to create a new one with all the values that are less than 3.

var numbers = [1, 2, 3, 4]
let filtered = numbers.filter { $0 < 3 }
print(filtered) 
// Output: [1, 2]

`.map()`

This method transforms each value of the array and returns a new array with the transformed values.

var numbers = [1, 2, 3, 4]
let mappedNumbers = numbers.map { $0 * 2 }
print(mappedNumbers) 
// Output: [2, 4, 6, 8]

`.forEach()`

This method performs an action for each value in the array.

var groceryList = ["Onions", "Apples", "Pasta"]
groceryList.forEach { print($0) }
/* Output: 
   Onions
   Apples
   Pasta
*/

`.sort(by:)`

This method sorts or rearrange the values inside the array according to a condition.

For example here we can sort them from smaller to higher.

var numbers = [10, 24, 3, 73, 5]
numbers.sort(by: { $0 < $1 })
print(numbers) 
// Output: [3, 5, 10, 24, 73]

`.first`

This property returns the first element of our array.

var numbers = [3, 63, 27]
print(numbers.first) 
// Output: 3

`.last`

This property returns the last element of the array.

var numbers = [3, 63, 27]
print(numbers.last) 
// Output: 27

`.removeFirst()`

This method removes the first element of the array.

var groceryList = ["Onions", "Apples", "Pasta"]
groceryList.removeFirst()
print(groceryList) 
// Output: ["Apples", "Pasta"]

`.removeLast()`

This method removes the last element of the array.

var groceryList = ["Onions", "Apples", "Pasta"]
groceryList.removeLast()
print(groceryList) 
// Output: ["Onions", "Apples"]

`.firstIndex(where:)`

This method returns the index of the first value that satisfies a condition.

var numbers = [3, 63, 27]
let firstIndex = numbers.firstIndex(where: { $0 > 10 })
print(firstIndex!) // Output: 1

`.shuffled()`

This method returns a new array with the elements shuffled.

var numbers = [3, 63, 27]
let shuffled = numbers.shuffled()
print(shuffled) 
// Output: [27, 3, 63] (order will vary)

`.reverse()`

This method reverses the order of the elements in the array.

var groceryList = ["Onions", "Apples", "Pasta"]
groceryList.reverse()
print(groceryList) 
// Output: ["Pasta", "Apples", "Onions"]

`.allSatisfy(_:)`

This method returns true if all elements satisfy a condition, otherwise false.

var numbers = [3, 63, 27]
let allGreaterThanTen = numbers.allSatisfy { $0 > 10 }
print(allGreaterThanTen) // Output: false

`.contains(_:)`

This method checks if the array contains a specific element.

var numbers = [3, 63, 27]
let containsTwentySeven = numbers.contains(27)
print(containsTwentySeven) 
// Output: true

`.isEmpty`

This property checks if the array is empty and returns a boolean result.

var numbers = [3, 63, 27]
print(numbers.isEmpty) // Output: false

Resources

If you want a Cheat Sheet with some of this methods and properties, feel free to save or download this image. If you share it please do not delete or hide my name 🫶🏻

Also if you want to keep learning more about this I highly recommend checking the official documentation and courses here

Want to keep learning about Swift?

This a full series on Swift 101, next chapter will be the second part of Collections where I will share about Sets, Tuples and Dictionaries, so I hope to see you there!

If you enjoyed this, please share, like, and comment. I hope this can be useful to someone and that it will inspire more people to learn and code with Swift

Swift 101: Basic Operators

Silvia España Gil — Thu, 23 May 2024 13:48:07 +0000

Hola Mundo!

Welcome to a new article in a series of Swift 101 notes 📝 I did while learning the language and I decided to share them because why not?.

If you're new to Swift or interested in learning more about this language, I invite you to follow my series!🙊

In this chapter, I'll be sharing a little bit about Basic Operators in Swift.

In the last chapter, we discussed constants and variables, which store values for us to use in our code.

When working with these values, we often need them to interact with each other. So, how do we accomplish this?
✨ Enter operators✨

Operators are special symbols that enable us to perform various operations on our variables. These operations can assign or change the value of a variable, allow us to compare one variable with another, or apply logic in our code.

Arithmetic operators ➕

Even if the "Arithmetic" name sound kinda scary, these operators are pretty simple and easy to understand.

Arithmetic operators are basically symbols that allow us to create mathematical calculations, additions, subtractions, multiplications, and divisions.

Operation	Action	Example	Result
Addition +	Addition between two values	var addition = 34 + 4	print(addition) Output: 38
Subtraction -	Subtract operation between values	var subtraction = 34 - 4	print(subtraction) Output: 30
Multiplication *	Multiplication of values	var multiplication = 30 * 2	print(multiplication) Output: 60
Division /	Division calculation	var division = 30 / 2	print(division) Output: 15

And yes, the logic says that this kind of operator only works with numeric types. However, Swift also allows us to do an addition operation with String-type variables. This is called string concatenation and it will put together in order different strings.

var magicSpell = "Accio 🪄 "
var object = "Nimbus 2000"
var completeSpell = magicSpell + object
print(completeSpell) 
// Output: "Accio 🪄  Nimbus 2000"

Please notice that ✨this is not the only way✨ to put two strings together but as this is a Basic Operators article we will not get in-depth with other ways to do so.

Modulo operator

Modulo or remainder operator % returns the value that is left after you divide two numbers.

var moduleA = 10 % 3
var moduleB = 10 % 5
print(moduleA) // 1
print(moduleB) // 0

Understanding modulo. If we divide 10 / 3 the quotient is 3 with a remainder of 1. This means that if we do 10 % 3, the result is 1.

Similarly, if we divide 10 / 5 the quotient is 2 which is already a whole number, meaning that there is no remainder from the operation. Therefore, 10 % 5 results in 0.

For me, this was one of the hardest operators to understand🤦🏽‍♀️, so I wrote down an example that helped me:

Imagine we have ten apples 🍎🍎🍎🍎🍎🍎🍎🍎🍎🍎 and there are three very hungry people, so we want to share the apples between all of us.
🧑‍🎤 - 🍎🍎🍎
👨‍🎤 - 🍎🍎🍎
👩‍🎤 - 🍎🍎🍎
If we want all of us to have the same amount of apples, we will each eat three apples. And there will be an extra apple 🍎 all lonely without a human to eat it. Well, that apple is the module of the first ten! Is the remainder of 10 % 3

Assignment and compound operators

This kind of operator will assign a value to a variable or constant.

The mother of the assignment operators is the equal operator 🟰. We have already used it in the previous chapter and is the one that says to Swift this value should be assigned to this variable or constant

var variableName: <Variable Type> = <Initial value>
var anotherVariable: <Variable Type>

However, the equal operator can be mixed with the arithmetic operators so it does a mathematical calculation and assign the value at the same time.

Equal `=`

The value from the right will be assigned to the one on the left.

var a = 10
var b = 100
a = b
print(a) Output: 100

Addition `+=`

The value from the right will be added and assigned to the one on the left.

var a = 10
var b = 5
a += b
print(a) Output: 15

Subtraction `-=`

The value from the right will be subtracted and assigned to the one on the left.

var a = 10
var b = 5
a -= b
print(a) Output: 5

Multiplication `*=`

The value from the right will be multiplied and assigned to the one on the left.

var a = 10
var b = 5
a *= b
print(a) Output: 50

Division `/=`

The value from the right will be divided and assigned to the one on the left.

var a = 10
var b = 5
a /= b
print(a) Output: 2

Modulo `%=`

It will calculate the modulo and assign it to the variable on the left.

var a = 10
var b = 5
a %= b
print(a) Output: 0

Comparison operators

These operators allow us, as the name states, to compare the value from the left side to the one on the right to check if the condition is true or false.

Equal to `==`

The value on the right is equal to the one on the left.

let a = 10
let b = 100
let c = (a == b)
print(c)  Output: false

Not equal to `!=`

The value on the right is not equal to the one on the left.

let a = 10
let b = 100
let c = (a != b)
print(c)  Output: true

Greater than `>`

The value on the left is greater than the one on the right.

let a = 10
let b = 100
let c = (a > b)
print(c) Output: false

Less than `<`

The value on the left is smaller than the one on the right.

let a = 10
let b = 100
let c = (a < b)
print(c)  Output: true

Greater or equal to `>=`

The value on the left is greater than or equal to the one on the right.

let a = 100
let b = 100
let c = (a >= b)
print(c)  Output: true

Less or equal to `<=`

The value on the left is smaller than or equal to the one on the right.

let a = 100
let b = 10
let c = (a <= b)
print(c)  Output: false

Logical operators

Logical operators allow us to check or set some rules based on logic. They compare two different conditions and tell us if the comparison between them is true or false.
Logical operators are particularly useful for making decisions in our code, as they enable more complex condition checking.

There are three Logical Operators:

And &&: Check if both conditions are true → This and that are true

let a = 10
let b = 10
let c = ((a <= b) && (a == b))
print(c) // Output: true

In the example, we check if a(10) is less or equal than b(10) and if a(10) is the same as b(10). As both of the conditions are true, then the output would be true.

Or ||: Check if at least one of the conditions are true → This or that are true

let a = 10
let b = 100
let c = ((a <= b) || (a == b))
print(c) // Output: true

In the example, we check if a(10) is less or equal than b(100) or if a(100) is the same as b(10). In this case, the first condition is true, but the second is false. As we want to know if one or the other is true, effectively, one of them is true so the output will also be true.

Not !: Returns true if the operand is false and vice versa

print(!true) // Output: false

In the example, we print the negation of true which is false

Want to keep learning about Swift?

So far, we've looked at what Swift is, explored types, variables, and constants, and now we've seen how basic operators can help us perform calculations, compare values, and make decisions in our code. But... there's more to come! 👩🏽‍💻

This is a full series on Swift 101. The next chapter will be the first part of Collections and Collection Types, so I hope to see you there 🫶!

If you enjoyed this, please share, like, and comment. I hope this can be useful to someone and that it will inspire more people to learn and code with Swift.

Swift 101: Understanding Types, Variables, and Constants

Silvia España Gil — Tue, 14 May 2024 14:37:30 +0000

Hola Mundo!

This is the second article in a series of Swift 101 notes 📝 I did while learning the language and I decided to share them because why not?.

So if you don't know what Swift is or you would like to know more about this language, I invite you to follow my series!🙊

In this chapter I'll be sharing a little bit about Types, Variables and Constants and how they work and behave in Swift.

Swift is a strongly typed language, but what does that mean? It means that at the moment that the code compiles all variables and constants types are known and they cannot be changed after declaring it.

To know so, Swift will first check the variable or constant and check if we have declared the type. If we haven’t Swift will take the first value assigned and set it.

If you have worked with other heavily typed languages like for example Java, C#, or C++ then you must know that Swift works similarly.

However, if you have no experience in coding, or have more experience in languages such as Javascript, ✨that is what happened to me when I learned Swift✨, this might be new for you.

Variables and constants

Variables and constants are a sort of storage location that we create and associate with a certain name so we can use it along our code. Is a container for a value📦.

As their name state variables are flexible in the sense that after declaring it, their value can change. However, constants can’t, their value is set and it cannot be changed.

To use these containers and their value we must first declare them. To do so we must use var or let followed by a keyword that will work as a name.



var variableName = <Initial value>
let constantName = <Initial value>

So for example, let's think of a variable. We could have the userPhone that they can change later on. So we store the userPhone in a variable, and later, in a method we change it for the new one.

In the case of constants is the contrary, we have information that the user can't change. For example, delicate data like an ID number might be not editable because it's inherent to that user. So that kind of data will be stored in a constant.

Variable and constant naming

Naming a variable or constant can be tricky sometimes. The names can be composed of letters, numbers, and underscore. However, depending on the team conventions sometimes the underscore is not used and we use camelCase, which means that each time a word starts we put it in capital letters, it would look like this: thisIsTheNewVariable

Variables and constants names should also be self-explanatory, which means that is not a good practice to use namings such as var password and var password2. Because what does password2 mean, what does it do🤔?

Is better to set names as var currentPassword and var newPassword. This way, as soon as you see the naming you already know what is stored.

If at a certain point, you find yourself not knowing how to name something just ask yourself, what does this storage? what does it do? And go in that direction.

Basic Swift Types

As stated before when we create either a variable or constant we should set its type or Swift will set it for us 🎯.

For declaring a type we will create our variable or constant followed by : and the type name. If it already has a value we will follow the type with the = and the initial value but this last part is not necessary.



var variableName: <Variable Type> = <Initial value>
var anotherVariable: <Variable Type>

There are many types in Swift, however, the most basic ones may be separated into two categories: individual data types and collection types.

Individual data types

As the name states these types tell the system that the value that we are storing is a single value. There are six main individual data types, three of them for different kinds of numbers, two of them with words, and the last one for booleans.

Let's have a look at them 👀

Type name	Description	Example
Int	It reads as integers. This type is used for whole numbers	var integer: Int = 2
Double	Is another number-related type that represents 64-bit floating numbers (with decimals). Double range is set to 15 digits ≈	let pi: Double = 3.14159265358979323
Float	Is used to represent 32-bit floating numbers. Float range is set to 7 digits ≈	let shorterPi: Float = 3.1415926
String	To represent text, it may be words or sentences. The name comes from a string of characters.	var greetings: String = "Welcome"
Character	This is for a single character, such as a letter, digit, and even punctuation mark or symbols.	var initial: Character = "W"
Bool	Represents one of two possible values: true or false	var isThisABool: Bool = true

As I said before, Swift is a strong typed language, so, if we don’t set the type, our variable or constant will be assigned by the system.

How does Swift automatically assign types? It checks the variable value and sets it.



// Will be typed as a "String"
var variableA = "It's me a Mario"
// Will be typed as a Bool
var isYoshiAvailable = false

Collection data types

On the other hand, we have collection data types. Collections are types that contain multiple values. This means that one variable or constant can store many values in it.
There are many collection types in Swift but we are going to talk about them in another chapter of Swift 101.

So keep an eye on the next posts of this series🤓!

Resources

If you want a Cheat Sheet with the individual data types information, feel free to save or download this image. If you share it please do not delete or hide my name 🫶🏻

Also if you want to keep learning more about this I highly recommend checking the official documentation and courses here

Want to keep learning about Swift?

This a full series on Swift 101, next chapter will be about Basic Operators in Swift, so I hope to see you there!

If you enjoyed this, please share, like, and comment. I hope this can be useful to someone and that it will inspire more people to learn and code with Swift

Swift 101: What's Swift?

Silvia España Gil — Sat, 04 May 2024 09:52:16 +0000

Hola Mundo!

Ready for some Swift?

This is my first article in a series of Swift 101 notes 📝 I did while learning the language and I decided to share them because why not?.

Well and also because I received so many nice and encouraging comments on my Twitter account that made me super happy 💖.

When I first started mobile development and read about Swift I was quite confused because the only Swift I knew was the bank code 🙈!

So, let's get to it.

What is Swift?

Swift is an open-source programming language specifically designed by Apple Inc. for development across the entire Apple ecosystem. While it's primarily associated with iOS development for iPhones and iPads, Swift is also utilized for macOS, watchOS, visionOS, and tvOS applications.

So whether you're building a mobile app, a desktop application, or software for wearable devices or home entertainment systems, Swift provides a unified language and toolset.

On its creation, Apple wanted to move away from C and ended up with an original object-oriented language that, in their words, aims to be new, modern, faster, and easier, allowing developers to produce expressive code.

“was inspired by drawing ideas from Ruby, Python, C#, CLU, and far too many others to list”

Chris Lattner

What is SwiftUI?

On the other hand, we have SwiftUI. SwiftUI is a Swift framework that allows us to describe and control the user interface. So basically it helps us build, what the user sees.

However, SwiftUI is quite new, and you may encounter some challenges building some things that you could solve with UIKit. UiKit was the former framework used to design the interface but that has been updated to SwiftUI. However I heavily recommend you to try and find SwiftUI solutions, even if they look harder, I've found that doing so is a great exercise to learn

Swift vs. SwiftUI

I know you could be thinking, aren't both the same thing? But no, they are not, Swift and SwiftUI are not the same but they are complementary ones for each other.

Swift is the programming language, the one that says our app what our program should do. SwiftUI is a Swift framework, interface-oriented that controls the aspect of our application.

"Building an app is the process of writing Swift code to control SwiftUI"

Paul Hudson

How to code with Swift? -

IDE

As with all languages, to code we need an IDE. An IDE is an Integrated Development Environment, in simpler words is a code editor in which developers can write and build code.

If you want to build iOS apps with Swift you will need XCode. This IDE is available in the App Mac Store and on the Developer's Resources page, here

XCode is only intended to run on Mac and it allows us to create full-on projects for mobile, wearables, and tv.

If you don't have a Mac but still want to try some Swift you may download Swift Playgrounds on iPad or use an online tool like Online Swift Playground

Want to keep learning about Swift?

This a full series on Swift 101, next chapter will be about Types, variables, and constants in Swift, so I hope to see you there!

If you enjoyed this, please share, like, and comment. I hope this can be useful to someone and that it will inspire more people to learn and code with Swift

DEV Community: Silvia España Gil

The 5 Stages of Grief in Tech Layoffs - a story

Hola Mundo!

1. Denial: "This can't be happening to me" 🙈

2. Anger: "They can't do this" 🤬

3. Bargaining: "If only I had" 🤔

4. Depression: "I won't find another job" 😔

5. Acceptance: "Finally, is official" 😌

Bonus Track: The Revival 🌱

Anatomía de un Layoff: del rumor al paro

Hola Mundo!

De los rumores a la realidad👂

¿Qué hacer en esta etapa? 📋

La confirmación: Bienvenido a un ERE ⚖️

¿Qué hacer durante la confirmación del ERE?

Las negociaciones 🤝

¿Qué hacer durante las negociaciones?

El desenlace: Aceptar - o no - el acuerdo 💭

¿Qué hacer durante el desenlace?

Fin del ere: hora de paro 🏁

Mi reflexión 🌱

Swift 101: Control flow - Loops, conditions, switch

Hola Mundo!

What is Control Flow?

Loops: When You Need to Repeat Yourself 🔁

- for-in loops:

- while loops:

- repeat loops:

- Break and continue:

Conditional Statements

- if statement

- Multiple conditions for an if

- Ternary operators

Switch

- Switch with Interval Matching

- Compound cases

- Switch with Enums

Want to keep learning about Swift?

How to Easily Use Feature Flags in Swift with Firebase

Hola mundo!

What’s a Feature Flag?​.

👉🏽​ Step 1: Set Up Firebase in your iOS Project​.

👉🏽​Step 2: Initialise Firebase​.

👉🏽​Step 3: Configure Remote Config in Firebase

👉🏽​Step 4: Create a view that will use the Feature Flag

👉🏽​Step 5: Fetch the Feature Flag value from Firebase

🎉​Check what you did

Swift 101: Enumerations

Hola Mundo!

Enumerations

How to declare an Enum

Enum RawValue

Enums Managing: Using Enums Effectively

Modifying Enum

Accessing and using Enums

Enum methods

Want to keep learning about Swift?

Swift 101: Collections part III - Tuples and Dictionaries

Hola Mundo!

Tuples

How to declare a Tuple

Tuples Managing: Accessing Values

Modifying Tuples

Accessing Tuples

Tuples methods and properties

Access to elements

Decomposition

Comparison

Dictionaries

How to declare a Dictionary

Dictionaries Managing: Accessing Values

Accessing values with iterations

Accessing values using the key

Adding new values to an existing dictionary

Dictionaries methods and properties

.updateValue(): Allows us to update the value of an existing key

.remove(): Allows us to remove a value completely from our dictionary.

.removeAll(): Allow us to remove all the values in the dictionary.

.isEmpty(): Returns a boolean reflecting if the dictionary is empty or not

.count(): Count all the elements inside the dictionary

- Multiple conditions for an `if`

What’s a Feature Flag?.

👉🏽 Step 1: Set Up Firebase in your iOS Project.

👉🏽Step 2: Initialise Firebase.

👉🏽Step 3: Configure Remote Config in Firebase

👉🏽Step 4: Create a view that will use the Feature Flag

👉🏽Step 5: Fetch the Feature Flag value from Firebase

🎉Check what you did

`.updateValue()`: Allows us to update the value of an existing key

`.remove()`: Allows us to remove a value completely from our dictionary.

`.removeAll()`: Allow us to remove all the values in the dictionary.

`.isEmpty()`: Returns a boolean reflecting if the dictionary is empty or not

`.count()`: Count all the elements inside the dictionary

`.count`

`.insert()`

`.remove()`

`.removeAll()`

`.contains(_:)`

`.isEmpty`

`.union(_:)`

`.intersection(_:)`

`.subtracting(_:)`

`.symmetricDifference(_:)`

`.count`

`.append()`

`.insert()`

`.remove(at:)`

`.removeAll()`

`.filter()`

`.map()`

`.forEach()`

`.sort(by:)`

`.first`

`.last`

`.removeFirst()`

`.removeLast()`

`.firstIndex(where:)`

`.shuffled()`

`.reverse()`

`.allSatisfy(_:)`

`.contains(_:)`

`.isEmpty`