Hi! I'm

Federico Calò

Software Developer | Technical Writer

I create modern web applications and custom digital tools to help businesses grow through technological innovation. My passion is combining computer science and economics to generate real value.

Contact Me

About Me

My passion for computer science was born at the Technical Commercial Institute of Maglie, where I discovered the power of programming and the fascination of creating digital solutions. From the start, I understood that computer science was not just code, but an extraordinary tool for turning ideas into reality.

During my studies in Business Information Systems, I began to interweave computer science and economics, understanding how technology can be the engine of growth for any business. This vision accompanied me to the University of Bari, where I obtained my degree in Computer Science, deepening my technical skills and passion for software development.

Today I put this experience at the service of businesses, professionals and startups, creating tailor-made digital solutions that automate processes, optimize resources and open new business opportunities. Because true innovation begins when technology meets the real needs of people.

My Skills

Data Analysis & Predictive Models

I transform data into strategic insights with in-depth analysis and predictive models for informed decisions

Process Automation

I create custom tools that automate repetitive operations and free up time for value-added activities

Custom Systems

I develop tailor-made software systems, from platform integrations to customized dashboards

const federico = {
  nome: "Federico Calò",
  ruolo: "Sviluppatore Software",
  città: "Bari, Italia",
  missione: "Aiutare attraverso l'informatica",
  passioni: [
    "Codice Pulito",
    "Innovazione",
    "Crescita Continua"
  ]
};

La Mia Missione

Credo fermamente che l'informatica sia lo strumento più potente per trasformare le idee in realtà e migliorare la vita delle persone.

🚀

Democratizzare la Tecnologia

La mia missione è rendere l'informatica accessibile a tutti: dalle piccole imprese locali alle startup innovative, fino ai professionisti che vogliono digitalizzare la propria attività. Ogni realtà merita di sfruttare le potenzialità del digitale.

💡

Unire Informatica ed Economia

Non è solo questione di scrivere codice: è capire come la tecnologia possa generare valore reale. Intrecciando competenze informatiche e visione economica, aiuto le attività a crescere, ottimizzare processi e raggiungere nuovi traguardi di efficienza e redditività.

🎯

Creare Soluzioni su Misura

Ogni attività è unica, e così devono esserlo le soluzioni. Sviluppo strumenti personalizzati che rispondono alle esigenze specifiche di ciascun cliente, automatizzando processi ripetitivi e liberando tempo per ciò che conta davvero: far crescere il business.

Trasforma la Tua Attività con la Tecnologia

December 2024

View

Master SQL

RoadMap.sh

Novembre 2024

View

Oracle Certified Foundations Associate

Oracle

October 2024

View

People Leadership Credential

Connect

Settembre 2024

💻 Languages & Technologies

☕Java

🐍Python

📜JavaScript

🅰️Angular

⚛️React

🔷TypeScript

🗄️SQL

🐘PHP

🎨CSS/SCSS

🔧Node.js

🐳Docker

🌿Git

💼

12/2024 - Presente

Custom Software Engineering Analyst

Accenture

Bari, Puglia, Italia · Ibrida Analisi e sviluppo di sistemi informatici attraverso l'utilizzo di Java e Quarkus in Health and Public Sector. Formazione continua su tecnologie moderne per la creazione di soluzioni software personalizzate ed efficienti e sugli agenti.

💼

06/2022 - 12/2024

Analista software e Back End Developer Associate Consultant

Links Management and Technology SpA

Esperienza nell'analisi di sistemi software as-is e flussi ETL utilizzando PowerCenter. Formazione completata su Spring Boot per lo sviluppo di applicazioni backend moderne e scalabili. Sviluppatore Backend specializzato in Spring Boot, con esperienza in progettazione di database, analisi, sviluppo e testing dei task assegnati.

💼

02/2021 - 10/2021

Programmatore software

Adesso.it (prima era WebScience srl)

Esperienza nell'analisi AS-IS e TO-BE, evoluzioni SEO ed evoluzioni website per migliorare le performance e l'engagement degli utenti.

🎓

2018 - 2025

Laurea in Informatica

Università degli Studi di Bari Aldo Moro

Bachelor's degree in Computer Science, focusing on software engineering, algorithms, and modern development practices.

📚

2013 - 2018

