DEV Community: Ione Souza Junior

Why Understanding, Not Just Generating Code, Still Matters

Ione Souza Junior — Fri, 02 May 2025 13:12:00 +0000

In the last few weeks, everybody has been talking about vibe coding and how easily you can develop an entire system, from zero to hero. This is blowing the minds of most people, and I'll talk about it in today's post. But, before talking about vibe coding, I'll talk about "normal coding" 🤔. Let's do it!

Normal coding? WTF??

Calm down, guys. I’m a Senior Software Engineer who develops mobile applications, but I’ve been learning Python and Django since February, and I’m using the expression “normal coding” to refer to the default process to develop software: learn, practice, develop, and repeat it over and over again.

Learning

I took great courses at Pluralsight. Actually, I completed two Pluralsight paths with a lot of courses in each one. The first one was Python 3 Path, and the second one was Building Web Applications with Django Path. Both are excellent resources to learn and remember how the web works and how to apply these concepts using Python. Maybe you don’t know, but I already worked with web development full time until 2014. So, for me, learning Python and Django was like remembering how to develop for the web.

Practicing

Between each course that I took, I developed some tiny applications just for practicing the concepts of each course module. It was a good moment to understand the Python style, main tools, and which code editor provides the best coding experience.

Fun fact: sometimes I feel a little bit lost when changing the language that I’m coding in. It’s very common to leave Swift and go back to C# and try to create methods using the func keyword, or just try to put curly braces into Python code to define a function. Does this happen with you too?

Developing

When I finished these courses, I started to think about a software to develop, and an Anki board solution came to my mind. I’m studying English, so I like to use an Anki board to practice words and expressions commonly used day-to-day. I know there are a lot of options for this kind of software. Even so, I thought about developing my own flash cards solution, and then I started.

The flash cards saga

During the development time, I learned a lot about the Python way to develop and how Django works. If you’re fluent in Python, I truly believe you know about:

Creating a requirements file for each flavor (debug / release) is good to split developer dependencies from production dependencies.
Adding the folder __pycache__ into the .gitignore file to avoid putting the Python generated files in version control.
Using some linter to improve code style and understanding how to configure it.
Creating a Django app to put your code, because you can’t do this in the main project.
Mapping your Django models to manage its data in the Django admin.
Using the debug toolbar to understand the reason for some bottlenecks, mainly when you use the magic Django ORM to load data into an HTML file.
The importance of the empty __init__.py file when we create a folder and want to make it a separated package.
The importance of avoiding using datetime.now() and replacing it with timezone.now() to avoid naive datetime.
And so much more!

I know you, Python developer, already know all of these things, but for me, a newbie in Python and Django, all of it was new.

I spent two days making this small app, and it was really fun for me. I didn’t use AI for coding, but I used AI just as a consultant, where I validated my plan about how to develop my flash cards app, and asked questions about the Python way to develop software.

Maybe you think this funny. but during development, I through to create some “interfaces” and make an abstraction until I discover the duck type.

If you’re feeling curious, here is the repository with the source code.

Validation and networking

After version 1.0 was finished, I talked with some colleagues to seek feedback. Where I’m working, there are a lot of great Software Engineers who know a lot about this stack, so I believe they’re the best guys to help me in this learning journey. I received some good feedback about decisions that I made well or not.

But the main insight is here: I could learn and understand a lot of concepts just by practicing, developing, and seeking feedback from other experienced engineers. Now I feel capable of continuing my project and my journey through Python.

The vibe coding idea

After this, I made an experiment: try to reproduce the same Python app just using vibe code, and the result really surprised me.

To do this, I used VS Code, an extension called Cline configured in Act mode, and Gemini 2.5 Pro Preview 03-25, which is amazing. I made two attempts. The first one using a simple and very generic prompt, and a second one using a more detailed prompt. Let’s talk about them.

First attempt

The idea here was to create a simple prompt that just expressed the main goal. My script was:

Create a web-based app in Python and Django. This app is a Flash Cards app, where I need to show my decks and have a possibility to open it and study my cards.

After this, Cline did the following:

Python version verification.
The creation of a virtual environment and the activation of it.
The creation of a Django project.
The creation of a Django app.
The registration of the new app into settings.py.
The models creation into models.py.
The creation and execution of migrations.
The implementation into the views.py.
The insertion of views references into the urls.py.
The HTML creation.
The models configuration into the Django admin.
The super user creation into the database.
The server initialization by command line.

All of it just took a few minutes (or seconds), and I had the entire project created. I tried to open the browser, but I saw a 404 error. Following the vibe coding, I just sought help using a new prompt:

I can’t see the first screen because I get a 404 error. Here is the message: Page not found (404) Request Method: GET Request URL: http://127.0.0.1:8000/ Using the URLconf defined in flashcards_project.urls, Django tried these URL patterns, in this order: admin/ cards/ The empty path didn’t match any of these. You’re seeing this error because you have DEBUG = True in your Django settings file. Change that to False, and Django will display a standard 404 page.

Looking at the message, it’s easy to understand, but I did vibe coding here, and I delegated this fix to the AI.

After this, the project worked very well and I could see my new flash cards app. But there was a problem: when I opened a deck, I saw all my cards, with the front and back text appearing together. My app wasn’t finished properly, because I didn’t provide enough context.

I thought about continuing talking with the chat to improve this code, but I had another idea: create a detailed prompt.

Second attempt

For the second attempt, I thought about a well-detailed prompt. So, here it is:

Create a web-based app in Python and Django. This app is a Flash cards app. This app only I’ll use, locally. I don’t have the necessity to publish it. So, to store data, I want to use SQLite. Python needs to be the version 3.11.4, and Django 5.2. This project should be called as “flashcards”, and the main app should be called “core”. Create two models, one for the decks, and another one for cards. The “Deck” model should have the following properties: name (max_length=50), and last_studied (nullable and blank). The “Card” model should have the following properties: deck_id, front (max_length=100), back (max_length=100), last_review_date (nullable and blank), and next_review_date (nullable and blank). The first screen should have my list of decks. In this screen, I want to see the name of the deck, the amount of cards on it, and the last studied date. I can click in a deck and it will open another screen to see the cards. This new screen will show only one card at a time. I want to see the front text of it, and when I click on it, I want to see the back text. Also, when I click on the card to see the back text, the feedback buttons will appear too. These buttons are “again”, “hard”, “good”, and “easy”. When I click on these buttons, I will process a post request form, update the last studied deck, and the last review date and next review date of the card. To calculate the next review date, I want to use a simple implementation of a SRS (Spaced Repetition System). If I click in “again”, add 1 minute from now into the next review date file. If I click in “hard”, add 1 day. “Good”, 3 days. “Easy”, 7 days. Create a class called SimpleSRS to create this logic. So, to get a card, create a CardManager class and assign it into the model. With this, implement a next_card function to filter by deck, the next_review_date greater than the current date or next_review_date is null. Order by next_review_date and get the first result. For these two pages, create a template called base.html. For my decks page, create a file called decks.html. For flash cards, create a flash_card.html. Create a 404.html custom page to handle error requests. To register new decks and cards, use Django admin. It’s enough. Use the following dependencies for the dev environment: django-debug-toolbar, pytest, pylint, pylint-django, python-dotenv. Also, create a README file with instructions about how to use the project and how to prepare the machine to use it.

Okay, maybe I exaggerated a little, but it worked too. I won’t detail all the execution now, because it was very similar, but this second prompt provided me with a new app totally customized based on my input.

Initially, the app didn’t work. There were problems of syntax in some files, but after some prompts, everything was fine and I had my new flash cards app working as expected. The result was very interesting here.

An interesting think that I found looking at the Python Debug Toolbar, was a bottleneck on the main screen. Looking at the SQL queries, I saw two queries executing a count to get the total of cards in a deck. When I saw the source code into the HTML file, I found the following code:

{ { deck.card_count } } card{ { deck.card_count|pluralize } }

Do you see the problem here? When we use the card_count we’re making a new SQL query on the database. But wait, there are two card_count references in this line. One for print the result, and another to properly print the “card” word using plural or no, depending of the total of cards. Now, imagine this in a big system. Are prepared to solve all this unwanted issues? Are you prepared to solve all these bottlenecks?

Another fun fact: I told the prompt to install the pytest dependency, so the AI should create some tests too, right? Unfortunately, no tests were created. Maybe I should make this request explicit.

Normal coding or just vibe coding?

The best answer I could provide is: it depends! If you just want a simple and fast solution, and don’t care about the artifacts that AI will generate, vibe coding could work using an advanced model and a good tool like Cline. But if you really want or need to understand what is happening, delegating the entire development to an AI tool can be tricky.

The point is, it isn’t a problem to create a fast solution using some AI tool, but think about: are you learning something or are you just seeing the code generated and understanding nothing? Are you accepting all generated code without review it and adjusting it to your project standards? If you’re delegating all this work to the AI in your company, maybe you should care about the final solution, because when you commit these files into the version control in the project of your company, it’s your name that appears there as an author, so the responsibility is yours.

Polemic: vibe coding can be good for experienced developers and harmful for newbies

This topic can be polemic, but it reflects my point of view about it. Since I started working with software development in 2008, the moments that I really learned a lot were moments that I focused on the three main pillars: learning, practicing, and developing. Sometimes we take shortcuts to evolve faster, or just to finish a task or a job, and there’s no problem. The problem is when we start to do things without understanding them. This can be very bad, mainly if you don’t have experience developing.

Do you think I’m wrong or have bad feelings about it? It’s not a problem. This post just reflects my bias. Tell me in the comments your thoughts about this post. But just for the record: there are other guys with interesting points of view too:

I highly recommend you check these contents out, because they provide excellent insights about this reflection.

To be clear: I like AI tools, and I’m using them a lot day-to-day. But also, I’m continuing to prepare myself, evolving in my career, and learning how to use these tools to boost my work, not replace my job.

With more ability, maybe I could solve, in the future, issues created today by AI tools, because all of us will need to be better Software Engineers to keep in our jobs.

The Human Side of Software Engineering: Reflections on Growth and Impact

Ione Souza Junior — Fri, 31 Jan 2025 00:00:00 +0000

I believe it's not so difficult to understand what makes us successful in our careers, but sometimes we need guidance to move forward. So, I dedicated time to read "The Software Engineer's Guidebook," and I'll share some of my thoughts about it, based on my perspective and experience as a Software Engineer and Team Lead.

About the Book

The book, “The Software Engineer’s Guidebook - Navigating Senior, Tech Lead, and Staff Engineer Positions at Tech Companies and Startups”, is written by Gergely Orosz, author of The Pragmatic Engineer Newsletter.

In this book, Gergely shares many perceptions and tips based on his experience. From my point of view, this content is a great opportunity to understand the key points to being successful in your career.

I’ll be careful not to reveal too many spoilers, but some might be inevitable. I’ll do my best.

My Thoughts

Along this reading, I thought about many situations that happened in my career, and I’ll share below the most important insights.

Good Advice for Growth

I didn’t feel this book revealed any big surprises. Most of what I read, I understand as basic behavior a Software Engineer should have.

I believe the last five years acting as a Team Lead changed my perspective, allowing me to understand this book very well. Leading a team helped me see the big picture and understand how to proceed in many situations. Also, this experience allowed me to understand how a company approaches an engineer’s career progression.

Some things we read don’t make sense until we have experience. I believe some examples might be difficult to understand if you’re in an initial position.

Don’t worry, because you can and will get there! But here’s my first thought:

This book explained many things I know today, but I wish someone had told me when I started as a developer.

This is a good book for people starting as Software Developers who need to understand how professional growth works in a company. It’s also a good book for experienced developers who want to ensure they continue growing and stay on the right track.

Take Charge of Your Career

Simply wanting to grow isn’t enough. You need to be in charge of your career. This isn’t your leader’s responsibility; it’s yours. Here’s my second thought:

Think about your career growth and try to answer where you want to be in the next few years. Don’t leave this decision to your leader.

When you know where you want to go, it’s easier to choose the correct path. I know this can be a challenging and stressful exercise, but only you can do it. Not your colleagues, not your leader, not your company. You need to be in charge of your career.

Of course, you can ask for help from an experienced person to clarify paths, understand challenges, or discuss experiences, but only you can decide where to go and how to invest your time.

Deliver Value

Sometimes we work hard and don’t feel recognized. This causes a bad feeling and demotivation. The best way to avoid this is to stay aligned with your leader to understand what’s most important for delivering value. So:

Talk with your leader to understand how you can deliver value for the team, project, other engineers, or the company.

Don’t give up. Wanting to grow doesn’t guarantee success. You need to ensure you’re moving in the right direction and have opportunities where you are.

Asking for feedback is also important to understand if you’re on the right track, need to improve in some areas, or make adjustments. Do this periodically, not just before performance reviews. Remember: your career is your responsibility, so stay in charge.

