Bună! Sunt

Federico Calò

Sviluppatore Software | Divulgatore Tecnico

Creo applicazioni web moderne e strumenti digitali personalizzati per aiutare le attività a crescere attraverso l'innovazione tecnologica. La mia passione è unire informatica ed economia per generare valore reale.

Contactează-mă

Despre Mine

La mia passione per l'informatica è nata tra i banchi dell'Istituto Tecnico Commerciale di Maglie, dove ho scoperto il potere della programmazione e il fascino di creare soluzioni digitali. Fin da subito, ho capito che l'informatica non era solo codice, ma uno strumento straordinario per trasformare idee in realtà.

Durante gli studi superiori in Sistemi Informativi Aziendali, ho iniziato a intrecciare informatica ed economia, comprendendo come la tecnologia possa essere il motore della crescita per qualsiasi attività. Questa visione mi ha accompagnato all'Università degli Studi di Bari, dove ho conseguito la Laurea in Informatica, approfondendo le mie competenze tecniche e la mia passione per lo sviluppo software.

Oggi metto questa esperienza al servizio di imprese, professionisti e startup, creando soluzioni digitali su misura che automatizzano processi, ottimizzano risorse e aprono nuove opportunità di business. Perché la vera innovazione inizia quando la tecnologia incontra le esigenze reali delle persone.

Competențele Mele

Analisi Dati & Modelli Previsionali

Trasformo i dati in insights strategici con analisi approfondite e modelli predittivi per decisioni informate

Automatizarea Proceselor

Creo strumenti personalizzati che automatizzano operazioni ripetitive e liberano tempo per attività a valore aggiunto

Sisteme Personalizate

Sviluppo sistemi software su misura, dalle integrazioni tra piattaforme alle dashboard personalizzate

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

Misiunea Mea

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

🚀

Democratizarea Tehnologiei

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.

💡

Unirea IT și Economiei

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à.

🎯

Crearea de Soluții Personalizate

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.

Transformă-ți Afacerea cu Tehnologia

Dicembre 2024

Visualizza

Master SQL

RoadMap.sh

Novembre 2024

Visualizza

Oracle Certified Foundations Associate

Oracle

Ottobre 2024

Visualizza

People Leadership Credential

Connect

Settembre 2024

💻 Linguaggi & Tecnologie

☕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.

Contactează-mă

Ai un proiect în minte? Hai să vorbim! Completează formularul și îți voi răspunde curând.

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

Feature-First Architecture cu Arhitectură curată în Flutter

Pe măsură ce o aplicație Flutter crește, structura codului devine factorul factor determinant între o aplicație care crește și una care acumulează datorii tehnice. Organizația Caracteristica-în primul rând — unde fiecare director de nivel superior reprezintă a funcționalitate de sine stătătoare — și modelul adoptat de principalele aplicații Flutter pentru întreprinderi succes în 2026, combinat cu principiile de Arhitectură curată de Robert C. Martin pentru a separa strict preocupările în cadrul fiecărei caracteristici.

Acest articol construiește o arhitectură completă de la zero: structură de directoare, implementarea celor trei straturi (date, domeniu, prezentare), injecție de dependență cu Riverpod și strategii pentru menținerea modulelor extractibile și testabil independent.

Ce vei învăța

Feature-First vs Layer-First: De ce primul se scalează mai bine în echipe mari
Cele trei straturi ale Arhitecturii Curate: date, domeniu, prezentare
Model de depozit: abstracția accesului la date cu interfețele Dart
Caz de utilizare (Interactor): Încapsulați logica de afaceri în clase testabile
Dependency Injection cu Riverpod: Cum să conectați straturile fără cuplare
Structura de director pentru un proiect Flutter de întreprindere
Testare pe strat: domeniu test unitar, prezentare test widget
Cum să extrageți o caracteristică într-un pachet Dart separat

Feature-First vs Layer-First: comparația fundamentală

Majoritatea tutorialelor Flutter organizează codul după tip: models/, repositories/, screens/. Această structură Layer-First pare foarte mică, dar nu se scalează.

# Layer-First (NON SCALABILE per progetti grandi)
lib/
  models/
    user.dart
    product.dart
    cart.dart
    order.dart
  repositories/
    user_repository.dart
    product_repository.dart
    cart_repository.dart
  screens/
    login_screen.dart
    product_list_screen.dart
    cart_screen.dart
  blocs/
    auth_bloc.dart
    product_bloc.dart
    cart_bloc.dart