Diploma - Sistemi Informativi Aziendali

Istituto Tecnico Commerciale di Maglie

Technical diploma specializing in Business Information Systems, combining IT knowledge with business management.

Contattami

Hai un progetto in mente? Parliamone! Compila il form qui sotto e ti risponderò al più presto.

* Campi obbligatori. I tuoi dati saranno utilizzati solo per rispondere alla tua richiesta.

Configure the First KMP Project: Android, iOS and Desktop with Kotlin Multiplatform

Setting up a Kotlin Multiplatform project from scratch is one of the most technical steps of the entire KMP journey. Unlike Flutter where flutter create produces everything you need, or React Native where Expo handles complexity, KMP requires a solid understanding of Gradle, source set structure, and the expect/actual mechanism before you can write the first line of shared logic.

This guide takes you from creating your blank project to a working application with code shared between Android and iOS, showing each configuration step with detailed explanations. At the end you will have a project with the correct structure, Gradle version catalog configured, and the first ones expect/actual functions working.

Prerequisites

Android Studio Hedgehog (2023.1.1) or higher with KMP plugin installed
Xcode 15+ (to build the iOS app — only on macOS)
JDK 17+ configured as JAVA_HOME
Basic knowledge of Kotlin and Gradle

Step 1: Create the Project with KMP Wizard

The fastest way to get started is to use the Kotlin Multiplatform Wizard available at the address kmp.jetbrains.com or directly from Android Studio via File → New → New Project → Kotlin Multiplatform App.

# Alternativa da riga di comando con il KMP Wizard CLI (2026)
# Installa il plugin KMP di IntelliJ/Android Studio dal marketplace
# oppure usa il sito web:
# 1. Vai su https://kmp.jetbrains.com
# 2. Configura: nome progetto, package, target (Android, iOS, Desktop)
# 3. Scarica il progetto e aprilo in Android Studio

# Struttura generata dal wizard:
my-kmp-app/
├── composeApp/              # (se scegli Compose Multiplatform)
│   └── build.gradle.kts
├── shared/                  # Il modulo condiviso principale
│   ├── src/
│   │   ├── commonMain/
│   │   ├── androidMain/
│   │   └── iosMain/
│   └── build.gradle.kts
├── androidApp/              # App Android standalone
│   └── build.gradle.kts
├── iosApp/                  # App iOS standalone (Swift)
│   └── iosApp.xcodeproj
├── gradle/
│   └── libs.versions.toml   # Version catalog
├── build.gradle.kts         # Root build script
└── settings.gradle.kts

Step 2: The Version Catalog (libs.versions.toml)

Il Gradle Version Catalog centralizes version management of all project dependencies in a single TOML file. It is the best practice recommended by JetBrains for KMP projects:

# gradle/libs.versions.toml
[versions]
kotlin = "2.0.20"
kotlinx-coroutines = "1.9.0"
kotlinx-serialization = "1.7.3"
ktor = "2.3.12"
sqldelight = "2.0.2"
koin = "3.5.6"
agp = "8.5.2"
compose-multiplatform = "1.7.0"
kotlinx-datetime = "0.6.1"

[libraries]
# Kotlin
kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }

# Coroutines
kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "kotlinx-coroutines" }

# Serialization
kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinx-serialization" }

# Ktor
ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
ktor-client-okhttp = { module = "io.ktor:ktor-client-okhttp", version.ref = "ktor" }
ktor-client-darwin = { module = "io.ktor:ktor-client-darwin", version.ref = "ktor" }
ktor-client-content-negotiation = { module = "io.ktor:ktor-client-content-negotiation", version.ref = "ktor" }
ktor-serialization-json = { module = "io.ktor:ktor-serialization-kotlinx-json", version.ref = "ktor" }

# SQLDelight
sqldelight-runtime = { module = "app.cash.sqldelight:runtime", version.ref = "sqldelight" }
sqldelight-android-driver = { module = "app.cash.sqldelight:android-driver", version.ref = "sqldelight" }
sqldelight-native-driver = { module = "app.cash.sqldelight:native-driver", version.ref = "sqldelight" }
sqldelight-coroutines = { module = "app.cash.sqldelight:coroutines-extensions", version.ref = "sqldelight" }