Understand Why

It’s detrimental to start developing a new feature or bug fix without fully understanding it. We might think we’re being productive by making things faster, but that’s often not the case. Sometimes, we fail. To avoid this, keep this in mind:

Ensure you know why you need to achieve an objective. This way, you’ll understand why, how, and when you need to do something because you’ll see the big picture.

Make sure everything is clear by asking questions, discussing edge cases and side effects. Don’t forget that when it comes to the code, you’re the expert. Only you can reveal certain details that Product folks, Designers, or Stakeholders might not see.

Before development, it’s important to see the big picture. This makes it more likely you’ll achieve the expected objective, enabling you to break it down into smaller parts, understand the main difficulties or challenges, and estimate them accurately.

Clarify to Get Unstuck

I’ve seen many great developers get stuck on issues, struggling to understand what to do. Try to avoid this by understanding and planning your work, and don’t be afraid to seek help.

Even if a problem is large, break it down to understand the challenges and where you’re focusing your efforts. If you don’t know how to do this, ask for help.

When you break a large task into smaller parts, you tend to isolate problems when they occur. Because you’re not focused on solving the entire task at once, but on a specific part, it’s easier to understand the real problem. This prevents you from feeling desperate in daily meetings (or any other meeting) because you’re making progress on a specific piece of the larger puzzle.

Remember: you don’t need to have all the answers , not even as a highly experienced developer. But you do need to be able to break problems down into smaller parts to create a concise plan.

Be Aware of Your Level

Seniority level is another important topic. What are the main differences between a Software Developer and a Software Engineer? Have you considered this? Many people think there’s no difference, but I’ll share my perspective. But first, think about this:

Understand, through conversations with your leader and teammates, how you are performing your work.

A Software Developer can write code, debug, and deliver tasks, but a Software Engineer goes deeper. They can plan a feature, discover and discuss requirements, estimate effort, build a solution, ship it, and maintain it. They can handle the entire process.

A Software Engineer delivers value for the team, not just for themselves. They provide guidance, take initiative, help the team understand software challenges, collaborate effectively, mentor others, and continuously learn. They also understand team and company challenges, quarterly objectives, and can break down large tasks into smaller ones.

I believe this is somewhat controversial and sometimes subjective. It can affect our egos, but believe me, there’s a big difference between someone who knows how to write code and someone who understands why to write code and how it achieves an objective.

Ask your leader and teammates about your deliveries. Seek feedback on your work and performance. Ask your colleagues about their perception of your work. Only this way you’ll really understand where you are and what is the best way to proceed. Think about it!

It Isn’t All About Code

We often think the fastest way to grow is by learning new technologies, frameworks, or design patterns. But we forget that we work with people on a team, so we also need to improve our soft skills, such as communication (asynchronous and synchronous), time management, and collaboration. Keep this in mind:

Even if you’re working as a developer, you’ll deal with people, and human skills are crucial for growth and making yourself understood.

It’s not just you and the machine. There’s a team with you. Don’t forget it. Always communicate well, providing updates on your issues, meetings, and documenting decisions.

Understand When a Task Is Done

It’s amazing to finish an issue and close it, but is that the end? What’s next? Should you follow up to ensure your task or bug fix was applied correctly or solved the main problem? The answer is yes. So, one more thing to keep in mind:

Your task is done when the objective is completed—that is, when your customer confirms everything is okay through feedback.

We always develop a product for a customer, so we need to develop what they need. It’s that simple.

Soft Skills Are Crucial (Sometimes More Than Hard Skills)

Another controversial topic. As you grow in your Software Engineering career, your impact increases. You’ll likely make more contributions that affect the whole team, department, or even company, impacting more people with your work. It’s common to use this expertise to work more closely with Product folks, Designers, Stakeholders, and other Managers to understand what’s truly necessary to make a real impact on the company.

Because of this, foundational abilities are crucial to progressing beyond a Senior Software Engineer career, such as into a Staff Engineer role.

Don’t neglect human skills. Include developing areas like communication, time management, meeting management, stress management, collaboration, emotional intelligence, active listening, empathy, and conflict resolution in your roadmap. Here’s the tip:

As much as you might like to just develop, building relationships with others is inevitable for growth and creating a greater impact.

This usually leads to developing leadership skills, and sometimes you might face decisions about which direction to take - just like it happened to me. But don’t be afraid. This will make you stronger and more capable of facing challenges.

Conclusion

This book has dozens of great tips and pieces of advice, and I’ve shared some of my thoughts about them. While experienced engineers might find some advice familiar, The Software Engineer’s Guidebook provides valuable tips and insights for career progression and is a must-read for those looking to advance to a senior position or beyond.

Every company is different, and you need to understand the rules and expectations for your current role or future aspirations. But these are the basics, and they tend to work well.

As I mentioned, I didn’t find any groundbreaking revelations in this book, but I wish someone had told me these things when I started in IT.

So, if you’re new to this career, I highly recommend this book. If you’re already a Senior or Staff Engineer, this is an excellent resource to remind yourself how you achieved your current role and how to continue growing.

I hope you enjoyed this post and consider reading the book. Remember that I’ve shared my thoughts based on my experience as a Software Engineer and Team Lead. If you have a different point of view, please share it in the comments. I’d love to discuss it.

See you in the next post!

2024 Year in Review

Ione Souza Junior — Fri, 27 Dec 2024 00:00:00 +0000

Before the end of the year seems like the perfect moment to reflect on what we did throughout the year. I believe this is the first year I've done this reflection, and I'll share some of my thoughts with you. Let's talk about 2024 from my career perspective.

Blog Posts

Since January, I’ve started writing on my blog again. Initially, I chose a topic I enjoy immensely: Git. I wrote many posts discussing Git commands. I also wrote posts about iOS development and career development. I like sharing content, but the best part is interacting with you through comments. So, thank you to everyone who interacts with me by commenting on posts both on the blog and on LinkedIn.

Live Streaming

This year I didn’t create any live streams on my YouTube and Twitch channels, but I participated in six live streams on the Canal .NET and Azure Brasil channels. I appreciated all these opportunities, and I’d like to express my gratitude for them.

Here are the links to these live streams:

Podcast

This year, a colleague, Fernando Okuma, invited me to participate in an episode of the Lambda3 podcast. It was an amazing experience to talk with him about Git. Thank you so much for inviting me! Below is the link:

Versioning Branching Strategies

Study on iOS Development

In 2024, I dedicated time to learning and practicing iOS development. I encountered a lot of great content, and I’ll share some of it with you.

Courses

I took several long and short courses.

Backfront Plus

First, I started a course at Backfront Plus. This platform contains many excellent courses about mobile development, and I found amazing content there. UIKit, ViewCode, and SwiftUI are some examples. If you’re looking for good content at a fair price, this is the platform. Just for the record: this isn’t a paid post. This is a genuine recommendation. I really liked this platform.

Functional Programming with Swift

Good content that I found on LinkedIn Learning was the short course called Learning Functional Programming with Swift. This course was very simple but very effective for understanding and practicing functional programming using Swift.

iOS Development: Architecture

In this course, I learned about fundamental architectural design patterns, SOLID principles, how to build responsive apps, and more concepts about iOS development. It was a good course for learning many details applied to the platform. If you’re interested, here’s the link: iOS Development: Architecture.

100 Days of SwiftUI

Another great resource that I used extensively was from Paul Hudson. I started the 100 Days of SwiftUI course, but unfortunately, I haven’t finished it yet. After I moved to Brasília, my routine changed, and I needed to rethink my study plan. But if you’re looking for great free content, this is it.

Book

I read an excellent book called Testing Swift by Paul Hudson. I highly recommend it. This book is easy to read, understand, and has great examples. It’s incredible how easy it can be to test iOS apps, and this book helps a lot with that.

I did other reading as well, but it wasn’t technical, so I won’t describe it here.

Open-Source Contribution

Unlike previous years, I didn’t start any clone app projects this year. Instead, I started contributing to an open-source project, programming in real software. I found a welcoming community in the Firefox iOS project and jumped in.

I started contributing with small pull requests, of course. My first pull request refactored a font reference, and then I started resolving some linter issues. I continue helping with linter issues, but I’m now committed to a large refactor, which has been an amazing experience, and I’m learning a lot from this great team.

Throughout the year, I made more than 40 pull requests, helping the Firefox iOS team enable some linter rules, make font updates, and resolve a flaky unit test. Thank you to all Firefox iOS team members for your patience and for helping me achieve these goals! You’re all doing great work and have a well-organized project.

Study on CI/CD

Recently, I faced some challenges using Azure DevOps Pipelines to build an app, and I found a course on Udemy called Azure Pipelines - CI/CD, Docker and Kubernetes in Azure DevOps. This is a good course for understanding Azure Pipelines, from beginner to advanced topics. I didn’t complete all the lessons, as I needed help with a very specific topic, but if you need more advanced information, this is a great course to check out.

Leaving Team Leadership

2024 was a year of another career change. Since 2020, I’ve been working as a team leader. In this role, I faced many challenges, which helped me grow significantly in soft skills — communication, difficult conversations, emotional intelligence, time management, team management, and delegation. I feel these skills are sometimes neglected by developers, but they contribute significantly to career growth, especially for those who work from home.

After this period of leading a team, I felt the need to refocus on my personal growth in my tech career. So, since the end of 2023, I’ve been discussing this with my leadership, and we created a plan to find another leader for the team, allowing me to return to focusing on mobile development. Now, at the end of 2024, we’ve found someone, and this will allow me to finalize my plan at the beginning of 2025.

2025 is Coming

2024 is ending, and 2025 is coming. Now is the best time to reflect on everything we’ve done, what worked and what didn’t, and think about the next year, ensuring we choose a path that makes sense for us.

Thank you for your attention, and see you next year!

Taking Pauses is Okay, But Not Planning Can Be Costly

Ione Souza Junior — Fri, 04 Oct 2024 00:00:00 +0000

Hello, everyone! I'm back after a short break. Recently, I changed my routine and it became challenging to write every week. Since I love sharing knowledge, I'm excited to be back. This past month has given me a lot to think about, so I want to share some thoughts with you. I hope you enjoy today's post.

Last month, my wife and I moved to a new city. This wasn’t our first rodeo – we’ve moved several times in our relationship (five by my count!). Moving is always time-consuming, so I took a short break to get settled into our new apartment, office, and routines.

Personally, I’m not a big fan of breaks. It’s easy to get used to doing nothing, especially when you’re tired. However, sometimes breaks are essential for recharging and moving forward. That’s what I want to discuss today.

I thrive on routine. I schedule all my tasks and try to stick to my daily and weekly plans. Of course, unexpected things happen, but having a plan helps me readjust.

But what happens to your routine when you’re moving or facing a wave of new responsibilities? That’s the big question I’ve grappled with these past few weeks.

To avoid frustration, understanding the situation is crucial. But are you truly prepared for it? Ask yourself: what happens when your carefully laid plans need to change direction? What if you realize something can’t continue? What if you need a pause before moving forward?

Embrace the Changes

As I mentioned, I live by my calendar. It holds my work schedule, personal appointments – everything. It’s what works for me. Others might prefer reminders, notebooks, or even their memory (personally, I don’t trust mine!).

My recent move was only about 62 miles (100 kilometers), but it still required time and attention. I had to accept that I wouldn’t be able to focus on writing and maintaining my blog schedule consistently. Recognizing this reality helped me avoid a lot of unnecessary frustration.

I’m a very pragmatic person. I like things planned, organized, and under control. Much of what I faced during the move fell outside these ideals, so it was vital to mentally prepare myself.

While I did consider writing posts in advance, I had to remind myself that I’m not a machine. I have a family, I need to prioritize my health, and sometimes life simply gets in the way.

These are simple yet crucial things to acknowledge. Failing to recognize the changes happening around you and adapt your routine accordingly can lead to intense frustration and burnout.

The Power of the Pause

Short breaks offer a fresh perspective. When we’re caught in the flow, it’s easy to overlook details. Breaks allow us to zoom out.

Taking a step back provides the opportunity to course-correct and make sure you’re still on the right track. For instance, I have a career path planned out, and every three months, I dedicate time to reflect on my progress. While I have “checkpoint days” scheduled, short breaks offer additional moments for this valuable exercise.

Whether you have designated checkpoints or take spontaneous pauses, these moments are crucial for evaluating if things are progressing as intended.

Reflecting on Achievements

When we fall short of our goals, it’s easy to feel like failures. I’m very self-critical, so when I don’t achieve something, my instinct is to assume I’m doing something wrong.

However, this isn’t a healthy or productive mindset. It can seriously hinder our motivation. I’m actively working on shifting this perspective and focusing on both successes and setbacks. The goal is to understand what’s working, why something went wrong, and how to adjust.

