Hi again, dear readers!

In the last post we had a brief introduction to Jetpack Compose, and before that a brief introduction to Android app components. In today's article, we'll build a color mixer app as our first project to have a brief introduction to Android app development.

In this article I'll document my walkthrough and my decisions, I encourage you, dear readers, to explore different approaches for the project and feedback, all suggestions are welcome.

Project Description

We'll build a color mixer, we'll have three text fields that will accept hexadecimal values for red, green and blue channels respectively. It'll also contain a preview of the resulting color and a label of the color's hex code. This should look like the image below:

Of course, the app must validate inputs and shouldn't crash. To run the app, I'll use a real device because my potato would burn if I try to run the emulator, but here you'll find a guide to configure the emulator in your machine.

Setting Up Your First Project

Download Android Studio, run it and create a new project. From the options, keep "Empty Activity" selected and press Next.

Rename "My Application" to "RGB Color Mixer", you can change other details, but be careful when changing Minimum SDK, the older, the better for compatibility with older devices. I'm using Minimum SDK 24 to support more devices. Then press Finish, let Gradle finish the sync and you're all done.

Along the projects, we'll explore the project structure when needed, we can ignore it for now.

Source Code

The default source code has two parts, the Activity declaration and the composable functions.

The default main activity is literally named as MainActivity. All Activities must be a subclass of the Activity class, as we can observe from the source code below, we have ComponentActivity, which is also a subclass of the Activity class. If the syntax looks confusing, check for trailing lambdas.

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            RGBColorMixerTheme {
                Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
                    Greeting(
                        name = "Android",
                        modifier = Modifier.padding(innerPadding)
                    )
                }
            }
        }
    }
}

The function setContent is responsible for setting up the layout. Inside of it there are other function calls, let's focus on the Greeting function, that is declared as below by default.

@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
    Text(
        text = "Hello $name!",
        modifier = modifier
    )
}

@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
    RGBColorMixerTheme {
        Greeting("Android")
    }
}

We can notice the annotation @Composable, this indicates that it is a composable, There is also a second annotation, the @Preview.

Development Process

Auxiliary Functions

Before paying attention to the UI, I first created functions that would help me handle user input, validate it, properly convert it to Color class, and use the color to update the preview.

The private val HEX_DIGITS = "0123456789ABCDEF" variable was declared to help to validate hex values and convert their string representation to integer.

The function isValidChannel validates the user input by checking the size and the characters it contains.

private fun isValidChannel(channel: String): Boolean{
    var isValid = true
    if (channel.length !in 1..2)
        return false
    channel.forEach { isValid = isValid && HEX_DIGITS.contains(it.uppercase()) }
    return isValid
}

To convert hexadecimal strings to Int, I declared an extension function for String class. This is just an adaptation of the famous atoi function (C programmers will recognize it), which converts strings to integers.

private fun String.toColorChannel(): Int{
    var value = 0

    if (!isValidChannel(this))
        return value
    this.forEach {
        value = value.shl(4)
        value += HEX_DIGITS.indexOf(it.uppercase())
    }
    return value
}

Finally, to get a Color object, I create the getColor function. This used bitwise operations to create a valid Int representation of a color, that follows the 0xAARRGGBB hexadecimal pattern. Here you'll find the API reference for more details.

private fun getColor(red: String, green: String, blue: String): Color {
    return Color(0xff.shl(8)
        .or(red.toColorChannel())
        .shl(8)
        .or(green.toColorChannel())
        .shl(8)
        or(blue.toColorChannel())
    )
}

Resources

Resources are files and static content that our code uses, such as images, strings, etc. Always externalize resources, so that we can maintain them separately. Also provide alternative resources, at runtime Android uses the appropriate resource based on current configuration — images for different screen sizes, for example.

Resources are located at app/src/main/res/ folder, there are different folders for different resources in it. For this project I focused on the values/ folder, strings.xml to be more accurate.

This file is dedicated to string resources, instead of using string literals inside your code, just set a string resource and use stringResource to get it inside your code. For example, let's say we have the following string resource:

<resources>
    <string name="app_name">RGB Color Mixer</string>
    ...
</resources>

To access it, we can call stringResource(R.string.app_name) to access the string resource. Every string resource has an Int ID generated inside of project's R class. In this example R.string.app_name is the resource ID.