# Koin DI
koin-core = { module = "io.insert-koin:koin-core", version.ref = "koin" }
koin-android = { module = "io.insert-koin:koin-android", version.ref = "koin" }

# DateTime
kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" }

[plugins]
android-application = { id = "com.android.application", version.ref = "agp" }
android-library = { id = "com.android.library", version.ref = "agp" }
kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
compose-multiplatform = { id = "org.jetbrains.compose", version.ref = "compose-multiplatform" }
sqldelight = { id = "app.cash.sqldelight", version.ref = "sqldelight" }

Step 3: The Shared Module Build Script

Il build.gradle.kts of the shared module is the most important configuration file of the project. Defines the build targets, source sets and dependencies of each:

// shared/build.gradle.kts
plugins {
  alias(libs.plugins.kotlin.multiplatform)
  alias(libs.plugins.android.library)
  alias(libs.plugins.kotlin.serialization)
  alias(libs.plugins.sqldelight)
}

kotlin {
  // Target Android
  androidTarget {
    compilations.all {
      kotlinOptions {
        jvmTarget = "17"
      }
    }
  }

  // Target iOS (arm64 per device, x64 per simulator Intel, simulatorArm64 per M1/M2)
  listOf(
    iosX64(),
    iosArm64(),
    iosSimulatorArm64()
  ).forEach { iosTarget ->
    iosTarget.binaries.framework {
      baseName = "Shared"
      isStatic = true
    }
  }

  // Target Desktop JVM (opzionale)
  jvm("desktop")

  sourceSets {
    // Codice comune a tutte le piattaforme
    commonMain.dependencies {
      implementation(libs.kotlinx.coroutines.core)
      implementation(libs.kotlinx.serialization.json)
      implementation(libs.ktor.client.core)
      implementation(libs.ktor.client.content.negotiation)
      implementation(libs.ktor.serialization.json)
      implementation(libs.sqldelight.runtime)
      implementation(libs.sqldelight.coroutines)
      implementation(libs.koin.core)
      implementation(libs.kotlinx.datetime)
    }

    // Test comuni
    commonTest.dependencies {
      implementation(libs.kotlin.test)
    }

    // Android-specific
    androidMain.dependencies {
      implementation(libs.ktor.client.okhttp)
      implementation(libs.sqldelight.android.driver)
      implementation(libs.kotlinx.coroutines.android)
    }

    // iOS-specific
    val iosMain by getting {
      // Su iOS non puoi usare "iosMain" direttamente se hai piu target iOS
      // Usa una convenzione condivisa per i tre target iOS
    }
    val iosX64Main by getting
    val iosArm64Main by getting
    val iosSimulatorArm64Main by getting

    // Source set condiviso per tutti i target iOS
    create("iosMain") {
      dependsOn(commonMain.get())
      iosX64Main.dependsOn(this)
      iosArm64Main.dependsOn(this)
      iosSimulatorArm64Main.dependsOn(this)

      dependencies {
        implementation(libs.ktor.client.darwin)
        implementation(libs.sqldelight.native.driver)
      }
    }
  }
}

android {
  namespace = "com.example.mykmpapp.shared"
  compileSdk = 35
  defaultConfig {
    minSdk = 26
  }
  compileOptions {
    sourceCompatibility = JavaVersion.VERSION_17
    targetCompatibility = JavaVersion.VERSION_17
  }
}

sqldelight {
  databases {
    create("AppDatabase") {
      packageName.set("com.example.mykmpapp.db")
    }
  }
}

Step 4: Understanding Source Sets

I source set they are the fundamental structure of KMP. Each source set is one directories of Kotlin code with its dependencies, and source sets may depend on others through the hierarchy dependsOn:

// Gerarchia dei source set tipica
commonMain
├── androidMain       (usa librerie Android: OkHttp, Android SQLite)
├── iosMain           (usa librerie Darwin: URLSession, iOS SQLite)
│   ├── iosX64Main
│   ├── iosArm64Main
│   └── iosSimulatorArm64Main
└── desktopMain       (usa librerie JVM: OkHttp, SQLite JDBC)

// Tutti i source set "eredita" le dipendenze di commonMain
// androidMain puo usare tutto di commonMain + dipendenze Android-specific

In the project filesystem, the directory structure reflects the source sets:

shared/src/
├── commonMain/
│   └── kotlin/
│       └── com/example/mykmpapp/
│           ├── data/
│           ├── domain/
│           └── Platform.kt  # expect declaration
├── androidMain/
│   └── kotlin/
│       └── com/example/mykmpapp/
│           └── Platform.android.kt  # actual per Android
└── iosMain/
    └── kotlin/
        └── com/example/mykmpapp/
            └── Platform.ios.kt  # actual per iOS

Step 5: The First expect/actual Functions

The mechanism expect/actual and how KMP handles platform-specific differences. expect declare the API in common code, actual implements it for each platform. Let's start with a classic example: getting information about the current platform:

// commonMain/kotlin/com/example/mykmpapp/Platform.kt
expect class PlatformInfo() {
  val name: String
  val version: String
  val isDebug: Boolean
}

// Funzione che usa l'implementazione platform-specific
fun greeting(): String = "Running on ${PlatformInfo().name} ${PlatformInfo().version}"

// androidMain/kotlin/com/example/mykmpapp/Platform.android.kt
import android.os.Build

actual class PlatformInfo {
  actual val name: String = "Android ${Build.VERSION.RELEASE}"
  actual val version: String = Build.VERSION.SDK_INT.toString()
  actual val isDebug: Boolean = BuildConfig.DEBUG
}

// iosMain/kotlin/com/example/mykmpapp/Platform.ios.kt
import platform.UIKit.UIDevice

actual class PlatformInfo {
  actual val name: String = UIDevice.currentDevice.systemName()
  actual val version: String = UIDevice.currentDevice.systemVersion
  actual val isDebug: Boolean = Platform.isDebugBinary
}

A second more practical example: generating UUID (which uses different APIs per platform):

// commonMain: dichiarazione expect
expect fun generateUUID(): String

// androidMain: implementazione con java.util.UUID
actual fun generateUUID(): String = java.util.UUID.randomUUID().toString()

// iosMain: implementazione con NSUUID di iOS
import platform.Foundation.NSUUID
actual fun generateUUID(): String = NSUUID().UUIDString()

Step 6: Configure the Android App

The Android app is a standard Gradle module that depends on the shared module. The configuration and simple:

// androidApp/build.gradle.kts
plugins {
  alias(libs.plugins.android.application)
  alias(libs.plugins.kotlin.android)
}

android {
  namespace = "com.example.mykmpapp.android"
  compileSdk = 35
  defaultConfig {
    applicationId = "com.example.mykmpapp"
    minSdk = 26
    targetSdk = 35
    versionCode = 1
    versionName = "1.0"
  }
  buildFeatures {
    compose = true
  }
}

dependencies {
  // Dipende dal modulo shared
  implementation(projects.shared)
  // UI Android (Compose o View-based)
  implementation(platform("androidx.compose:compose-bom:2026.01.00"))
  implementation("androidx.compose.ui:ui")
  implementation("androidx.compose.material3:material3")
  implementation("androidx.activity:activity-compose:1.9.3")
}

Step 7: Configure the iOS App

iOS integration requires you to configure Xcode to include the compiled KMP framework. The shared module is compiled into an iOS framework (Shared.xcframework) that is linked to the Xcode app:

# Script di build iOS da aggiungere come Xcode Build Phase:
# "Run Script" - da aggiungere in Build Phases di Xcode

cd "$SRCROOT/.."

# Compila il framework KMP per il target iOS corrente
if [ "$PLATFORM_NAME" = "iphonesimulator" ]; then
  if [ "$ARCHS" = "arm64" ]; then
    TARGET="iosSimulatorArm64"
  else
    TARGET="iosX64"
  fi
else
  TARGET="iosArm64"
fi

./gradlew "shared:link${TARGET}DebugFrameworkIos${TARGET^}" \
  -Pkotlin.native.useEmbeddableCompilerJar=true

# Il framework viene copiato automaticamente da Gradle

In the iOS app's Swift file, the framework imports like a regular Swift framework:

// iosApp/ContentView.swift
import SwiftUI
import Shared  // Il framework KMP compilato

struct ContentView: View {
  @State private var greeting = ""

  var body: some View {
    VStack {
      Text(greeting)
        .padding()
      Button("Refresh") {
        greeting = Greeting().greeting()
      }
    }
    .onAppear {
      // Chiama il codice Kotlin dal framework condiviso
      greeting = PlatformInfoKt.greeting()
    }
  }
}