This reflection is vital. Without it, we risk repeating the same mistakes. And trust me, it’s not easy to self-reflect, especially for us software engineers! But developing this self-awareness is crucial, even (or perhaps especially) in a technical field. We need soft skills too.

Embracing Necessary Changes

Sticking to a plan is great, but what happens when change is unavoidable? Are you willing to adapt to ensure the success of your journey?

Recognizing and understanding changes – whether due to internal factors or external events – is essential for maintaining motivation. Short breaks can clear the fog and help you see the bigger picture.

By understanding what changed and why, you can make informed decisions and continue progressing on your journey.

Reconnecting with Your Motivation

It’s okay to realize that what you’re doing no longer resonates with you. Our passions and goals evolve. Regularly checking in with yourself ensures you’re staying true to what motivates and excites you.

Back on Track

Getting back into a routine after a break can be challenging. For me, it’s a battle against inertia. It’s so easy to get comfortable doing nothing. But inaction leads to stagnation, and I know that ultimately, it’s up to me to make things happen.

I find that once I push through the initial resistance and stick to my routine for a few days, things start to flow naturally again. So, don’t be discouraged! The first step is always the hardest. Once you take it, the rest becomes easier.

The Importance of Focus

It might seem counterintuitive, but I often find myself self-sabotaging. A demanding routine can lead to exhaustion, making it tempting to give up at the end of the day. This is where discipline is critical. Without it, it’s easy to lose sight of your goals and veer off track.

Keep Moving Forward

Life is full of unexpected twists and turns. We might feel tempted to power through without pausing, but sometimes the most productive thing we can do is hit the reset button. And that’s where planning comes in. It might seem counterintuitive when you’re feeling overwhelmed, but having a plan, even a flexible one, can be your saving grace during times of change. Without a roadmap, even a loose one, it’s incredibly easy to get lost in the chaos, lose motivation, and potentially make decisions that don’t align with your long-term goals.

So, take that break when you need it, embrace the changes that come your way, and don’t be afraid to adjust your plans. The journey might not always be linear, but with a bit of focus and self-awareness, you’ll keep moving forward.

See you in the next post!

SwiftUI Basics: Project Structure, Views, and Previews

Ione Souza Junior — Fri, 09 Aug 2024 00:00:00 +0000

This is a new post of the "100 Days of SwiftUI" series. In today's post we'll embark on a fundamental journey: understanding the core structure of a SwiftUI app. We'll demystify the Xcode project setup and explore the essential building blocks of every SwiftUI masterpiece. Let's get started!

Creating a New SwiftUI Project

To create a new SwiftUI project is very simple. Just open Xcode and click on “Create New Project” option. Another way is pressing the shortcut CMD + SHIFT + N.

Launch Xcode and start a new project.

You’ll see a screen to choose a template to you new project. Select “Multiplatform” menu, and them the “App” option on “Application” section. The multiplatform option will ensure you’ll create a new SwiftUI app, compatible with other platforms. Press “Next”.

Choose the "App" template under the multiplatform tab.

You’ll see a screen to choose some options for your new project. Let’s see about them:

Product Name : This is the name of your project. Think about it, because it will be used on bundle identifier too.
Team : This is your Apple developer account team. For a new “hello world” app, just keep it as “None”.
Organization Identifier : Here is the prefix of your app bundle. On my machine, the default bundle is “dev.ionixjunior”, and you can change it for your apps.
Bundle Identifier : This is the result of your organization identifier and the product name.
Storage : In this option you can select if you want to use Core Data or SwiftData. Just keep it as “None”.

Also, there’s another two checkboxes: “Host in CloudKit” and “Include Tests”. Ensure they’re unselected and click “Next”. I’ve defined the product name of my app as “Sample App”.

Give your project a name.

Now, you need to choose the location where you want to save your new project. If you want to create a local Git repository on your machine, select the option “Create Git repository on my Mac”. Press “Create”.

Optionally, initialize a Git repository for version control.

The Xcode project will open, and we’ll talk about it now.

Exploring the Xcode Workspace

When a SwiftUI new project open, we can split the Xcode Workspace in five different main areas: Navigator Area, Editor Area, Preview Canvas, Inspector Area, and Debug Area. Let’s talk about each one.

Navigator Area

Maybe this is the most important area of the project, because we can find our core files there. He’s located on the left side of Xcode workspace, as you can see below.

The Navigator Area (highlighted) is where you find the files of your project.

Note we have a lot of tabs located in this area - nine in total, but the first one is selected, and it is showing the core files of our new project. This first tab is called “Project navigator”, and you can easily show the content from it hitting the shortcut CMD + 1. All other tabs has a shortcut too, from CMD + 1 to CMD + 9, as you can see below.

Your browser does not support video playback.

A quick overview about these tabs and shortcuts:

Tab	Shortcut	Functionality
Project navigator	`CMD + 1`	Is where the files of the project are located
Source control navigator	`CMD + 2`	Is where you can see information about the source control changes
Bookmark navigator	`CMD + 3`	Is where you can see your code bookmarks You can add / remove them to easily find some code
Find navigator	`CMD + 4`	Is where you can make a search query on your project files
Issue navigator	`CMD + 5`	Is where you can see the project warnings
Test navigator	`CMD + 6`	Is where you can see the unit and UI tests of your project
Debug navigator	`CMD + 7`	Is where you can see debug information when you run your app and stop at a breakpoint
Breakpoint navigator	`CMD + 8`	Is where you can see all of your project breakpoints
Report navigator	`CMD + 9`	Is where you can see reports about the app compilation, like warnings, time compilation, and test coverage

Editor Area

The heart of your coding. Here is the location where your code is written and edited.

The Editor Area (highlighted) is where you write and edit your SwiftUI code.

To show a file here, you just go to project navigator, choose a file, and it will appear on editor area.

Preview Canvas

Here we can show the real-time magic of SwiftUI previews. This definitely a killer feature of SwiftUI, because it helps a lot the development workflow providing real-time preview of the screen developed.

The Preview Canvas (highlighted) gives you an instant view of your UI.

This preview is very interesting. As you can see on the image above, it appears when you type the #Preview code, like this:

#Preview {
    ContentView()
}

This code won’t ship when you publish your app on Apple Store, it’s only works under development. A nice think that I discovered recently is it works with UIKit too. It helps a lot to prototype some screen or UI component. Try it!

Inspector Area

This is a hidden area when you create a new project, but you can show it hitting a top right button from Xcode toolbar. When you open it, you’ll see a contextualized area based on selected view elements.

Use the Inspector to adjust view properties and settings without coding.

This area contains 5 tabs

Tab	Shortcut	Functionality
File inspector	`CMD + OPTION + 1`	Show information about the selected file
History inspector	`CMD + OPTION + 2`	Show information about project history (Git commits)
Help inspector	`CMD + OPTION + 3`	Show technical information about selected elements in the file
Accessibility inspector	`CMD + OPTION + 5`	Show information about screen accessibility (I didn’t see this tab working until now, so please let me know if you know how to do it)
Attributes inspector	`CMD + OPTION + 4`	Show information about the selected element on screen

Your browser does not support video playback.

Debug Area

This is a dedicated area to use when you’re running your app. In this area you can interact when you create a breakpoint on your app and need to see values on variables or objects. To see it, click on the button located at bottom right side, and you’ll see a spliced area that will can contain values when you’re running your app.

Use the Debug Area to see information when your app is running.

Now you know about the Xcode workspace, let’s explore about the SwiftUI code.

Exploring the SwiftUI Code

Now that you’ve set up your SwiftUI project and understand the basics of Xcode, let’s explore the core code that brings your app to life. Let’s see the main file.

“YourAppName.swift” file

Now I’m seeing that “Sample App” isn’t a good name for the app, because SwiftUI create a file called “your app name” + “App”. So, my file is called Sample_AppApp.swift 😂. But that’s okay, no problem.

import SwiftUI

@main
struct Sample_AppApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

The @main attribute above the struct declaration might seem subtle, but it’s crucial. It signals to Xcode that this structure, Sample_AppApp, serves as the entry point of your application. Think of it as the “front door” where execution begins.

The struct Sample_AppApp: App line defines your app’s overall structure and behavior. This means Sample_AppApp conforms to the App protocol. By conforming to App, you’re telling SwiftUI that this structure knows how to assemble and manage the different parts of your application.

Inside the body property of your app structure, you’ll find the WindowGroup. This powerful element determines what users see on their screens.

Within the WindowGroup, you’ll usually see ContentView(), witch creates an instance of another SwiftUI view called ContentView. Your ContentView.swift file (created automatically by Xcode) is where you’ll start building the actual user interface of your app.

In essence, the code in the Sample_AppApp.swift sets the stage by defining the entry point, app structure, and the initial view (ContentView) that users will see when they launch your app.

In the next section, we’ll dive into ContentView.swift and start crafting the visual elements of your SwiftUI masterpiece!

ContentView.swift file

Let’s dive into ContentView.swift, the heart of your SwiftUI app. Open it up, and you’ll see a structure similar to this:

import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            Image(systemName: "globe")
                .imageScale(.large)
                .foregroundStyle(.tint)
            Text("Hello, world!")
                .accessibilityLabel("hello")
                .accessibilityAction {
                    print("teste")
                }
                .accessibilityHint("Hellou")
        }
        .padding()
    }
}

#Preview {
    ContentView()
}

The line struct ContentView: View declares a structure named ContentView that conforms to the View protocol. This is how you create all visual elements in SwiftUI.

The body is where the magic happens. This computed property is responsible for defining the appearance and layout of your view.

Inside the body, you’ll find SwiftUI views that make up your UI. The default code includes a simple Image and Text views.

Below ContentView, you’ll notice #Preview block. This enables SwiftUI’s incredible live previews using the Preview Canvas.

With this foundation, you’re well on your way to crafting beautiful and interactive user interfaces in SwiftUI. The possibilities are limitless, and we explore some of them in the next blog posts.

Wrap up

You’ve taken your first steps into the world of SwiftUI, and you’ve already got a good grasp of the basics. You know how to set up a new Xcode project, know about the Xcode workspace, and understand the roles of key elements like @main, App, WindowGroup, and ContentView. Plus, you’ve experienced the magic of SwiftUI Previews, which give you instant feedback as you code.

But this is just the beginning! There’s so much more to learn and explore in SwiftUI. Get ready to master layout techniques, create dynamic user interfaces with data, and build smooth navigation between different parts of your app.

Keep experimenting, have fun, and never stop learning. The possibilities with SwiftUI are limitless, and you’re well on your way to creating incredible apps.

See you in the next post!

Swift Essentials: Protocols, Extensions, and Optionals (Part 4)

Ione Souza Junior — Fri, 02 Aug 2024 00:00:00 +0000

We're back with the "100 Days Of SwiftUI" posts! In today's post, we'll continue the Swift Essentials series, exploring protocols, extensions, and optionals. This will be the final installment on Swift Essentials. Let's get started.

What Is a Protocol?

To simplify things: protocols are like interfaces. I’m not sure why Apple changed the terminology, but there you have it. In the Apple world, you’ll see a lot of this, as much of iOS development is based on protocol-oriented programming (POP).

How to Create a Protocol

Creating a protocol is very simple. Just use the protocol keyword and choose a name. By convention, I’ve chosen to suffix it with Protocol. Thinking about it, I believe I’m influenced by some DotNet conventions, because put “Protocol” at the end is redundant. Anyway, let’s see:

protocol SearchProtocol {
    func search(text: String)
}

This code defines a protocol named SearchProtocol. This protocol requires conforming types to implement a search(text:) function, which would presumably perform some kind of search operation using the provided text as input. So, how do we use it?

How to Use a Protocol

Here’s how you could use this protocol:

struct YourStruct: SearchProtocol {
    func search(text: String) {
        print("Searching for: \(text)")
    }
}

YourStruct conforms to SearchProtocol and provides its own implementation for the search(text:) function. As mentioned earlier, it’s the same concept as interfaces.

This is very important in iOS, so let’s explore a slightly different example. Suppose we need to create a small component to represent some type of search UI element, like this:

import SwiftUI

struct SearchComponent: View {
    @State private var text: String = ""

    var body: some View {
        VStack(alignment: .leading) {
            Text("What are you looking for?")

            TextField("Type here", text: $text)
                .onChange(of: text) { oldValue, newValue in
                    print(newValue)
                }
        }
    }
}

Here we have a view with a TextField, and we’re monitoring changes using the onChange event and capturing the text typed inside it using the print function. It works. Now we can use it in a screen, like this:

import SwiftUI

struct SearchView: View {
    var body: some View {
        VStack {
            SearchComponent()
            Spacer()
        }
    }
}