Declaring The UI

I first removed 'Greeting' and 'GreetingPreview' declarations and calls, then created a composable to get the user input as follows:

@Composable
fun ColorTextField(
    modifier: Modifier = Modifier,
    color:String = "",
    isValidColor: Boolean = true,
    label: Int,
    placeholder: Int,
    onValueChange: (String) -> Unit = {},
){
    TextField(
        modifier = modifier.padding(4.dp),
        value = color,
        onValueChange = onValueChange,
        isError = !isValidColor,
        supportingText = {
            if (!isValidColor)
                Text(
                    text = stringResource(R.string.invalid_color),
                    color = MaterialTheme.colorScheme.error
                )
        },
        trailingIcon = {
            if (!isValidColor)
                Icon(
                    imageVector = Icons.Filled.Warning,
                    contentDescription = stringResource(R.string.error_icon),
                    tint = MaterialTheme.colorScheme.error
                )
        },
        singleLine = true,
        label = {
            Text(stringResource(label))
        },
        placeholder = {
            Text(stringResource(placeholder))
        }
    )
}

The TextField composable is brought by Jetpack Compose, other default composables used in the project are Button and Text, there are many others, but we'll explore them along future projects. To avoid repetition, I declared a customized TextField to reuse common details through ColorTextField composable.

It's worth noting that value and onValueChange must be set in TextField. value is the current TextField content while onValueChange is a lambda function that will be executed every time value changes. As Jetpack Compose uses a declarative approach and composables can only be updated through recomposition, remember API and MutableState<T> objects should be used to trigger it.

To preview a color, the Surface composable was used, its height was defined to 1/3 of the screen height.

Modifiers allow us to augment or decorate composables. It's a best practice to have all our composable functions to accept a modifier parameter and pass that parameter to the first child that emits UI.

@Composable
private fun ColorPreview(
    modifier: Modifier = Modifier,
    color: Color,
    label: @Composable () -> Unit = {}
){
    Column(
        modifier = modifier.fillMaxSize().padding(4.dp),
        horizontalAlignment = Alignment.CenterHorizontally,
    ){
        val screenHeight = LocalConfiguration.current.screenHeightDp.dp
        Surface(
            modifier = Modifier.fillMaxWidth().height(screenHeight / 3),
            color = color
        ){}
        label()
    }
}

If you noticed, the code has two interesting composables: Column and Row. Including Box composable, they form the layout composables, making easier to design our UI.

Column organizes UI elements vertically, Row horizontally, and Box stacks elements one above other.

To put things together, I declared the ColorMixerUI composable as follows:

@Preview
@Composable
fun ColorMixerUI(
    modifier: Modifier = Modifier,
){
    var red by rememberSaveable { mutableStateOf("") }
    var green by rememberSaveable { mutableStateOf("") }
    var blue by rememberSaveable { mutableStateOf("") }
    var isValidRed by rememberSaveable { mutableStateOf(true) }
    var isValidGreen by rememberSaveable { mutableStateOf(true) }
    var isValidBlue by rememberSaveable { mutableStateOf(true) }

    Column(
        modifier = modifier.fillMaxSize(),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.SpaceEvenly
    ) {
        Row(
            modifier = Modifier.fillMaxWidth().padding(4.dp),
            horizontalArrangement = Arrangement.SpaceEvenly
        ) {
            ColorTextField(
                modifier = Modifier.weight(1f),
                color = red,
                isValidColor = isValidRed,
                label = R.string.red,
                placeholder = R.string.input_red
            ){
                if (it.length < 3 ) {
                    red = it.uppercase()
                    isValidRed = isValidChannel(it)
                }
            }
            ColorTextField(
                modifier = Modifier.weight(1f),
                color = green,
                isValidColor = isValidGreen,
                label = R.string.green,
                placeholder = R.string.input_green
            ){
                if (it.length < 3 ) {
                    green = it.uppercase()
                    isValidGreen = isValidChannel(it)
                }
            }
            ColorTextField(
                modifier = Modifier.weight(1f),
                color = blue,
                isValidColor = isValidBlue,
                label = R.string.blue,
                placeholder = R.string.input_blue
            ){
                if (it.length < 3 ) {
                    blue = it.uppercase()
                    isValidBlue = isValidChannel(it)
                }
            }
        }
        ColorPreview(
            modifier = Modifier,
            color = getColor(red, green, blue),
        ){
            Text(
                modifier = Modifier
                    .padding(8.dp),
                text = "#${getColorString(red, green, blue).uppercase()}",
                fontSize = 24.sp,
                textAlign = TextAlign.Center,
            )
        }
        Button(
            modifier = Modifier.padding(vertical = 8.dp),
            onClick = {
                red = ""
                green = ""
                blue = ""
            }
        ) {
            Text(stringResource(R.string.reset))
        }
    }
}