# Problema: per aggiungere la feature "Cart" devi toccare
# 4 directory diverse. Impossibile estrarre il modulo.
# Team A e Team B modificano gli stessi file contemporaneamente.

# Feature-First (SCALABILE)
lib/
  features/
    auth/
      data/
      domain/
      presentation/
    products/
      data/
      domain/
      presentation/
    cart/
      data/
      domain/
      presentation/
  core/
    network/
    storage/
    theme/

# La feature "Cart" e completamente autonoma in lib/features/cart/
# Un team lavora su cart/ senza toccare le altre feature.
# In futuro: dart create --template=package cart e sposta la directory.

Anatomia unei caracteristici: cele trei straturi

În cadrul fiecărei caracteristici, Clean Architecture impune trei straturi cu dependențe unidirecționale: Prezentare depinde de Domeniu, Data depinde de Domeniu, dar Domeniul nu depinde de nimeni. Această regulă este inima a arhitecturii.

# Struttura completa della feature "products"

lib/features/products/
  # DOMAIN LAYER: entita pure Dart, nessuna dipendenza esterna
  domain/
    entities/
      product.dart          # Entita del dominio (pure Dart class)
      product_filter.dart   # Value object per i filtri
    repositories/
      products_repository.dart  # Interfaccia (abstract class)
    usecases/
      get_products_usecase.dart    # Recupera lista prodotti
      search_products_usecase.dart # Cerca prodotti per query
      get_product_detail_usecase.dart

  # DATA LAYER: implementa le interfacce domain con source concrete
  data/
    models/
      product_dto.dart       # DTO: mappa JSON API -> entita domain
    sources/
      products_remote_source.dart  # HTTP calls
      products_local_source.dart   # SQLite / Hive cache
    repositories/
      products_repository_impl.dart # Implementa ProductsRepository

  # PRESENTATION LAYER: UI e state management
  presentation/
    providers/
      products_provider.dart       # Riverpod providers
    pages/
      products_list_page.dart
      product_detail_page.dart
    widgets/
      product_card.dart
      product_filter_bar.dart

Stratul de domeniu: Interfață de entitate și depozit

# domain/entities/product.dart

// Entita: pure Dart, zero dipendenze da Flutter o pacchetti esterni
// Immutabile per convenzione (const constructor + final fields)
class Product {
  const Product({
    required this.id,
    required this.name,
    required this.price,
    required this.imageUrl,
    required this.category,
    this.description = '',
    this.rating = 0.0,
    this.inStock = true,
  });

  final String id;
  final String name;
  final double price;
  final String imageUrl;
  final String category;
  final String description;
  final double rating;
  final bool inStock;

  // copyWith: aggiorna campi mantenendo l'immutabilita
  Product copyWith({
    String? id,
    String? name,
    double? price,
    String? imageUrl,
    String? category,
    String? description,
    double? rating,
    bool? inStock,
  }) {
    return Product(
      id: id ?? this.id,
      name: name ?? this.name,
      price: price ?? this.price,
      imageUrl: imageUrl ?? this.imageUrl,
      category: category ?? this.category,
      description: description ?? this.description,
      rating: rating ?? this.rating,
      inStock: inStock ?? this.inStock,
    );
  }

  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      other is Product && runtimeType == other.runtimeType && id == other.id;

  @override
  int get hashCode => id.hashCode;
}

// domain/repositories/products_repository.dart

// Interfaccia: il Domain layer definisce IL CONTRATTO
// Il Data layer lo implementa. Il Domain non sa COME vengono presi i dati.
abstract interface class ProductsRepository {
  Future<List<Product>> getProducts({
    String? category,
    int page = 1,
    int limit = 20,
  });

  Future<Product> getProductById(String id);

  Future<List<Product>> searchProducts(String query);

  Future<void> refreshCache();
}

Stratul de domeniu: caz de utilizare

Cazurile de utilizare (sau Interactorii) încapsulează o singură acțiune logică de afaceri. eu sunt clase mici, testabile, cu o singură răspundere. Dacă un caz de utilizare crește prea mult și un semnal care trebuie împărțit.

# domain/usecases/get_products_usecase.dart

import 'package:my_app/features/products/domain/entities/product.dart';
import 'package:my_app/features/products/domain/repositories/products_repository.dart';

// Parametri del Use Case: value object per type safety
class GetProductsParams {
  const GetProductsParams({
    this.category,
    this.page = 1,
    this.limit = 20,
  });

  final String? category;
  final int page;
  final int limit;
}

// Use Case: dipende SOLO dall'interfaccia repository (domain)
// Non sa nulla di HTTP, Dio, SQLite o Riverpod
class GetProductsUseCase {
  const GetProductsUseCase(this._repository);