The component is displayed correctly, but how can we get the value typed inside the TextField? We can use protocols and delegates. It’s very common in iOS to use this approach to achieve a decoupled implementation. Instead of the view knowing all the details about the component, we just make it conform to the SearchComponent protocol and use it. Let’s see how.

I’ve placed the protocol near the component, created an optional property on the component, and replaced the print function call with the protocol function call through the delegate.

import SwiftUI

protocol SearchProtocol {
    func search(text: String)
}

struct SearchComponent: View {
    // rest of the code

    var delegate: SearchProtocol?

    var body: some View {
        // rest of the code

        TextField("Type here", text: $text)
            .onChange(of: text) { oldValue, newValue in
                delegate?.search(text: newValue)
            }

        // rest of the code
    }
}

Now I can go back to the view, make it conform to the protocol, and pass the delegate parameter when creating the instance of the component.

import SwiftUI

struct SearchView: View, SearchProtocol {
    var body: some View {
        // rest of the code

        SearchComponent(delegate: self)

        // rest of the code
    }

    func search(text: String) {
        print(text)
    }
}

Now we can get the values typed in the component right here on the screen, maintaining low coupling between them.

This pattern is very common when working with UITableView on iOS. It uses protocols to keep the component easy to use and reusable.

Let’s continue by talking about extensions.

What Is an Extension?

Extensions are an easy way to add more functionality to your code. Extensions in Swift are very powerful because you can create them even for primitive types. Let’s explore this.

How to Create an Extension

In Swift, it’s very simple to create one. You just use the extension keyword followed by the type name you want to extend. The String type has a property called isEmpty, and sometimes we want to create an expression to validate if a string is not empty. We can do this in three ways:

Use yourStringVariable.isEmpty == false.
Use !yourStringVariable.isEmpty.
Create an extension, choosing one of the options above.

extension String {
    var isNotEmpty: Bool {
        return self.isEmpty == false
    }
}

Now you can use yourStringVariable.isNotEmpty. This is an extension property, but you can create extension functions too. It works the same way, even for primitive types, as you can see above.

What Is an Optional?

In Swift, optionals are a powerful safeguard against a notorious coding issue: the dreaded “unexpectedly found nil” error or something like this. But what are optionals, and why are they so important?

Imagine a variable as a container. A regular variable must always hold a value of its declared type. An optional, however, introduces the possibility of emptiness. It’s like a container that can either hold a value or be explicitly marked as empty, a state represented by the keyword nil.

This “nullability” is incredibly valuable. For instance, when fetching data from a server or a user’s device, there’s no guarantee the operation will always succeed. Optionals handle these scenarios elegantly.

Consider a function that tries to convert a string to an integer:

func convertToInt(from text: String) -> Int? {
    return Int(text)
}

The Int? return type signifies that this function might return an integer, or it might return nil if the conversion fails (for example, trying to convert “hello” to an integer). Let’s explore how to safely access an optional value.

if let

To safely access the potential value inside an optional, you use “unwrapping” mechanisms. One common way is using if let:

let userInput = "123"
if let number = convertToInt(from: userInput) {
    print("The number is \(number)")
} else {
    print("Invalid input")
}

Here, number is only assigned a value if convertToInt succeeds. Otherwise, the else block executes, preventing crashes from trying to use a non-existent value.

guard let

You can check for “nullability” in different ways. For instance, you can use guard let. This approach is better to use when you need to create an early return statement.

let userInput = "123"

func yourFunction() {
    guard let number = convertToInt(from: userInput) else {
        print("Invalid input")
        return 
    }

    print("The number is \(number)") 
}

yourFunction()

Nil Coalescing

Nil coalescing provides a concise and elegant way to handle optional values by providing a default value when an optional is nil.

Here’s a simple example:

let userInput = "hello"
let convertedValue = convertToInt(from: userInput)
print(convertedValue ?? "empty value")

As a result, the print function will display “empty value” because convertedValue is an optional without a value.

Optional Chaining

Optional chaining acts like a careful safeguard when you’re accessing data that might be missing in your Swift code. Imagine you’re following a treasure map with instructions like “Go to the old oak tree, then check under the loose rock, and you’ll find the prize!” But what if the tree is gone, the rock is missing, or the prize was already taken? In code, when we try to access something that doesn’t exist, we get a fatal error, but using optional chaining prevents this from happening. Let’s look at the previous example where I showed you about protocols:

import SwiftUI

protocol SearchProtocol {
    func search(text: String)
}

struct SearchComponent: View {
    // rest of the code

    var delegate: SearchProtocol?

    var body: some View {
        // rest of the code

        TextField("Type here", text: $text)
            .onChange(of: text) { oldValue, newValue in
                delegate?.search(text: newValue)
            }

        // rest of the code
    }
}

In the line delegate?.search(text: newValue), we’re accessing the search method of the delegate property, but it will only be called if the property actually contains a value.

Optionals, while initially appearing as an extra layer of complexity, are a fundamental safety net in Swift. They encourage you to think about and handle situations where data might be missing, leading to more robust and crash-resistant applications.

Wrap Up

As we reach the end of our exploration, it’s clear that protocols, extensions, and optionals form a powerful trio in the world of Swift programming.

Protocols , with their blueprint-like nature, empower you to define consistent behavior across different types, fostering code reusability and maintainability. They bring order to chaos, ensuring your code adheres to a common standard.

Extensions , like skilled artisans, add functionality and elegance to existing types without requiring access to their original blueprints. They enhance and extend, making your code more expressive and adaptable.

Optionals , the ever-vigilant guardians, equip you to handle the uncertainty of missing data. They gracefully guide your code through potential pitfalls, preventing crashes and fostering resilience in the face of the unknown.

Together, this dynamic trio empowers you to write safer, cleaner, and more flexible Swift code. Embrace their strengths, experiment with their possibilities, and watch as your code transforms into a masterpiece of clarity and robustness.

See you in the next post!

Git-ifying SVN: How I Brought Modern Version Control to an Age-Old System

Ione Souza Junior — Fri, 26 Jul 2024 00:00:00 +0000

Rewind the clock ten years. The year was 2014, smartphones were still finding their feet, and I was a bright-eyed developer, eager to conquer the world, one line of code at a time. But a formidable foe stood in my path – our company’s steadfast reliance on Subversion (SVN) for version control. Don't get me wrong, SVN had served us well for a time. But as our projects grew in complexity and our team expanded, its limitations became increasingly apparent. Branching and merging were exercises in frustration, collaboration felt clunky, and don't even get me started on trying to work offline! The very tool that was meant to streamline our development process was slowing us down. A solution was needed, but a full-blown migration to a new system (Git was beckoning) felt like a distant dream. Then, I stumbled upon something that promised the best of both worlds... a way to "Git-ify" our SVN workflow. Let me tell you how git svn changed everything.

The SVN Struggle

Every developer knows that sinking feeling when their tools become roadblocks instead of enablers. With SVN, that feeling was becoming a constant companion.

The branching and merging process was the stuff of nightmares. Each branch felt like a delicate ecosystem, and merging them back into the trunk was a high-stakes operation fraught with the peril of conflicts. Hours would disappear into resolving these conflicts, often introducing new ones in the process. It felt like we were spending more time battling the version control system than writing actual code. I believe this was why the company choose to work only on the “trunk” branch - this is the name of the main branch on SVN.

Collaboration wasn’t much better. SVN’s centralized nature meant we were tethered to a constant internet connection. Want to commit a small change? Make sure you’re online! Working remotely? Better hope your VPN is cooperating. This lack of offline access was a major productivity killer.

And let’s not forget that code review didn’t exist. You just made a commit and done. We lived this way. It was funny when you and your colleague were working on the same file and whoever commit last without updating the repository ended up removing the implementation of the colleague who commit first.

The impact of these SVN struggles was undeniable. As I was used to working with good tools, it was a bit difficult to work with SVN. Something had to give. A full switch to Git seemed ideal, but migrating our entire codebase and getting everyone on board felt like a Herculean task we weren’t prepared for.

Discovering git svn

Just when my developer despair was at its peak, I stumbled across a glimmer of hope while scouring the internet for SVN workarounds (as one does when facing a mountain of merge conflicts). Enter git svn: a seemingly magical command that promised to bridge the chasm between my SVN reality and the Git-powered dreams I held dear.

In essence, git svn acts as a translator between the two systems. It allows you to work locally with all the power and flexibility of Git - branching, merging, offline commits – while still interacting with a remote SVN repository. Imagine having your cake and eating it too, but for version control!

The beauty of git svn lay in its simplicity. I could keep using my familiar Git commands (git checkout, git branch, git merge, oh my!) without forcing my colleagues to abandon SVN. It was the perfect stealth operation to bring some modern version control sanity into our workflow, all while flying under the radar of a full-blown migration.

The possibilities were exhilarating: I could finally branch and merge with ease, commit changes offline to my heart’s content, and gain much-needed visibility into our project’s history, all without rocking the SVN boat. Could this be the answer to our version control woes? I was determined to find out.

Implementing the Solution

Armed with newfound hope and a healthy dose of developer enthusiasm, I dove headfirst into the world of git svn. My first order of business? Cloning our SVN repository into a local Git repository using the magic command:

git svn clone --stdlayout SVN_REPOSITORY_URL

It felt like opening a portal to a parallel universe – a universe where I could branch and merge without breaking a sweat. Once the clone was complete, I was greeted by a familiar sight: my very own Git repository, complete with the entire project history.

To show you, I’m using a free SVN repo from RiouxSVN, create a project, make some commits and clone it. When I typed the command above, I can see the following where I typed git log:

* 899c967 (origin/trunk, main) Replace age by birthDate
* c6e470f Replace name by first and last name properties
* 0645868 Add User struct
* 9d3fa32 Creating initial repository structure

Note that the main branch of Git is synched with the trunk branch of SVN. Now, you can imagine that we’re in the Git world and can create new branches, make merges, updates, and so on. I’ve created a new branch called “new_feature”, and make a small implementation. Seeing the log, we have the following:

* 9ec48e4 (HEAD -> new_feature) Change to a computed property
* 9a03f1b Add fullName method
* 899c967 (origin/trunk, main) Replace age by birthDate
* c6e470f Replace name by first and last name properties
* 0645868 Add User struct
* 9d3fa32 Creating initial repository structure

Now we have the “new_feature” branch ahead of the trunk. Suppose we finish our development and needs merge. But first, let’s do another think: let’s make another commit into SVN repo (simulation a teammate work), and keep our new branch updated before merge and send changed to SVN. How can we do this? Well, we can simple use the fetch command to get the newest updates from SVN, and them merge it if our local repository. Let’s see it.

git svn fetch   

        M User.swift
r5 = 8bfc98b61c4e4c0eaf4062d5dacdaeb634b97cc7 (refs/remotes/origin/trunk)

Seeing the log, we get the following:

* 8bfc98b (origin/trunk) Add id property
| * 9ec48e4 (HEAD -> new_feature) Change to a computed property
| * 9a03f1b Add fullName method
|/  
* 899c967 (main) Replace age by birthDate
* c6e470f Replace name by first and last name properties
* 0645868 Add User struct
* 9d3fa32 Creating initial repository structure

Now we see the trunk branch is one commit ahead of our main branch. Let’s update it and them make a rebase of our feature branch.

git checkout main
git merge origin/trunk

Updating 899c967..8bfc98b
Fast-forward
 User.swift | 1 +
 1 file changed, 1 insertion(+)

Now the trunk and main branches are synched.

* 8bfc98b (HEAD -> main, origin/trunk) Add id property
| * 9ec48e4 (new_feature) Change to a computed property
| * 9a03f1b Add fullName method
|/  
* 899c967 Replace age by birthDate
* c6e470f Replace name by first and last name properties
* 0645868 Add User struct
* 9d3fa32 Creating initial repository structure

Let’s go back to our feature branch, make a rebase and prepare to commit into SVN.

Checkout to the “new_feature” branch.

git checkout new_feature

Make the rebase.

git rebase main

After it, everything is okay again and all synched.

* 6e1f665 (HEAD -> new_feature) Change to a computed property
* e171831 Add fullName method
* 8bfc98b (origin/trunk, main) Add id property
* 899c967 Replace age by birthDate
* c6e470f Replace name by first and last name properties
* 0645868 Add User struct
* 9d3fa32 Creating initial repository structure

We’re prepared to make our commit to SVN. First, let’s checkout to the main branch.

git checkout main

Merge the feature branch using the --no-ff (no-fast-forward) option. This will create a merge commit into main branch, and this will be good to the SVN because won’t mess with a lot of commits.

git merge --no-ff new_feature

Git will ask you a commit message. Type the message and finish the merge. Seeing the log, everything is okay.