Handling State

Ignoring my questionable UI design decisions, let's focus on this part of ColorMixerUI:

    var red by rememberSaveable { mutableStateOf("") }
    var green by rememberSaveable { mutableStateOf("") }
    var blue by rememberSaveable { mutableStateOf("") }
    var isValidRed by rememberSaveable { mutableStateOf(true) }
    var isValidGreen by rememberSaveable { mutableStateOf(true) }
    var isValidBlue by rememberSaveable { mutableStateOf(true) }

That is the use of the remember API and MutableState<T> to trigger recomposition and update the app's UI state. rememberSaveable is the variant of remember that survives configuration changes (eg: screen rotation).

Final Words

This project is a brief introduction to Android development, you now have an idea on how to put things together and build basic UIs. Check the references for more details, the project repository is also there.

See you in the next post, happy coding!

References

RGB Color Mixer Repository

Jetpack Compose UI App Development Toolkit

ComponentActivity API Reference

Thinking In Compose

TextField

Text

Button

Surface In Jetpack Compose

Compose Modifiers

App Resources Overview

Compose Layout Basics

State and Jetpack Compose

EOF

Hi, dear readers! I'm posting this article before the one related with the project because I realised it would be better to give a short introduction to new concepts before the real project.

That said, let's have a small introduction to Jetpack Compose.

Jetpack Compose

Jetpack Compose is a modern toolkit to develop Android apps' UI. Compared to the old Views approach that uses XML, this is a lot easier and a less verbose way to create UIs and their functionalities.

Visual elements are created by using special functions called composable functions. These functions not just declare how an element looks, they also declare how it behaves. They increase code reusability and testing.

For a function to be considered a composable, it must be annotated by the @Composable annotation, and composable functions can only be called if the @Composable context exists somewhere up in the call stack.

There is also the @Preview annotation, as the name tells us, its purpose is to allow us to see a preview of the composable, but there is a restriction for functions with arguments: they must have default values.

State Management

A state is a value that can change anytime in the app. Composition is the description of the UI built by Jetpack Compose when it executes composables, taking the form of a tree of UI elements. This represents a state of the UI, and the only way to update it is to run the composables again due to the declarative nature of Jetpack Compose.

The first time a composable is executed it's called initial composition. When a state changes for a composable and it needs to be rebuilt, we call it recomposition.

Composables can use the remember API to store mutable or immutable objects in memory. The value is stored during the initial composition, and restored during recomposition.

mutableStateOf creates an observable MutableState<T>, which is an observable type. The MutableState<T> interface contains a value: T field that schedules recomposition for all composables that read it when the value changes.

Final Words

In this article, we had a brief introduction to Jetpack Compose. This is enough to get started on Android projects, additional features are better learned in practice.

See you in the next article, happy coding.

References

Jetpack Compose UI App Development Toolkit

Thinking In Compose

State And Jetpack Compose

Lifecycle Of Composables

EOF

Hi, it's been a while. I know I promised I'd focus on projects instead of theory, but I promise to not be extensive and just give a small introduction to key components in Android apps.

Android Applications

To build apps for Android systems, you need the tools in the Android SDK (Software Development Kit) that compile your source code to the .apk (Android Package) or .aab (Android App Bundle) formats. Android apps are written mainly in Java, Kotlin and C++.

The main difference between an .apk and an .aab is that the first one contains all resources needed by the Android application at runtime, while the second one has the contents of an Android project, including metadata. .apk files are used by the Android system to install apps, while the .aab is a publishing format, from which an .apk can be generated for the specific device requesting installation — from Google Play, for example.