  final ProductsRepository _repository;

  Future<List<Product>> call(GetProductsParams params) {
    return _repository.getProducts(
      category: params.category,
      page: params.page,
      limit: params.limit,
    );
  }
}

// Test del Use Case: zero dipendenze da Flutter
// test/features/products/domain/get_products_usecase_test.dart
class MockProductsRepository extends Mock implements ProductsRepository {}

void main() {
  late GetProductsUseCase useCase;
  late MockProductsRepository mockRepo;

  setUp(() {
    mockRepo = MockProductsRepository();
    useCase = GetProductsUseCase(mockRepo);
  });

  test('chiama repository con i parametri corretti', () async {
    // Arrange
    const params = GetProductsParams(category: 'electronics', page: 2);
    when(() => mockRepo.getProducts(
      category: 'electronics',
      page: 2,
      limit: 20,
    )).thenAnswer((_) async => []);

    // Act
    await useCase(params);

    // Assert
    verify(() => mockRepo.getProducts(
      category: 'electronics',
      page: 2,
      limit: 20,
    )).called(1);
  });
}

Strat de date: implementare DTO și depozit

# data/models/product_dto.dart

// DTO (Data Transfer Object): sa come mappare JSON <-> entita domain
// Dipende dal domain (Product entity) ma non viceversa
class ProductDto {
  const ProductDto({
    required this.id,
    required this.name,
    required this.price,
    required this.imageUrl,
    required this.category,
    this.description,
    this.rating,
    this.inStock,
  });

  final String id;
  final String name;
  final double price;
  final String imageUrl;
  final String category;
  final String? description;
  final double? rating;
  final bool? inStock;

  // Factory: converte Map JSON in DTO
  factory ProductDto.fromJson(Map<String, dynamic> json) {
    return ProductDto(
      id: json['id'] as String,
      name: json['name'] as String,
      price: (json['price'] as num).toDouble(),
      imageUrl: json['image_url'] as String,
      category: json['category'] as String,
      description: json['description'] as String?,
      rating: (json['rating'] as num?)?.toDouble(),
      inStock: json['in_stock'] as bool?,
    );
  }

  // toEntity: converte DTO in entita domain
  Product toEntity() {
    return Product(
      id: id,
      name: name,
      price: price,
      imageUrl: imageUrl,
      category: category,
      description: description ?? '',
      rating: rating ?? 0.0,
      inStock: inStock ?? true,
    );
  }
}

# data/repositories/products_repository_impl.dart

class ProductsRepositoryImpl implements ProductsRepository {
  const ProductsRepositoryImpl({
    required this.remoteSource,
    required this.localSource,
  });

  final ProductsRemoteSource remoteSource;
  final ProductsLocalSource localSource;

  @override
  Future<List<Product>> getProducts({
    String? category,
    int page = 1,
    int limit = 20,
  }) async {
    try {
      // Prima prova la cache locale
      final cached = await localSource.getProducts(
        category: category,
        page: page,
        limit: limit,
      );
      if (cached.isNotEmpty) {
        return cached.map((dto) => dto.toEntity()).toList();
      }

      // Se la cache e vuota, chiama l'API remota
      final dtos = await remoteSource.getProducts(
        category: category,
        page: page,
        limit: limit,
      );

      // Salva in cache per la prossima volta
      await localSource.saveProducts(dtos);

      return dtos.map((dto) => dto.toEntity()).toList();
    } catch (e) {
      throw ProductsException('Impossibile caricare i prodotti: $e');
    }
  }

  @override
  Future<Product> getProductById(String id) async {
    final dto = await remoteSource.getProductById(id);
    return dto.toEntity();
  }

  @override
  Future<List<Product>> searchProducts(String query) async {
    final dtos = await remoteSource.searchProducts(query);
    return dtos.map((dto) => dto.toEntity()).toList();
  }

  @override
  Future<void> refreshCache() => localSource.clearAll();
}

Injecție de dependență cu Riverpod

Riverpod este lipiciul care conectează cele trei straturi fără cuplare directă: fiecare furnizor își declară dependențele prin ref.watch e Riverpod rezolvă întregul grafic de dependență într-o manieră leneșă și sigură.

# presentation/providers/products_provider.dart

import 'package:riverpod_annotation/riverpod_annotation.dart';

part 'products_provider.g.dart';

// DATA LAYER providers
@riverpod
ProductsRemoteSource productsRemoteSource(Ref ref) {
  return ProductsRemoteSource(dio: ref.watch(dioProvider));
}