* 3c13eb4 (HEAD -> main) Implement the fullName computed property
|\  
| * 6e1f665 (new_feature) Change to a computed property
| * e171831 Add fullName method
|/  
* 8bfc98b (origin/trunk) Add id property
* 899c967 Replace age by birthDate
* c6e470f Replace name by first and last name properties
* 0645868 Add User struct
* 9d3fa32 Creating initial repository structure

Now comes the best part: push changes to SVN. To do it, we just type the git svn dcommit command to push our local changes on main branch to the trunk branch on SVN server.

git svn dcommit
Committing to https://svn.riouxsvn.com/ionixjunior-prj/trunk ...
        M User.swift
Committed r6
        M User.swift
r6 = 42e0f095ec453b6416f954958479f39842028f58 (refs/remotes/origin/trunk)
No changes between 3c13eb4501d858e7b7c225fa687b08667d97bcb4 and refs/remotes/origin/trunk
Resetting to the latest refs/remotes/origin/trunk

Seeing the log, we will see the branches synched.

* 42e0f09 (HEAD -> main, origin/trunk) Implement the fullName computed property
|\  
| * 6e1f665 (new_feature) Change to a computed property
| * e171831 Add fullName method
|/  
* 8bfc98b Add id property
* 899c967 Replace age by birthDate
* c6e470f Replace name by first and last name properties
* 0645868 Add User struct
* 9d3fa32 Creating initial repository structure

Works like a charm 😎.

The Impact

The introduction of git svn wasn’t just a technological shift; it was a breath of fresh air for me. I went from battling our version control system to embracing it as a valuable ally in our quest to build great software. Unfortunately, I’ve tried to evangelize my teammates to work this way, but I felt from them some fear and disturb. Even though it was cool, it was something very “new”, and we know that changes take time to be introduced.

The most noticeable change was the boost in productivity. Branching and merging, once dreaded tasks, became routine operations. The fear of merge conflicts subsided, replaced by the confidence that Git’s powerful algorithms had our back. I was finally free to experiment, iterate, and collaborate with ease, and the way that I love: commit a lot, every piece of code, and I finally can use Git as a strategic tool in development, not just for versioning code.

git svn was the silent hero, bridging the gap between two worlds and empowering us to become better, happier, and more productive developer.

Using git svn today

In 2014 I just typed git svn, and everything works. But today, maybe you need to install the git-svn using Homebrew. Just type brew install git-svn, and you’ll get the git svn command on your command line. But this is an official command, as you can see here.

Lessons Learned and Conclusion

Looking back, my journey with git svn was an eye-opener. It taught me that you don’t always need a radical overhaul to make a significant impact. Sometimes, the most effective solutions are the ones that bridge the gaps between existing systems and individual preferences.

While my teammates were content with the familiar flow of SVN, I was eager to tap into the power and flexibility of Git. git svn became my secret weapon, allowing me to work more efficiently and with far less friction, all while remaining a contributing member of our SVN-centric team.

What did I learn?

The right tool can make all the difference. Don’t be afraid to explore solutions that cater to your specific workflow and preferences, even within constraints.
Sometimes, a gradual approach is key. git svn provided a perfect steppingstone, allowing me to reap the benefits of Git without disrupting the team’s established workflow.
Embrace flexibility. Development is a diverse field, and what works for one person might not work for another. Respecting different tools and approaches is crucial for team harmony.

While our team eventually moved on to embrace Git fully (hey, progress waits for no one!), my time with git svn taught me valuable lessons about adaptability, the importance of choosing the right tools for the job, and finding ways to thrive, even within the constraints of legacy systems. And sometimes, a little bit of silent revolution is all it takes to make a world of difference in your own coding journey.

Happy coding and choose the best tools for work!

Swift Essentials: Structs, Classes, and More (Part 3)

Ione Souza Junior — Fri, 19 Jul 2024 00:00:00 +0000

In the first two parts of "100DaysOfSwiftUI", we explored the fundamental building blocks of Swift - variables, data types, control flow, loops, functions, and closures. Now, we're ready to dive into a crucial aspect of Swift programming: structs and classes. These powerful tools allow us to create custom data structures that organize and represent real-world objects in our code. Understanding structs and classes is essential for building complex and modular applications in SwiftUI, and they will empower you to create more powerful and robust iOS apps. Let's learn about it!

Structs: Value Types

Structs in Swift are value types that allow you to create custom data structures. Imagine them as blueprints for creating your own unique data containers, similar to how you might design a blueprint for a house.

Think of structs as “boxes” that hold related information. Each box has specific compartments (properties) to store different types of data, and you can define actions (methods) that can be performed on the data within the box. Here’s a breakdown of structs.

Basic Struct Definition

To define a struct, we use the struct keyword followed by the struct’s name:

struct User {
    // Properties and methods will go here
}

Let’s create a User struct to represent a user profile:

struct User {
    var firstName: String
    var lastName: String
}

This defines a User struct with two properties: firstName and lastName.

Stored Properties

Stored properties hold data within a struct. They act like variables inside the struct. The properties showed above are stored properties.

let userLaura = User(firstName: "Laura", lastName: "Campbell")

Computed Properties

Computed properties don’t store values directly. Instead, they calculate and return a value based on other properties.

struct User {
    var firstName: String
    var lastName: String

    var fullName: String {
        return "\(firstName) \(lastName)"
    }
}

let userLaura = User(firstName: "Laura", lastName: "Campbell")
print(userLaura.fullName) // Output: Laura Campbell

This User struct now has a fullName computed property that returns the concatenation of firstName and lastName.

Computed properties are very used on SwiftUI, mainly on views.

Property Observers (didSet, willSet)

Property observers allow you to perform actions whenever a property’s value changes. We have two:

didSet: This observer is called after a property’s value changes.
willSet: This observer is called before a property’s value changes.

struct User {
    var firstName: String
    var lastName: String {
        willSet {
            print("The new value is \(newValue)")
        }

        didSet {
            print("The old value is \(oldValue)")
        }
    }
}

var userLaura = User(firstName: "Laura", lastName: "Campbell")
userLaura.lastName = "Johnson"

// Output:
// The new value is Johnson
// The old value is Campbell

The newValue and oldValue are automatically powered by Swift when using these property observers. You can use this to develop something reactive. But be careful, because your code can be slow with a lot of actions in a simple property called many times.

Memberwise Initializers (Default Constructor)

Structs automatically get a memberwise initializer, which is a default initializer that allows you to create instances by providing values for all properties. As showed previously, we didn’t create any constructor for the struct, but we were capable to initialize the object and put values inside.

Custom Initializers

We can create our own custom initializers for structs to control instance creation based on specific parameters.

struct User {
    var firstName: String
    var lastName: String

    init(firstName: String, lastName: String) {
        self.firstName = firstName.uppercased()
        self.lastName = lastName.uppercased()
    }
}

Here, we create a custom initializer that takes the same parameters as the memberwise initializer. However, we can add additional logic or validation within the initializer before assigning values to the properties. If you create a custom initializer, you need to ensure that all property will be initialized with a value.

Mutating Methods

Methods that modify the properties of a struct needs the mutating keyword.

struct User {
    var firstName: String
    var lastName: String

    mutating func changeLastName(to newLastName: String) {
        lastName = newLastName
    }
}

var userLaura = User(firstName: "Laura", lastName: "Campbell")
userLaura.changeLastName(to: "Johnson")
print(userLaura.lastName) // Output: Johnson

Here, changeLastName modifies the lastName property, so it needs to be marked as mutating.

Structs are incredibly useful for creating custom data types, and understanding their features is crucial for building well-organized and efficient code in Swift. In the next section, we’ll dive into classes, another powerful tool for representing data and behavior in Swift.

Classes: Reference Types

Classes in Swift are like blueprints for creating objects that represent real-world entities. They’re similar to structs in that they can hold properties and methods, but they have some crucial differences. Classes are reference types , meaning that they’re passed around as references (pointers) instead of copies. This has significant implications for how they behave.

Let’s explore classes in more detail to understand some differences.

Basic Class Definition

To define a class, we use the class keyword followed by the class name. I’ll use the same example of User struct that I showed previously.

class User {

}

Let’s add some properties.

class User {
    var firstName: String
    var lastName: String

    init(firstName: String, lastName: String) {
        self.firstName = firstName.uppercased()
        self.lastName = lastName.uppercased()
    }
}

Notice now we need to specify the initializer method. Different from struct, Swift doesn’t create memberwise initialize for classes.

Inheritance

Inheritance allows us to create subclasses that inherit properties and methods from superclasses. This promotes code reusability and reduces redundancy.

class AdminUser: User {
    var canDeleteAccount: Bool

    init(firstName: String, lastName: String, canDeleteAccount: Bool) {
        self.canDeleteAccount = canDeleteAccount
        super.init(firstName: firstName, lastName: lastName)
    }
}

In this example, AdminUser inherits from User. It has its own property (canDeleteAccount) and overrides the initializer to take an additional canDeleteAccount parameter.

Note we’re using an initializer for inheritance class with super.init.

Methods

Different from structs, classes doesn’t need to be marked with the mutating keyword to change some property.

class User {
    var firstName: String
    var lastName: String

    init(firstName: String, lastName: String) {
        self.firstName = firstName
        self.lastName = lastName
    }

    func changeLastName(to newLastName: String) {
        lastName = newLastName
    }
}

var userLaura = User(firstName: "Laura", lastName: "Campbell")
userLaura.changeLastName(to: "Johnson")
print(userLaura.lastName) // Output: Johnson

Deinitializers

Deinitializers (deinit) are called when an instance of a class is about to be deallocated from memory. Some languages calling it as desctructors.

class User {
    var firstName: String
    var lastName: String

    init(firstName: String, lastName: String) {
        self.firstName = firstName
        self.lastName = lastName
    }

    deinit {
        print("\(firstName) is being deallocated.")
    }
}

To see it in action, try to use the playground and create this object in a loop. You’ll see when the context of class finishes, the deinit will be called.

for index in 1...3 {
    var userLaura = User(firstName: "Laura \(index)", lastName: "Campbell")
    print(userLaura.lastName)
}

// Output:
// Campbell
// Laura 1 is being deallocated.
// Campbell
// Laura 2 is being deallocated.
// Campbell
// Laura 3 is being deallocated.

Classes are powerful tools for building complex and object-oriented applications in Swift. They allow you to model real-world entities, promote code reusability through inheritance, and manage object lifecycle. But I believe you thinking now: when I need to use a struct or a class?

Struct or Class?

I’ll try to simplify: use a struct when you want to create simple data containers that are copied and remain immutable. Use a class when you want to create complex objects that are referenced and modified, and when inheritance is necessary.

Feature	Struct (Value Type)	Class (Reference Type)
Copying	Copies are made when passed as arguments or assigned to new variables	References are passed, so changes affect the original object
Mutability	Properties are immutable by default. `mutating` keyword is required to modify properties within methods	Properties are mutable by default. No need for `mutating`
Inheritance	Structs cannot inherit from other structs or classes	Classes can inherit from other classes (single inheritance)
Reference Counting	No reference counting	Reference counting is used to track object instances
Deinitializers	Structs do not have deinitializers	Classes can have deinitializers (`deinit`)
Typical Use Cases	Representing simple data structures, value types, where immutability is preferred, data structures passed by value	Representing complex objects, reference types, where inheritance or mutability is required, data structures passed by reference

In the table above I show you the main differences for each one. One thing that I haven’t showed yet is about “copying”. Let’s see it.

In the following code, I’ve created a user1 and copy it to a user2. I’ve changed the user1 property and print both. Note that the name are different for each one because we’re using a struct.

struct User {
    var firstName: String

    init(firstName: String) {
        self.firstName = firstName
    }
}

var user1 = User(firstName: "Laura")
var user2 = user1
user1.firstName = "Samantha"

print(user1.firstName) // Output: Samantha
print(user2.firstName) // Output: Laura

Now I just changed one keyword: I replaced the struct for a class and the result is different now.

class User {
    var firstName: String

    init(firstName: String) {
        self.firstName = firstName
    }
}

var user1 = User(firstName: "Laura")
var user2 = user1
user1.firstName = "Samantha"

print(user1.firstName) // Output: Samantha
print(user2.firstName) // Output: Samantha

This occurs because the differences between these two kinds of type. When you’re using a class and pass a reference of it, any changes affect the original object, but this is not the same for structs.

We already see a lot about structs and classes, right? Let’s see the next section to understand about the access control, which helps protect your code and ensure data integrity.

Access Control: Protecting Your Code

Access control in Swift is a mechanism that allows you to restrict access to entities within your code, like properties, methods, and even entire types. This helps ensure data integrity, prevent accidental modifications, and improve code organization.

Swift provides several access modifiers to control the visibility and accessibility of entities:

public: Accessible from anywhere, including other modules or frameworks.
private: Accessible only in the same scope where the entity is defined (like a class or an extensino).
fileprivate: Accessible only from within the same source file wher the entity is defined.