Step 8: First Test of the Shared Module

Verify that everything works by writing and running a unit test in the shared module. Testing in commonMain uses kotlin.test which works on all platforms:

// commonTest/kotlin/com/example/mykmpapp/PlatformTest.kt
import kotlin.test.Test
import kotlin.test.assertNotNull
import kotlin.test.assertTrue

class PlatformTest {
  @Test
  fun testPlatformInfoNotNull() {
    val info = PlatformInfo()
    assertNotNull(info.name)
    assertNotNull(info.version)
  }

  @Test
  fun testGreetingContainsPlatform() {
    val greet = greeting()
    assertTrue(greet.contains("Running on"), "Greeting dovrebbe contenere 'Running on'")
  }

  @Test
  fun testUUIDFormat() {
    val uuid = generateUUID()
    // UUID formato: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
    assertTrue(uuid.length == 36, "UUID dovrebbe avere 36 caratteri")
    assertTrue(uuid.count { it == '-' } == 4, "UUID dovrebbe avere 4 trattini")
  }
}

# Esegui i test sul target JVM (piu veloce, per CI)
./gradlew shared:jvmTest

# Esegui i test su Android (emulatore o device)
./gradlew shared:connectedAndroidTest

# Esegui i test iOS (solo su macOS)
./gradlew shared:iosSimulatorArm64Test

Common Problems and Solutions

"Kotlin/Native toolchain not found" error: Make sure you have the JDK 17+ configured as JAVA_HOME and that Gradle has downloaded the toolchain Kotlin/Native (the first build is slower for this reason).
"actual declaration not found" error: You are using expect without providing a corresponding one actual for all configured targets. Check that the actual class/function exists in all source sets configured in kotlin { }.
Out-of-date iOS framework: After changes to the Kotlin code, clean the Xcode build (Cmd+Shift+K) and recompile. The framework must be recompiled with Gradle before Xcode can see it.
Library compatibility: Not all Java libraries work on iOS. Always use libraries with the "KMP" or "Kotlin Multiplatform" tag in the README.

Structure of the Final Project

At the end of this configuration, your project has this operational structure:

my-kmp-app/
├── gradle/
│   └── libs.versions.toml      # Version catalog centralizzato
├── shared/                      # Modulo KMP condiviso
│   ├── src/
│   │   ├── commonMain/kotlin/   # Logica condivisa
│   │   ├── commonTest/kotlin/   # Test condivisi
│   │   ├── androidMain/kotlin/  # Android-specific
│   │   └── iosMain/kotlin/      # iOS-specific
│   └── build.gradle.kts
├── androidApp/                  # App Android
│   ├── src/main/...
│   └── build.gradle.kts
├── iosApp/                      # App iOS (Xcode project)
│   ├── iosApp/
│   │   ├── ContentView.swift
│   │   └── iOSApp.swift
│   └── iosApp.xcodeproj
├── build.gradle.kts             # Root (plugin declarations)
└── settings.gradle.kts          # Moduli inclusi

Conclusions and Next Steps

You have set up a complete KMP project with Android, iOS and the shared module. The curve The learning curve of Gradle and source sets is steep at first, but the structure you have created and robust and scalable for enterprise projects.

The next article delves into theshared module architecture: how to use expect/actual for more complex patterns, how to set Koin for the dependency multiplatform injection, and how to structure the code to be easily testable in isolation.

Series: Kotlin Multiplatform — One Codebase, All Platforms

Article 1: KMP in 2026 — Architecture, Establishment and Ecosystem
Article 2 (this): Configure the First KMP Project — Android, iOS and Desktop
Article 3: Shared Module Architecture — expect/actual, Interfaces and DI
Article 4: Multiplatform Networking with Ktor Client
Article 5: Multiplatform Persistence with SQLDelight
Article 6: Compose Multiplatform — Shared UI on Android and iOS
Article 7: State Management KMP — ViewModel and Kotlin Flows
Article 8: KMP Testing — Unit Test, Integration Test and UI Test
Article 9: Swift Export — Idiomatic Interop with iOS
Article 10: CI/CD for KMP Projects — GitHub Actions and Fastlane
Article 11: Case Study — Fintech App with KMP in Production