Android is a multi-user system, where each application runs as a different user in a sandbox, with each application isolated from the others. Of course there are means to allow communication between apps, but this must be explicitly declared. Each app runs in its own process, but it's also possible to make apps share the same process, but, again, this must be declared explicitly.

App Components

An Android app can be built upon four main components: Activities, Services, Broadcast Receivers, and Content Providers.

Each component serves its own purpose, and they all can be an entry point for Android apps. Apps can expose their own components for others to use.

Activity

This component represents a single screen that the user directly interacts with when opening the app. An app can have multiple activities forming a cohesive flow. For example, a banking app might first bring you to the login screen, then the balance screen and then the transfer screen, etc, where each screen can be specified by an Activity.

This is the most common component in Android apps; you can do a lot with only this component.

Service

This component is more suitable for background long-term tasks like file downloading, audio playback, data sync, etc. Services can be started by other apps' components, an activity, for example, and they do not provide a user interface. There are two types of services: Started and Bound.

Started Services run in the background until they finish their task. The user may or may not be aware of the service execution, and this impacts how the Android system manages memory. Audio playback is an example of a service that the user notices, so only in really necessary cases the Android system would kill it to reclaim memory, while background data sync the user would not even notice.

Bound Services expose an API for inter-process communication. When an app binds to a service, the Android system prioritizes it at the same level as the app the user is interacting with.

Broadcast Receiver

This component allows your app to respond to events outside user interactions, even when not running. Imagine you want your app to perform an action when the device is turned on, when the battery is low, etc.

They are commonly used as a gateway for other components; they are intended to do as little work as possible. Apps can also send events through Intents to trigger other apps' Broadcast Receivers.

Content Provider

This component allows other apps to access another app's private data, following the rules the app states. For example, an app that allows you to choose a profile picture from your gallery can access the pictures from the gallery app's content provider.

Content Providers are often mistaken for database abstractions, but they are actually a URI-based interface for sharing data across apps. This data can be from a database, internal storage, files, network, etc.

Intents

Android apps cannot interact directly because the Android system architecture isolates them. This is where Intents come into play.

Intents act like messengers between the components, and are delivered by the system to their targets.

Intents can be explicit (specify a component) or implicit (specify a type of component). For example, a note-taking app can use an explicit intent to open the screen to show a specific note's content, and an implicit intent when you click the share button to allow you to choose which app you'd like to use to share your notes.

Final Words