Also, for properties we can use the private (set) modifier to create properties only for public reading with private setter.

class User {
    private (set) var firstName: String

    init(firstName: String) {
        self.firstName = firstName
    }

    func deleteAccount() {
        deleteFiles()
        deleteData()
    }

    private func deleteFiles() {

    }

    fileprivate func deleteData() {

    }
}

Access control is particularly important in SwiftUI because it helps you control the data and behavior of your views. By carefully using access modifiers, you can create more robust and well-structured UI components.

This example is very simple, only to you understand what’s possible. Please, create a new playground project and explore it.

Static Properties and Methods

Static properties and methods are associated with the struct or class itself, rather than individual instances of the struct or class. This means that they can be accessed directly on the type without needing to create an instance.

struct User {
    static var totalOfUsers = 0

    var firstName: String

    init(firstName: String) {
        self.firstName = firstName
        User.totalOfUsers += 1
    }
}

print(User.totalOfUsers) // Output: 0
var user1 = User(firstName: "Laura")
print(User.totalOfUsers) // Output: 1
var user2 = User(firstName: "Samantha")
print(User.totalOfUsers) // Output: 2

Static properties hold data that is shared among all instances of a class or struct. So, be careful. Also, methods can be static too.

struct User {
    static var totalOfUsers = 0

    var firstName: String

    init(firstName: String) {
        self.firstName = firstName
        User.totalOfUsers += 1
    }

    static func describeTotalOfUsers() {
        print("There are \(totalOfUsers) users created.")
    }
}

User.describeTotalOfUsers() // Output: There are 0 users created.
var user1 = User(firstName: "Laura")
User.describeTotalOfUsers() // Output: There are 1 users created.

Wrap up

In this third installment of “100DaysOfSwiftUI,” we’ve delved into the world of structs and classes, the building blocks for organizing and representing data in Swift. We’ve explored their differences, learned how to define properties, methods, and initializers, and discovered about the access control.

By mastering structs and classes, we unlock new levels of power and flexibility in Swift programming. We can now model complex objects, create reusable code through inheritance, and control data access for better code organization and security.

As you continue your SwiftUI journey, remember that structs and classes are essential tools for building powerful and maintainable applications. They provide a structured approach to organizing your code, making it easier to manage, extend, and modify your projects. Structs are very important for SwiftUI, because they’re using massively to create views.

Now it’s your time. Take a time to practice and explore all described here using the playground, and practice using them in your own projects. The more you practice, the more confident you’ll become in harnessing their power.

Stay tuned for the next part of the “100DaysOfSwiftUI” series, where we’ll dive into more advanced topics, building upon the foundation we’ve laid together. Happy coding!

Swift Essentials: Loops, Closures, and More (Part 2)

Ione Souza Junior — Fri, 12 Jul 2024 00:00:00 +0000

In the first part of "100DaysOfSwiftUI," we explored the foundational building blocks of Swift — variables, data types, and more. Now, let's dive deeper into the control flow, loops, functions, and closures. These are essential concepts for building dynamic and interactive apps in SwiftUI, and they'll help us write more powerful and flexible code. Get ready to unleash the true potential of Swift and unlock new possibilities for your iOS development journey!

Control Flow: Making Decisions and Repeating Actions

In the world of programming, we need to create code that can respond to different situations and repeat actions efficiently. This is where control flow comes in. It allows us to make decisions based on conditions and execute code blocks repeatedly based on specific criteria.

Let’s explore some key elements of control flow in Swift:

If Statements and Comparisons

if statements are used to execute code only if a certain condition is true. We use comparison operators to compare values and determine if a condition is met. Common comparison operators include:

> (greater than)
< (less than)
>= (greater than or equal to)
<= (less than or equal to)
== (equal to)
!= (not equal to)

Here’s a simple example:

let age = 25

if age >= 18 {
    print("You are an adult.")
}

This code checks if the variable age is greater than or equal to 18. If it is, the message “You are an adult.” is printed.

Else and Else If

The else keyword allows us to execute a different block of code if the if condition is false. The else if keyword can be used to create additional conditions to check.

Another simple example:

let temperature = 20

if temperature > 25 {
    print("It's hot!")
} else if temperature < 15 {
    print("It's cold!")
} else {
    print("The temperature is pleasant.")
}

Logical Operators (&&, ||): Combining Conditions

Logical operators allow us to combine multiple conditions within an if statement.

&& (AND): The && operator checks if both conditions are true.
|| (OR): The || operator checks if at least one condition is true.

Here’s an AND example:

let isLoggedIn = true
let isAdmin = true

if isLoggedIn && isAdmin {
    print("You have administrative privileges.")
}

Here’s an OR example:

let isAdmin = false
let isSimpleUserWithGrantAccess = true

if isAdmin || isSimpleUserWithGrantAccess {
    print("You can execute the action.")
}

Switch Statements: Evaluating Multiple Cases

switch statements provide a more concise and readable way to handle multiple conditions, especially when dealing with a limited number of cases.

let trafficLight = "Red"

switch trafficLight {
case "Red":
    print("Stop!")
case "Yellow":
    print("Slow down.")
case "Green":
    print("Go!")
default:
    print("Invalid traffic light color.")
}

This code checks the value of trafficLight. It matches the value against different cases and executes the corresponding code block. The default case handles any values not explicitly matched.

I think this way to create switch and case is the strangest thing in Swift, because they’re on the same indentation. But this is the pattern, that’s okay.

Ternary Conditional Operator

The ternary operator is a shorthand way to write simple conditional expressions. It takes the form:

condition ? valueIfTrue : valueIfFalse

Here’s an example:

let age = 25

let message = age >= 18 ? "You are an adult." : "You are not an adult."

print(message)

This code checks the value of age. If it’s greater than or equal to 18, the variable message is assigned “You are an adult.” Otherwise, it’s assigned “You are not an adult.”

Control flow statements are fundamental building blocks of any programming language. They allow us to create code that can make decisions and repeat actions, making our programs more interactive and efficient. In the next section, we’ll explore another important aspect of Swift programming: loops.

Loops: Repeating Actions

Loops are powerful tools in Swift that allow us to repeat blocks of code multiple times. They’re essential for automating tasks, iterating over collections, and handling repetitive operations. Let’s explore two common types of loops: for loops and while loops.

For Loops

for loops are used to iterate over a sequence of values, such as a range of numbers or elements in an array.

Here’s an example iterating over an array:

let fruits = ["Apple", "Banana", "Orange"]
for fruit in fruits {
    print(fruit)
}

// Output:
// Apple
// Banana
// Orange

Here’s an example iterating over a range:

for number in 1...5 {
    print(number)
}

// Output:
// 1
// 2
// 3
// 4
// 5

Swift provides a good way to create ranges. Very easy to use.

While Loops

while loops are used to repeat a block of code as long as a specific condition is true.

var counter = 0

while counter < 5 {
    print(counter)
    counter += 1
}

// Output:
// 0
// 1
// 2
// 3
// 4

This loop continues to execute as long as the value of counter is less than 5. Inside the loop, the value of counter is printed, and then incremented by 1.

When we’re using while we need to be careful to always control the variable who is deterministic to go out of the while. If we don’t increment the counter in this example, the code won’t stop.

Break and Continue

Sometimes, we need more control over how loops execute. break and continue statements provide us with this control.

Break

The break statement immediately exits a loop, regardless of the loop’s condition.

for number in 1...5 {
    if number == 3 {
        break
    }
    print(number)
}

// Output:
// 1
// 2

Continue

The continue statement skips the current iteration of a loop and jumps to the next iteration.

for number in 1...5 {
    if number == 3 {
        continue
    }
    print(number)
}

// Output:
// 1
// 2
// 4
// 5

Loops are powerful tools for repeating code efficiently, and break and continue provide additional control over loop execution. Understanding how to use loops effectively is essential for building complex and efficient algorithms in Swift. Now, let’s move on to another important aspect of Swift programming: functions.

Functions: Reusable Code Blocks

Functions are like mini-programs within your Swift code. They allow you to encapsulate a block of code that performs a specific task, making your code more organized, reusable, and easier to maintain.

Let’s break down the fundamentals of functions in Swift.

Basic Function Definition

To define a function, we use the func keyword followed by the function’s name and parentheses (). You can optionally add parameters within the parentheses. The code block that executes when the function is called is enclosed in curly braces {}.

func greet(name: String) {
    print("Hello, \(name)!")
}

greet(name: "Laura") 

// Output: Hello, Laura!

In this example, we define a function named greet that takes a single parameter name of type String. The function prints a greeting message to the console. We call the function by using its name followed by parentheses and passing the argument “Laura” for the name parameter.

Returning Values

Functions can also return values. We use the return keyword to specify the value to be returned. The return type is specified after the parentheses in the function definition.

func getGreet(name: String) -> String {
    return "Hello, \(name)!"
}

let greet = getGreet(name: "Laura")
print(greet) // Output: Hello, Laura!

If you have a function with a single-line, you can suppress the return keyword.

func getGreet(name: String) -> String {
    "Hello, \(name)!"
}

let greet = getGreet(name: "Laura")
print(greet) // Output: Hello, Laura!

Default Values for Parameters

We can provide default values for function parameters, making our functions more flexible. If a value is not provided when calling the function, the default value will be used.

func getGreet(name: String, greeting: String = "Hello") -> String {
    return "\(greeting), \(name)!"
}

let greetLaura = getGreet(name: "Laura")
print(greetLaura) // Output: Hello, Laura!

let greetAdrian = getGreet(name: "Adrian", greeting: "Hi")
print(greetAdrian) // Output: Hi, Adrian!

Functions That Can Throw Errors

In Swift, we can define functions that can throw errors using the throws keyword. This indicates that the function might not complete successfully and could throw an error.

enum DivisionByZeroError: Error {
    case zeroDivision
}

func divide(number1: Int, number2: Int) throws -> Int {
    if number2 == 0 {
        throw DivisionByZeroError.zeroDivision
    }

    return number1 / number2
}

To use functions with throws keyword you need to use the following syntax to ensure you’ll capture the exception error:

do {
    let result = try divide(number1: 10, number2: 0)
    print(result)
} catch DivisionByZeroError.zeroDivision {
    print("Error: Division by zero.")
} catch {
    print("An error occurred.")
}

Here, the divide function throws a DivisionByZeroError if the number2 is 0. We use a do-catch block to handle the error: the try keyword indicates that the code inside the block might throw an error, and the catch block handles the thrown error.

Functions are fundamental building blocks of Swift code, making our programs more modular, reusable, and efficient. Next, we’ll explore another powerful feature: closures.

Closures: Passing Code as Values

Closures are blocks of code that can be passed around like variables. They’re incredibly versatile, allowing you to encapsulate behavior and reuse it in different parts of your code. Imagine closures as self-contained mini-programs that can be executed on demand. In SwiftUI is very important to understand about this concept. Let’s dive into it.

Basic Closures

The simplest way to create a closure is to use curly braces {}. A closure without parameters can be defined like this:

let greet = {
    print("Hello, world!")
}

greet() // Output: Hello, world!

We assign this closure to a constant named greet. To execute the closure, we call it like a function. If you think about the type of this closure, it’s () -> Void, because it’s a function without parameter, and without return. It can be represented this way:

let greet: () -> Void = {
    print("Hello, world!")
}

greet() // Output: Hello, world!

It’s the same.

Closures with Parameters and the “in” Keyword

Closures can also take parameters and have return values. We use the “in” keyword to separate the parameters and return type from the closure’s code block.

let greet = { (name: String) in
    print("Hello, \(name)!")
}

greet("Laura") 

// Output: Hello, Laura!

This closure has a parameter of type String without return. The type can be represented as (String) -> Void, and you can write this closure this way too:

let greet: (String) -> Void = { name in
    print("Hello, \(name)!")
}

greet("Laura")

// Output: Hello, Laura!

Also, your closure can return a value.

let greet = { (name: String) -> String in
    return "Hello, \(name)!"
}

let result = greet("Laura") 
print(result) // Output: Hello, Laura!

Now the closure type is (String) -> String. You can write the same closure above this way:

let greet: (String) -> String = { name in
    return "Hello, \(name)!"
}

let result = greet("Laura")
print(result) // Output: Hello, Laura!

But where can we use it? In Swift is very common you see a function with a “completion handler”. Usualy, it is a closure that is called when some operations finish, like an animation or a data load. Let’s se an example:

func registerNewUser(name: String, completionHandler: (String) -> Void ) {
    // Make a long operation like call an API or change a database
    // After it, call the completion handler
    completionHandler(name)
}

let greet = { (name: String) in
    print("Hello, \(name)!")
}

registerNewUser(name: "Laura", completionHandler: greet)
// Output after the long operation: Hello, Laura!