@riverpod
ProductsLocalSource productsLocalSource(Ref ref) {
  return ProductsLocalSource(db: ref.watch(databaseProvider));
}

// DOMAIN LAYER providers
@riverpod
ProductsRepository productsRepository(Ref ref) {
  return ProductsRepositoryImpl(
    remoteSource: ref.watch(productsRemoteSourceProvider),
    localSource: ref.watch(productsLocalSourceProvider),
  );
}

@riverpod
GetProductsUseCase getProductsUseCase(Ref ref) {
  return GetProductsUseCase(ref.watch(productsRepositoryProvider));
}

// PRESENTATION LAYER: AsyncNotifier che usa il use case
@riverpod
class ProductsList extends _$ProductsList {
  @override
  Future<List<Product>> build({String? category}) async {
    return ref.watch(getProductsUseCaseProvider).call(
      GetProductsParams(category: category),
    );
  }

  Future<void> refresh() async {
    await ref.read(productsRepositoryProvider).refreshCache();
    ref.invalidateSelf();
  }
}

// Nel widget: nessun accoppiamento con i layer sottostanti
class ProductsListPage extends ConsumerWidget {
  const ProductsListPage({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final productsAsync = ref.watch(productsListProvider());

    return Scaffold(
      appBar: AppBar(title: const Text('Prodotti')),
      body: productsAsync.when(
        loading: () => const Center(child: CircularProgressIndicator()),
        error: (e, _) => Center(child: Text('Errore: $e')),
        data: (products) => ListView.builder(
          itemCount: products.length,
          itemBuilder: (context, i) => ProductCard(product: products[i]),
        ),
      ),
    );
  }
}

Testare pe strat

Arhitectura curată permite o strategie optimă de testare: fiecare strat are propriul tip de test cu setarea minimă necesară.

# Struttura test allineata alla struttura feature

test/
  features/
    products/
      domain/
        get_products_usecase_test.dart  # Unit test puri (no Flutter)
        product_entity_test.dart
      data/
        product_dto_test.dart           # Unit test con JSON fixtures
        products_repository_impl_test.dart # Mock remote + local source
      presentation/
        products_list_page_test.dart    # Widget test con provider override

# Widget test con override del provider per mock
testWidgets('Mostra lista prodotti', (tester) async {
  await tester.pumpWidget(
    ProviderScope(
      overrides: [
        // Override del use case con dati mock
        getProductsUseCaseProvider.overrideWithValue(
          FakeGetProductsUseCase(products: [
            const Product(
              id: '1',
              name: 'iPhone 15',
              price: 999.0,
              imageUrl: 'https://example.com/iphone.jpg',
              category: 'electronics',
            ),
          ]),
        ),
      ],
      child: const MaterialApp(home: ProductsListPage()),
    ),
  );

  await tester.pumpAndSettle();

  // Verifica che il prodotto mock sia visibile
  expect(find.text('iPhone 15'), findsOneWidget);
  expect(find.text('999.00 EUR'), findsOneWidget);
});

class FakeGetProductsUseCase extends Fake implements GetProductsUseCase {
  FakeGetProductsUseCase({required this.products});
  final List<Product> products;

  @override
  Future<List<Product>> call(GetProductsParams params) async => products;
}

Când să extrageți o caracteristică dintr-un pachet

Când o funcție este reutilizată în mai multe aplicații (de ex. auth împărțit între aplicația de consum și administrare) și este timpul să creați un pachet Dart separat: dart create --template=package packages/auth_feature. Curatul Arhitectura face această extracție aproape mecanică: copiați directorul fișierului caracteristică în noul pachet și actualizați importurile. Zero refactorizare arhitecturală.

Concluzii

Feature-First Architecture cu Clean Architecture nu este cea mai simplă soluție pentru o aplicație mică — și soluția potrivită pentru o aplicație care trebuie să crească și să evolueze și supraviețuiesc schimbării echipelor. Costul inițial de configurare (structura directorului, interfețe, DTO, cazuri de utilizare) este rapid amortizată: urmează fiecare caracteristică nouă același model, fiecare dezvoltator știe exact unde să găsească și unde să pună codul, iar fiecare strat poate fi testat și înlocuit independent.

În 2026, cele mai robuste aplicații Flutter pentru întreprinderi – de la Nubank la eBay la ByteDance – toate converg spre variante ale acestei structuri. Nu este o tendință: este răspunsul exersează problemele reale care apar atunci când Flutter crește dincolo de echipa de 3 persoane.