In this article, we gave a brief introduction to Android app components. I also wanted to introduce Jetpack Compose here, but this is more suitable for the next article (spoiler: It's a project).

Thanks for your attention, see you in the next article.

References

Application fundamentals

Introduction to Activities

Services Overview

Broadcasts Overview

Content Providers

Intents And Intent Filters

EOF

It's been so long since my first article, but I'm committing to posting more regularly.

This article introduces the Android Development Fundamentals series, a documentation of my path as an Android developer. I hope this series also helps beginners like me to understand the fundamentals without feeling overwhelmed by the information available, especially from the updates that drastically change the way things are done.

Who This Series Is For

This series is for beginners in Android Development, not for beginners in programming, so at least the basics of Kotlin are necessary.

I don't plan to write articles introducing Kotlin (yet), so if you don't know Kotlin, I recommend learning it on your own from a course, book, etc. The official documentation is a good starting point. Come back when you learn what a class, data class, lambda and higher-order function, List, MutableList are.

Topics and Methodology

First I'll cover the Android system architecture and the main components of apps. Then we'll introduce Jetpack Compose, its basic composables and modifiers, recomposition concept, navigation, tests, API requests, storage... you know, the fundamentals you probably saw in a roadmap before landing here.

For each article, I want to be more practical, so I'll give just enough theory at the start of the articles, then we'll build a small project from that and integrate the rest of the theory in a more natural way. Practicing, committing mistakes, and solving them is more efficient, so let me warn you that you're going to find errors not mentioned in the articles during your implementations. I encourage you to read the error messages, search for them to understand what is going on and solve them.

The source code of all projects will be available on my GitHub, so feel free to explore it. The link to the repository and my references will be at the end of my articles.

Asking Questions

If something is confusing or not clear in the article, feel free to ask, but first, I recommend you try to find it by yourself. This is an important skill for developers, especially in the AI era. Sometimes we ask questions that already have answers and can be found with a quick Google. Beginners tend to do that because they don't even know about that, so I want to make sure you develop this skill early.

I'm not saying you cannot ask questions and try to solve everything alone, I'm just saying that you should at least check if someone else had the same problem (99% of the cases the answer is yes). I recommend reading this article for better understanding.

AI is also a great tool, but be careful when using it. AI commits mistakes in a confident way — the more you know about the topic, the more you can spot the lies — so at least complement the answer with parallel research.

Final Words

I hope this series helps you learn Android development, and I will do my best to write clear, concise articles and readable code.

See you in the next article, subscribe and tell me in the comments why you chose to learn Android Development in the first place.

EOF

From the title, you might think I'm a senior developer or someone with extensive market experience, but I’m still on my journey. This first article explores my path in the programming world and the lessons I’ve learned over the past decade since writing my first line of code at 14. Take your coffee and join me as I share my story and insights. What has your journey been like?

What Brought Me Here?

Natural Curiosity?

Like any child, I was curious. Period. I had a passion for science and inventions. After cartoons, I’d spend all day watching documentaries about animals, biology, chemistry, history, technology, the cosmos, etc. I know, it sounds nerdy, but those were my interests. I also loved to do experiments at home, observing bugs (once I was late to class because I stopped on the way to watch a spider eat). Who never messed up the electrical installation due to an electrical experiment? Please, tell me I was a normal kid.

Now, as an adult, I see that I have lost part of this genuine thirst for knowledge. I’m trying to recover at least part of it, but responsibilities require time and energy, and both are scarce. Maybe I just finished the learning process every child goes through, I don’t know, but I miss watching “Cosmos: A Spacetime Odyssey”.

Sci-Fi?

I LOVED Sci-Fi, especially those with hackers and scientists who make spaceships and robots. I always dreamed of being like those characters, inventing anti-gravity, jetpacks, time machines, portals, flying cars… Sci-Fi stuff.

CSI Cyber and Scorpion were my favorite series in my teenage years; unfortunately, they were canceled. Yes, I didn’t mention Mr. Robot because after entering high school, I was more into anime, so… sorry, I’m ashamed to admit that I never finished the first season, but I know its reputation.

Informatics Course?

In my 11s, a friend convinced me to attend an informatics course. It was free (except for the registration fee). I asked my dad, and I started the course. There, I learned the basics of Microsoft Office, and PowerPoint was my favorite module.

Before that, I only remember playing games on my father’s laptop at the same age and on my brother’s computer when I was 9. I remember that my father’s computer suffered from high memory usage because I opened and minimized the games for days. Dozens of processes for each game were still open, and I thought that "suspend the computer" meant "turn off."

Anyway, unfortunately, I missed the day we were to learn how to use the internet, but it made no difference. After getting the certificate, I asked my aunt for a computer (thank God I didn’t ask for a PS3), and after months of waiting, I got my own notebook. Windows 8 was different from what I was used to in the informatics course, but I adapted quickly.

I used it for playing games, recording videos, and creative work (painting, video editing, and music creation). I used my computer a few times per month only for these purposes, as we had no internet at home at that time (at least no Wi-Fi).

First Steps

“How to become a hacker“

I spent most of my mom’s mobile data searching about this. I read many tutorials, especially from WikiHow. When I got my first smartphone in 2014, I installed an app that compiled many tutorials. I learned some concepts of cybersecurity, hacker slang, command prompt, HTML, and some basic batch scripts. I didn’t want to use ready-to-use tools because I read that real hackers should be able to create their own tools, and being a script kiddie was shameful, as you’d be limited by your tools.

In the journey to become a true hacker, I discovered programming languages. Python caught my attention because it was described as “easy to learn, but powerful.” I didn’t know what that meant, but it sounded cool.

print “Hello World“

My first “Hello World” came to life in 2016, in a Python interpreter for Android. I used that app and an offline tutorial from Python Brasil to learn the basics. “What about your computer?” you may be asking. It is still in good condition, thanks for asking (if you did).

I was coding on my phone because I didn’t have constant access to the internet. I could download the Python interpreter for Windows months later at my classmate’s house. After receiving a modem from my sister-in-law (for mobile data), I could explore a little more.

Some meaningful projects

From what I can remember, I tried to make games in Python with Pygame, but I struggled to animate the characters from the frame images. I made a single-level game that didn’t look like a real game because it didn’t have collectibles or enemies, but it was a good enough copy of Super Mario. I was creating a second level, but the frame animation frustrated me, so I abandoned this project (my graveyard is full of them).

I also remember playing with sockets and file I/O. I made some trashy GUI projects and tried to create a file editor, but it was just a script that read everything from STDIO and then wrote it to a file specified at initialization.

Playing with sockets was the most fun part; I even made a RAT where the client was on my phone running in the Python interpreter app.

High School

The deception

In 2017, I entered high school with high expectations about the content. I thought we’d learn how to program from the first day or even disassemble computers, but I was surprised by the focus on theory. I already knew the history of computers from the informatics lessons I had since the 7th grade, but I didn't even imagine there were other numerical systems beyond decimal and binary, or the concept of algorithms and the different areas in technology. It was disappointing at the time, but now I know how useful this knowledge is.

Learning C and VisuAlg before everyone

In the first year, the teacher told us which languages we’d learn each year. At that time, school ran from February to November/December. C was planned to be taught in the second year, but I learned it in the first year from the book the teacher recommended: Linguagem C - Luis Damas. Don’t worry about looking for it if you don’t speak Portuguese.

I liked learning C more than Python. I felt like all my doubts were being answered. In Python, you have a high level of abstraction, and many concepts are hidden, while in C, you are forced to know the basics. That’s why I recommend C for beginners. I finished the book, but in high school, we only reached the topic of vectors and matrices. Not even pointers were mentioned, only variables, loops, vectors, and matrices concepts.

VisuAlg was introduced in the middle of the first year. It was a pseudocode language like Portugol. VisuAlg is based on Pascal syntax, not so different from C.

C#, HTML, CSS, JavaScript, PHP and MySQL

In the middle of the second year, I had a brief introduction to C# due to school lessons, but it was so quick that I didn’t even bother to learn it, and there were new concepts that seemed too complex to me.

I updated my HTML knowledge to HTML5 and learned the basics of CSS and JavaScript from Gustavo Guanabara's lessons (the teacher of all programmers… at least the ones who speak Portuguese). At school, we were introduced to PHP and used DreamWeaver (even at that time, it was too old for senior developers). The drag and drop wasn’t my style, so I learned the language basics from one of my downloaded PDFs and did all school exercises manually.

I also learned MySQL (also from teacher Guanabara). At that time, I thought I was born to be a backend developer; creating interfaces wasn’t my vibe, which is why I delegated this task to someone else in the final project.

My story with Assembly

After learning C, I developed a liking for raw languages and the control they provided, so I tried some Assembly. I didn’t get very far because the complexity was too high for my level, but I learned how to read a string from STDIN, convert strings to integers, perform basic operations (addition, subtraction, multiplication, and division), convert the result to a string, and print it on STDOUT.

I even dared to try to create an operating system, but the materials were beyond my comprehension, and the tutorial I followed on keyboard events and printing text on the screen. I loved doing that, and maybe one day I’ll do it again. If you are interested, take a look at ZenityOS.

Survivor projects

From the projects I made in high school, these two are the ones I cared enough to save on GitHub:

Electrosfera: This project simulates a power company, and the main goal was to implement CRUD operations. I used obsolete code and even hid the warnings because I was doing it under pressure and applying the Extreme Go Horse methodology.

Asclepio Site: This was the final project. It was developed to allow parents to check their son's grades online. Many of them don’t have time on Saturdays to attend the meetings that happen twice a year, so being able to do it online, along with a summary of the behavior, was proposed as a solution.

College

Java: Loved by some and hated by everyone

In 2021, during the first semester, I reviewed everything I learned in high school. From the second semester, we started using Java. I studied it in advance after finishing high school because I was interested in Android development. I don't know why everyone hates Java online; it is a great language. This is one of the projects I made in Java in college. It's nothing fancy or usable, but it was enough to get approved.

In the second year, we did a web project in Java. At first, I tried to do it manually using JSP, but it wasn’t working, so I tried Spring Boot. From that day on, I changed my mind about frameworks, as I could focus more on functionalities.

Kotlin

Kotlin was getting popular; it became the new standard for Android development. When I had to do a project with Spring Boot, I had the idea to test the interoperability between Java and Kotlin. First, I tried to do it on Eclipse, but I was getting errors. Then I discovered IntelliJ IDEA from JetBrains, and I fell in love with that IDE. I don't use anything else but IntelliJ for Java/Kotlin projects.

This is the project, by the way. It’s a platform to sell organs on the Deep Web (of course it's not real). My partner and I didn’t finish all the functionalities. We also wanted to access it via TOR and put it online during the defense, but it didn’t work.

PHP again?

In college, I had two subjects related to web development. We had to use pure PHP at first. I used the opportunity to learn Docker and MongoDB. Docker was intuitive, but MongoDB was a nightmare. The documentation stated one thing, and it didn’t work. It took me too much time to figure out how to use it from non-official resources. In this project, I made a forum about animes (or it was supposed to be, I didn’t finish), and in this one, it was supposed to be a website to check Euro 24 competition information. I enjoyed doing the UI too much, so I neglected the backend, especially the last one where I decided to learn TailwindCSS.

In the other subject, we had to use a PHP framework. I chose Laravel, but I couldn’t finish the project, unfortunately. I was having problems during the development process, and I was so exhausted by all of it that my productivity multiplied by absolute zero. Fortunately, I got a good grade to pass, thanks to the teacher!

Data Structures & Algorithm and Competitive Programming

During the lockdown in 2020, I read somewhere that the fundamentals of Data Structures & Algorithms are essential for any programmer. I was studying Java, so I learned the basic data structures, how to build them, and their pros and cons.

I should have learned it deeply because the next year I was about to discover competitive programming. For those who don’t know what it is, you probably know Leetcode (I expect, this is the most famous platform). There, you solve programming problems, and your solution is heavily tested and ranked according to performance. Of course, there is a time limit in which your solution must return the answer!

From my experience, Leetcode isn’t the main choice among competitive programmers. It’s more for those who want to practice for tech interviews at Big Techs like Amazon, Google, and Meta. Codeforces, Vjudge, and Atcoder are the ones I see the most, but there are dozens or even hundreds of them, but the principle is the same: solve problems in the most efficient way quickly.

In college, I had the opportunity to participate in the regionals of ICPC, where each university is represented by at most three teams with three members each. I also heard about IOI and others, but I couldn’t participate, so I didn’t care about them. Unfortunately, in my three participations, my team couldn’t qualify… that’s sad, but it happens. Now I sometimes participate in Codeforces weekly contests, and seldom in Leetcode weekly or biweekly contests. I noticed a small improvement in my abilities; maybe one day I will get into the top 100, 10, or even first place.

Competitive programming was a game changer in my life as a programmer. I still have a lot to improve, but my problem-solving skills increased a lot. I recommend this practice at least as a hobby. You don’t need to participate in weekly contests; not everyone has time for that. You can do a virtual participation (do past contests) or just solve individual exercises. In Codeforces and Atcoder, you can see the editorial if you get stuck and don’t know how to solve a problem (not in the middle of the contest, obviously), but on Leetcode, you can only see the solutions after submitting one that gets accepted. But don’t worry, YouTube is full of solutions for Leetcode problems.

Getting My First Car In Two Months As A Freelancer

I wish it were that easy :’).

During the lockdown, I decided to try freelancing. I had just turned 18 and wanted to make some money (and upgrade my computer). I chose platforms that supported Payoneer because PayPal wasn’t an option due to its limitations in my country. Almost no payment service supported transactions in my country, which was frustrating.

I first tried Workana. It has an approval process for new freelancers. I waited for weeks for an answer. I could have paid for a faster review, but I didn’t want to (I was broke anyway). I logged out and never returned, so I don’t know whether I got approved or not. Fiverr and Upwork gave me the best results, especially Fiverr.

I admit I wasn't even at a Junior level at that time, but I was confident I could do basic jobs (probably that was the reason Workana was taking so long to review my profile). I created all these accounts in 2021, but I only decided to be more serious in 2024, when I got my first clients.

On Fiverr, I did some basic Java tasks. My clients were all college students, and they were paying me to do their homework. From these jobs, I learned more about SOLID principles and design patterns, and I increased my skills in software engineering. Their teachers provided a source code that the students had to modify to meet the project requirements. The project I enjoyed the most was the HTML validator. I got excited when I heard about it because, in my Data Structure & Algorithms studies, I had already seen something related when I read the chapter about stacks. Of course, I struggled with the GUI, but it worked perfectly.

After some time, I decided to move to Android app modifications. I got one client and was able to meet his expectations. My smartphone was stolen, and my computer couldn’t handle the emulator without running out of memory. My mother wouldn’t let me test on her device (I took it sometimes when she wasn’t aware, but not enough time to study). I had to rely on Waydroid to test the apps. The RAM usage was slightly better, but the virtual device was rebooting constantly, and sometimes bugs happened in the system.

Working on Fiverr was challenging, but Upwork was worse (my fault). I got two jobs there. The first was a bug fix for an Android app; the client was trying to modify the UI from another thread that was listening for socket communication. The second and last one was to build a quiz creator website to play in an Android app with the possibility of exporting to PDF. I shouldn’t have accepted that job. I promised an unrealistic deadline, couldn’t finish the project, and even ignored the client for days… until he canceled the job and my account was locked. I only got the courage to try to unlock my account one year later, but at least I learned that lying just to get a client doesn’t work; that’s not professional.

“The Answer to the Ultimate Question of Life, the Universe, and Everything“

In 2023, I started my admission process at 42 Luanda, one of the campuses of the 42 Network. You don’t know what it is? Let me introduce you to the best programming school in the world.

In a few words, 42 is a programming school founded by (checking notes) Xavier Niel, Nicolas Sadirac, Kwame Yamgnane, and Florian Bucher in 2013 in Paris. It differs from traditional institutions because you don’t have teachers; you learn from your peers. It’s open 24/7 and it’s free forever. There, you have all the infrastructure you might need to learn programming, and the assurance that after finishing the mandatory part of their curriculum, you’ll have an almost 100% chance of getting a job. That’s almost 100% because some students start their own companies. They are the most inclusive institution you may find, and the content you learn is the same on all campuses. Ok, I don’t want to explain here something you can check on their website.

During the lockdown (ok, this is the last time), I found out about the school from Fabio Akita, but a campus would open only 3 years later (the inauguration plans were delayed thanks to COVID). The admission process was long and challenging, especially the piscine (the last step). They want to make sure you really want it and can adapt to their methodology. It doesn’t matter if you are a senior software engineer or a computer scientist; this is not a guarantee you will get approved. Other factors matter, and the requirements to pass are still a secret.

In June 2025, I started my journey as a 42 student, and I must say that I’ve learned more in these few months than in years. Each project focuses on a single fundamental topic. Besides programming, you also have projects about system administration, networks, and games. Half of the projects are made in C, and the other half in C++ (some PHP for system administration projects, but there are at most two). The new curriculum is in Python, but it was implemented in December 2025, so not all were transitioned to the new common core (this is how the cursus is called).

After the common core, there is a mandatory internship, and then you have the choice to do a specialization. They are internationally recognized specializations; in Europe, they are at the same level as a Master's degree. I want to do a specialization, but I don’t know what to choose because they are all interesting. Maybe I’ll follow my dream to be a hacker and specialize in cybersecurity, or maybe in blockchain technology, or even mobile. I can do more than one specialization; maybe I’ll do those three aforementioned.

2026 And Beyond

First of all, I need to tackle the biggest problem in my life, the main reason why my skills haven't been sharp all these years: procrastination. Procrastination isn't laziness; it's a defense mechanism. To develop discipline and be consistent in practice, I first need to defeat my demons.

I started this blog not just to post about my experiences at 42, but also as a way to document my knowledge and share it with others. It's said that teaching is the best way to learn, and visualizing progress more clearly is also a good motivation.

42 Luanda projects, personal experiments, freelancing, competitive programming, Data Structures & Algorithms, Android development... these are all topics I'm willing to talk about. I hope you enjoy my content and give your feedback; this way, I can improve the quality of my content and bring topics you're more interested in.

Happy coding, see you next time.

EOF