We create a function called registerNewUser with two parameters. The first one is the name and the second one is a closure that expect a parameter of type String and without return represented with Void keyword.

Shorthand Syntax for Trailing Closures

Swift provides a shorthand syntax for trailing closures when the closure is the last argument and it has only a single expression. We can just omit the closure parameter declaration and embed it at the trailing. I’ll consider the same registerNewUser function showed previously, and I’ll embed the greet closure using the shorthand syntax.

registerNewUser(name: "Laura") { name in
    print("Hello, \(name)!")
}

Very easy, and clear. You’ll see it a lot in SwiftUI.

Conclusion

We’ve covered a lot of exciting ground in this second part of “100DaysOfSwiftUI”! We’ve explored control flow, loops, functions, and closures — powerful features that allow us to create more dynamic and sophisticated Swift code (closures specially).

Mastering these concepts is like unlocking a new level of proficiency in Swift programming. These tools provide us with the ability to make decisions, repeat actions efficiently, and encapsulate reusable code blocks, which are crucial for building complex and interactive applications in SwiftUI.

As we continue our journey through the “100 Days of SwiftUI” challenge, remember that practice is key. Experiment with these concepts, try out different examples, and don’t hesitate to ask questions. The more you practice, the more comfortable you’ll become with these essential tools.

I encourage you to explore further, and remember, every line of code you write brings you closer to mastering Swift!

Stay tuned for the next part of the “100DaysOfSwiftUI” series, where we’ll delve into structs and access control, expanding our knowledge of Swift programming even more.

Swift Essentials: Variables, Data Types, and More (Part 1)

Ione Souza Junior — Fri, 05 Jul 2024 00:00:00 +0000

I'm diving headfirst into the "100 Days of SwiftUI" challenge by Paul Hudson, and I'm thrilled to be on this journey of discovery. But before I can create dazzling iOS apps, I know that building a strong foundation in Swift is crucial. This blog series, which I'm calling "100DaysOfSwiftUI," is my way of sharing my learning journey with you, especially those who are new to Swift. We'll explore the fundamental building blocks of this powerful language together. In this first part, we'll tackle the core concepts of variables, data types, string interpolation, and enums. These seemingly simple elements are the pillars upon which we'll build more complex and powerful applications in SwiftUI. So buckle up, grab your coffee (or your preferred drink!), and let's embark on this journey together! We'll cover the basics in a clear and engaging way, and by the end, you'll have a solid grasp of the foundational concepts that will empower you to start crafting your own iOS apps.

If you don’t know about the 100 Days of SwiftUI, please check out this link.

Variables and Constants: Storing Data with Flexibility and Immutability

In the world of programming, we often need to store data. We have two primary tools for doing this: variables and constants. Both act as containers for data, but they differ in their flexibility:

Variables: The Changeable Ones

Variables are like labeled boxes in our code that hold data that can be modified. We use the var keyword to declare a variable:

var name = "Laura"

We can change the value of name at any point in our code:

name = "Laura Smith"

Now, name holds the value “Laura Smith”.

Constants: The Immutable Ones

Constants are like sealed containers. Once you define a constant, its value cannot be changed. We use the let keyword to declare a constant:

let name = "Laura"

This sets name to the value “Laura”, and we cannot assign a different value to it later.

Constants are good for preventing accidental changes to important values, ensuring data integrity. They also make your code clearer and more predictable, as the values they hold are fixed.

So, consider this when deciding how to use variables and constants in your code.

Data Types: Defining the Nature of Data

In programming, we need a way to categorize the kinds of data our variables and constants can hold. These categories are called data types.

Think of data types as defining the “nature” or “essence” of the data. They tell Swift how to interpret and manipulate the information. Here are some essential data types in Swift:

String: For Textual Data

The String data type represents textual information. It’s used to store anything that can be written or displayed, such as names, addresses, sentences, and even code.

let name = "Laura"
var message = "Hello!"

Int: For Whole Numbers

The Int data type represents whole numbers (integers), such as 1, 10, 25, 1000, and so on. Integers are commonly used in counters, calculations, and for representing quantities.

let age = 30
var numberOfItems = 5

Float, Double and Decimal: Representing Numbers with Precision

In Swift, we have three primary data types for representing numbers with decimal points: Float, Double, and Decimal. While they all handle fractional values, they differ in their precision and memory usage:

Float: Lower Precision, Smaller Range

Float uses 32 bits of memory to store its value, offering a smaller range of values and less precision than Double. It’s generally used when memory efficiency is a priority and lower precision is acceptable.

let floatNumber: Float = 0.00001

Double: High Precision, Large Range

Double is the most common choice for representing floating-point numbers in Swift. It provides a high degree of precision, making it suitable for calculations requiring a wide range of values. Double uses 64 bits of memory to store its value, which is twice the size of Float.

let doubleNumber: Double = 0.00001

Decimal: High Precision, Financial Calculations

Decimal is specialized for handling financial calculations where accuracy is paramount. It offers a high degree of precision, especially for numbers with a large number of decimal places. However, it is less computationally efficient than Double or Float due to its focus on accuracy. Decimal is a base-10 number representation that provides high precision, allowing you to store a lot of numbers.

To create a Decimal value, you can use the following syntax:

let decimalNumber: Decimal = 0.00001

Type Annotations

As you can see in the samples above, there’s only one keyword that changed in these examples: the type. Here, the type defines what kind of numeric value you’ll store. This is called “type annotations,” and you can use it for all data types or structures.

You can create a numeric value simply by creating a variable and assigning a value, but it will be created as a Double type by default.

Bool: For Logical Values

The Bool data type represents boolean values, which can be either true or false. Bools are fundamental for decision-making in your code, helping you create conditional statements and logical expressions.

let isAdmin = true
var hasError = false

Arrays, Dictionaries, and Sets

So far, we’ve explored data types for individual values: strings, numbers, booleans. But often, we need to store collections of data—multiple values related to each other. This is where arrays, dictionaries, and sets come in handy.

Arrays: Ordered Collections of Values

Arrays are ordered lists of elements of the same data type. Think of them as numbered boxes where you can store a collection of related items. You access elements in an array by their index, starting from zero.

let cities = ["Barcelona", "London", "São Paulo"]
print(cities[0]) // Output: Barcelona (first element)
print(cities[2]) // Output: São Paulo (third element)

Arrays are useful when you need an ordered list of elements of the same type.

Dictionaries: Key-Value Pairs

Dictionaries are unordered collections of key-value pairs. Each key is unique and maps to a corresponding value. Think of dictionaries like a real-world dictionary, where each word (key) has a definition (value).

let userData = ["name": "Laura", "surname": "Smith", "city": "London"]
print(userData["name"]) // Output: Optional("Laura")
print(userData["city"]) // Output: Optional("London")

Dictionaries are useful when you need to store and retrieve data based on unique keys.

Sets: Unique and Unordered Collections

Sets are unordered collections of unique elements. They don’t allow duplicates, making them useful for checking membership and removing duplicates from a collection.

let uniqueNames = Set(["Laura", "Josh", "Laura", "Marie", "Josh"])
print(uniqueNames.count) // Output: 3 (duplicates removed)

Sets are useful when you need to work with unique values or when you want to check for membership quickly - this structure is very fast.

Enums: Defining Related Values

Enums, short for enumerations, are a powerful way to define a custom type that represents a set of related values. They provide a more structured and readable way to represent choices or states within your code, compared to using raw integers.

Think of enums as creating a vocabulary of specific terms related to a particular concept. For example, imagine you’re building an app that handles order status. Instead of using raw integers like 0, 1, and 2, you can create an enum to represent the order states:

enum OrderStatus {
    case pending
    case processing
    case shipped
    case delivered 
    case cancelled
}

Now, instead of using numbers, you can directly use the enum values:

var orderStatus = OrderStatus.pending 
print(orderStatus) // Output: OrderStatus.pending

Enums improve readability. They make your code more self-documenting and easier to understand. They also enforce type safety, preventing you from accidentally assigning incorrect values.

Cool Things

String Interpolation

An easy way to concatenate strings without using “+” is using interpolation:

let name = "Laura"
let surname = "Smith"
print("The name of the winner is \(name) \(surname)!")

Multi-line Strings

Sometimes we need to create a multi-line string, and this is very easy in Swift. You just use triple quotes and write your string inside them. Just ensure that the triple quotes are declared on a different line from the string.

var multilineMessage = """
This is the multi-line message.
You can add a lot of lines.
Don't worry about it!
"""

Bools and the Toggle Function

When you create a variable, you can change its value later. So, we can create a bool value and change it using the toggle function.

var isAdmin = false
print(isAdmin) // Output: false

isAdmin.toggle()
print(isAdmin) // Output: true

Dictionary Default

As you can see in the dictionary example, when we access the key, we get an optional. This occurs because Swift can’t ensure that there is a value in that key. Because of this, Swift gives us an optional. You can handle this using a property called default. This way you don’t get an optional, and your code won’t break if you handle the optional without careful.

let userData = ["name": "Laura", "surname": "Smith", "city": "London"]
print(userData["name"]) // Output: Optional("Laura")
print(userData["name", default: "Unknown"]) // Output: Laura
print(userData["nickname", default: "Unknown"]) // Output: Unknown

Conclusion

We’ve covered a lot of ground in this first part of “100DaysOfSwiftUI”! We’ve explored variables, constants, data types, string interpolation, enums, and some collection types. These concepts are essential for understanding how data is stored, manipulated, and used in your code.

Understanding these fundamentals is like having a solid foundation upon which you can build more complex structures in your SwiftUI journey. Imagine them as the bricks and mortar that make up the walls of your iOS apps.

I encourage you to practice these concepts, experiment with different examples, and don’t hesitate to ask questions. Share your thoughts and experiences in the comments below!

Stay tuned for the next part, and let’s continue to build our Swift knowledge together!

My 100 Days of Swift: Cool Projects & What I Learned

Ione Souza Junior — Fri, 28 Jun 2024 00:00:00 +0000

A while ago I completed the 100 Days of Swift challenge by Paul Hudson. It was an amazing experience where I learned a lot about Swift and iOS development. In today's post, I'll share my thoughts about this journey and highlight some of the most interesting things I encountered. Let's dive in!

If you search online for “100 days of Swift,” you’ll find various resources. When I began my search, I chose Paul Hudson’s program. You can find it here. Some people asked me why I started with UIKit instead of SwiftUI. Well, I believe both are important, so I decided to begin with UIKit.

For anyone starting their iOS development journey, I highly recommend following a structured path like this. You’ll face challenges, practice consistently, and learn something new every day. The dynamic is simple: learn and practice. I’m excited to share some highlights from my experience.

The First 12 Days

The first 12 days were dedicated to Swift basics, but even with seemingly simple concepts, I learned valuable things.

Making Large Numbers Legible

When working with large numbers, you can use underscores as thousands separators. This doesn’t change the number’s value; it just makes it easier to read.

var balance = 10_000_000

Exiting Multiple Loops

If you have multiple nested loops, you can name each loop to create a break condition for exiting. It’s a good alternative to using goto (remember those? 😅).

outerLoop: for i in 1...5 {
    for j in 1...5 {
        print ("\ (i) - \(j)")

        if j == 3 {
            break outerLoop
        }
    }
}

These might seem like small details, but I found them quite useful.

Starting iOS Projects

After mastering Swift basics, I began working on iOS projects, which opened a world of new possibilities. Let’s revisit some of the coolest features I encountered and some things I’ve tried.

Environment Overrides

Xcode provides an option called “environment overrides.” Basically, you can change settings like appearance, text, and accessibility to test your app in different scenarios. It’s incredibly easy to check your app in various environments.

Your browser does not support video playback.

Debug Description in UI Tests

When running UI tests, you can set a breakpoint and type po app.debugDescription in the output window. This will show a “REPL” (Read-Eval-Print Loop) that helps you understand the UI elements you can interact with on the screen. This is incredibly useful for analyzing UI elements during testing.

Xcode showing the UI elements on the screen in the output window.

Unresponsiveness UI Warnings

This is a very helpful feature. Xcode alerted me when I performed expensive operations on the UI thread, such as loading a URL from the internet. These types of issues are easy to fix, and I appreciated Xcode’s warnings that helped me improve my implementation.

Xcode showing an unresponsiveness UI warning in a content loaded from a URL.

River Raid - A Tiny Version

In addition to UIKit, I also explored a bit of SpriteKit. This was not a challenge from Paul Hudson training, but some lessons that I’ve developed helped me to built it. I’ve made just for fun. I had an Atari, so I’ve played River Raid a lot!

Your browser does not support video playback.

Memory Game

I also created a simple memory game. To test it, I developed UI tests to verify that all cards could be flipped and that the game could be completed successfully. It was a rewarding project.

Your browser does not support video playback.

100 Days of Practice == A Great Evolution

Some chapters of this training were repetitive, but they served a purpose: solidifying knowledge. Before embarking on this journey, I felt the need to continuously develop something every day, to learn and practice consistently. The 100 Days of Swift challenge provided the perfect framework for this goal and introduced me to excellent content.

If you’re interested in following my entire journey, you can check out this tweet. Also, all projects that I developed are hosted on this GitHub project.

I’m thinking about starting the 100 Days of SwiftUI challenge, also by Paul Hudson. What do you think? Would you like to join me on this adventure? Remember, consistency is key! Every day counts, and with dedication, you can achieve incredible things in your coding journey. So, let’s keep learning and growing together!

The Power of Patience and Persistence: How to Thrive in the Ever-Evolving Tech Landscape

Ione Souza Junior — Fri, 21 Jun 2024 00:00:00 +0000

There's a lot to study if you choose any Software Engineering position. You can develop desktop, web, mobile, IoT applications, and each of these options have huge possibilities for you to choose or specialize in. A common question, mainly for a newbie is: when will I be a master in this technology? This is a difficult question to answer, isn't it? Technology evolves fast and all the time we face things changing. This can cause some nervousness and stress, because it's a little bit difficult to not get things under control. So, in today's post, I'll share some of my thoughts about it. Take a coffee or any drink you prefer, have a seat, and let's get started.

I’ve been working with software development since 2008. I’ve already worked in six different companies, and I felt I and my colleagues were looking for the same objective: to be a master in some technology. Everybody who wants to learn, usually, wants to be a master in some subject, but how fast can we achieve this to acquire the knowledge we want?

Well, all of us, IT guys, love to say: it depends! That’s the absolute truth for this question. It depends, because each of us have different ways to learn. Some people like to learn by watching videos, another one likes to learn by reading blog posts, other people like to roll up their sleeves and dive into the code. So, it depends. Do you agree with this?

Another thing that I believe is very important to understand: learning is different from knowing. You can watch a bunch of videos about some specific content, and that’s okay. You learn about it. But did you really understand it? Do you really know about it? You watched some course in 2x velocity and are you prepared for the fight? If you need to get your hands dirty, can you put into practice what you’ve learned? Did you really learn the concepts?

And last, but not least: the time. This is another factor in the equation. Most of us want to learn very fast, and a lot of things. There’s a lot of abilities that we can learn and practice, but what we really need to focus at first to feel comfortable? This is important to think to you understand when to stop or when to go easy on yourself.

My Point Of View

When we want to learn something or want to achieve an objective, we create expectations. We want to change, to make a career transition, to learn a new technology or just to start in the field. Sometimes we know what we want, but we don’t know the path to achieve it. So, in this case, it’s very common to immerse yourself in studying everything you come across. Do you want to achieve your objective, right? How much time do you believe you’ll need to get it? Three or six months? One year? And what’s your plan B? Do you have one? It’s not difficult to start trying to learn all the things, but if you don’t have a clear path, you can get only anxiety and fear.

This usually happens when you try to learn too much at once. Learning a lot of things doesn’t mean knowing these things. You need to practice, and you need time to develop the new abilities. This can cause anxiety, because if you don’t have a clear path, you can see there’s a lot of new things to learn. You start learning just one new thing, and you discover there are five or ten new concepts to look for. That’s okay! You’re not alone. If you don’t have a clear path to focus on what’s more important, you can feel a little anxious, because you won’t stop to look for new content. All you’ll see isn’t enough, and you won’t enjoy your journey. This is terrible.

It can cause fear too. If you understand that there’s always a lot of things to learn, and you don’t feel confident with your knowledge, how can you work properly if you’re always concerned about your own knowledge?

You Can Learn With Your Mistakes

I’ve already faced this situation in different stages of my career. The first one in 2008 when I started in the field as a Web Developer. In that year, I was almost a Webmaster, because I needed to learn about web applications, databases, manage Linux servers, and all the things that an IT guy does — including fixing printers. At the beginning of my career, I didn’t have a clear path to follow, I just learned a lot of things, fast, and practiced a lot. I learned a lot practicing, and I worked all the time. It was very tiring, but I evolved a lot.

The second stage of my career that I faced a change was in 2014 when I started as a Mobile Developer working with Xamarin Forms. I had a challenge to develop a sales representative application for Android, iOS, and Windows, but as a Web Developer, I had no idea what was necessary to learn, so I started again to learn all content that I found and practice a lot. In this period, I was always worried about learning mobile development. It was a period of time that I’ve grown a lot again, but it cost my mental health. Some people may think this is bullshit, but only I know what I felt.

In 2019, I made a new move, and started as a Mobile Engineer. Despite continuing to work with mobile development, there was something different: I started to work more closely to the native Android and iOS APIs. I started to work all day with the Xamarin Traditional approach. This may seem like nothing, but it was a big change for me. I felt I didn’t have enough good knowledge to stay there. Honestly, I knew that I had a good knowledge about software development, but not about mobile development, because I had been working with Xamarin Forms for a long time. So, I needed to start to learn again. Tiring, isn’t it? Well, but this time was different for me, because I was (and continue) in a good place, and it provides me to finally enjoy my learning path.

I was determined to try something different in 2019. I didn’t want to repeat the same cycle.

Calm Down And Enjoy The Learning Path

To keep calm and enjoy the learning path, I accept that I never will be a master of everything. This was very difficult for me, because I put a lot of pressure on myself. I want to be the best, so accepting this was not easy.

What is working for me is to think about the following questions:

What knowledge do I need to develop to make myself confident and allow me to move on?
Where and how can I get this new knowledge?
How much time will I invest to achieve this?

Is it difficult to answer these questions? If you don’t have the habit or ability to reflect about yourself, this can be a big challenge. You need to know about yourself, what you want, and how much are you willing to sacrifice. This can be difficult, but understanding this is very important. Let’s explore these questions.

1. What knowledge do I need to develop to make myself confident and allow me to move on?

This is very particular to each one. You need to think about what knowledge you’ll focus on learning and practicing that will make you more confident and prepared for the challenges in your career. So, think: what do you want to learn?

Do you want to learn about backend development? Maybe you should start learning about the basics of databases, HTTP protocol, and RESTful APIs.

Do you want to learn about frontend development? Maybe you should start learning about HTML, CSS, JavaScript, and responsive design.

Do you want to learn about mobile development? Maybe you should start learning about view controllers / activities / fragments, UI components, and life cycle.

You need to choose what path you want to follow, and understand what knowledge you need to learn that allows you to move on without problems.

2. Where and how can I get this new knowledge?

Today there are a lot of resources that you can use to learn about anything. YouTube videos, blog posts, courses at LinkedIn Learning, Pluralsight, Udemy, Alura, BackFront Plus, or even free content on YouTube.

I think this topic is a little bit interesting, because I was born in 1987, and I grew up without the new technologies that we use today. My first computer I won when I was 15 years old, and the internet was dial-up. Today, we turn on our computers and smartphones, and all the time we’re connected, with a lot of content on the palm of our hands. But even with a lot of content to consume, I think sometimes we don’t know where to find good content or where to start. So, the most important is: just start. It’s better than do nothing.

3. How much time will I invest to achieve this?

Now you already know what knowledge you want to develop, where the resources are, and you need to think about how much time you’ll invest to achieve this. How much time? One hour per day? Two, maybe? Between three and six hours per week? You need to organize your agenda and put your learning path into your routine. Don’t you have time at the moment? No problem, but you can’t feel frustrated with this, and this situation needs to be very clear to you.

It’s not a problem to not have time now. It’s a problem if you want to make a change and not dedicate on it. No pain, no gain.

Things to care about

Focus means setting a target and sticking to it. So, if you plan to study a lot of things, maybe you’re starting wrong, or you won’t achieve your plans properly. I’m telling you this because it’s humanly impossible to start learning many things at the same time and be productive in all of them. There are some exceptions, but focus means starting something and ensuring you evolve it until the end. Think about it.

Sharing My Experiences

I’ve dedicated this session to share my last experiences. Maybe something can help you to clear the learning path.

Experience 1: Start Working With iOS And Android Native APIs

As I said previously, in 2019 I started as a Mobile Engineer to work with Xamarin Traditional, more closely to iOS and Android native APIs. This was a great challenge for me, because I was used to working only with Xamarin Forms. At that time, Xamarin Forms was very evolved, and each new application didn’t need a lot of custom renderers to work properly anymore. This meant that native knowledge was less crucial, allowing developers to focus on the shared code for most of their work.

Well, my scenario changed, and I needed a plan to study. I knew I needed to study a lot of things, and I tried to answer the three questions.

1. What knowledge do I need to develop to make myself confident and allow me to move on?

This is very strange, but for me, to feel comfortable, I didn’t need much:

Master how to create screens with dynamic lists and content.
Master how to navigate between screens.
Master how to communicate between screens.

Very simple, right? Yeah, simple, but I needed to master these things to feel more comfortable in my new job. I knew all the concepts, but I didn’t work with them until that moment. There’s a big difference between only learning about something and truly understanding it, in practice. All of this knowledge I needed to evolve on both platforms, but more on iOS.

2. Where and how can I get this new knowledge?

Well, I don’t remember exactly where I studied, but I remember looking for courses at Udemy, Pluralsight, and some content on YouTube. All very practical training. On Pluralsight, I remember taking the following courses:

3. How much time will I invest to achieve this?

I usually dedicate many hours to studying. This is how it works for me. When I face a new challenge, I like to dive deep into it. I have the privilege of being able to find time for this. My wife supports me and helps me a lot. I usually dedicate between one and two hours a day, including weekends, because my wife loves to wake up late, and I wake up early to study more time when we stay home.

I hoped to see progress in about a year, and it came. Over time, the tasks became easier. This was a sign to me that I was achieving my objective. I continue studying and evolving, but with less pressure on myself.

This basic knowledge helped me to continue growing in my position. Maybe you’re thinking: why did you study iOS and Android native approaches with Swift and Kotlin instead of C# with Xamarin? Well, I believe if you master native development and understand how each platform works, you will reduce doubt when you’re facing problems on mobile development with Xamarin. Something goes wrong? What’s wrong? Is it Xamarin or is it iOS / Android? Understanding the core concepts in the native language helps me many times to not blame Xamarin when I faced problems. I’ve seen this sometimes happen when people blamed Xamarin Forms, but the real problem lied within the platforms themselves.

Experience 2: Start To Focus On Mastering iOS Development With Swift

Last year I wrote about it, and you can find this post here. So, here I am thinking about the questions again.

1. What knowledge do I need to develop to make myself confident and allow me to move on?

Over the last few years working with Xamarin Traditional, I’ve learned a lot about iOS, but now I have some specific necessities to feel comfortable to be an iOS Engineer in the future. For example:

Master memory management
Master parallelism and concurrency
Master closures in Swift
Master View Code
Learn how to build the same things in SwiftUI that I know how to build with UIKit

2. Where and how can I get this new knowledge?

To my surprise, I found a lot of content on LinkedIn Learning, but I’ve started this journey using BackFront Plus. They have great paid content, and the videos about iOS development are fantastic, very well explained. If you have the opportunity, I highly recommend it to you.

Also, I like the content of Paul Hudson. He has a lot of great free content. The same is true for Sean Allen, and CodeWithChris.

Another interesting thing that I’m trying now is to practice in a real project. I love to create a project from scratch and test concepts on it. But there’s a problem: when you’re in a “hello world” project, learning tends to be somewhat limited. So I decided to practice trying to contribute to a real open-source project. I shared about it in this post.

3. How much time will I invest to achieve this?

Today, I’m investing at least one hour from Monday to Friday, and some hours on Saturday. My intention here is to study and practice until I feel confident to contribute to open-source projects.

To be confident is subjective, right? Well, in my context, feel confident means contribute and create solutions without too much difficulty. That’s it.

Need Tips To Find Where Or What To Study?

There’s a site called roadmap.sh, that is a community effort to create roadmaps, guides, and other educational content to help guide developers in picking up a path and guide their learnings. Check this out!

Another great resource is a study guide for software development with Swift. I didn’t finish it, but I found great content there.

What Will You Learn Now?

The path to mastery in tech is a journey, not a destination. It’s about finding the right balance between learning and practicing, focusing on what matters most to you, and understanding that you don’t need to know everything to make progress.

Embrace the power of patience and persistence — it’s your key to conquering the ever-evolving tech landscape. Start by identifying what you want to learn, find the resources that suit your learning style, and dedicate the time you can to reach your goals.

Don’t be afraid to make mistakes, learn from them, and keep moving forward. Remember, every new skill you acquire adds value to your career and empowers you to build incredible things. So, take that first step, stay curious, and enjoy the learning journey!