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

Che tu gestisca un negozio, uno studio professionale o un'azienda, posso aiutarti a sfruttare le potenzialità dell'informatica per lavorare meglio, più velocemente e in modo più intelligente.

Parliamone Insieme →

Join the Community

Join the developer community where we discuss software, AI, architecture and DevOps. Share ideas, ask questions and grow with us.

Channel

FC Dev Blog

Get notifications on new articles, complete series, weekly tips and featured tools. Bilingual IT/EN content directly in your Telegram.

New articles as they are published
Weekly tips and code snippets
Polls on future topics

Subscribe to Channel

Group

FC Dev Community

A bilingual IT/EN community for developers. Discussions, Q&A, mutual help and networking with other professionals.

Discussions on articles and technologies
Coding help and code review
Job opportunities and collaboration

Join the Group

Discussion Topics

View

Master SQL

RoadMap.sh

November 2024

View

Oracle Certified Foundations Associate

Oracle

October 2024

View

People Leadership Credential

Connect

September 2024

💻 Languages & Technologies

Java

Python

JavaScript

Angular

React

TypeScript

SQL

PHP

CSS/SCSS

Node.js

Docker

Git

💼

12/2024 - Present

Custom Software Engineering Analyst

Accenture

Bari, Puglia, Italy · Hybrid Analysis and development of computer systems through the use of Java and Quarkus in Health and Public Sector. Continuous training on modern technologies for creating customized and efficient software solutions and on agents.

💼

06/2022 - 12/2024

Software analyst and Back End Developer Associate Consultant

Links Management and Technology SpA

Experience analyzing as-is software systems and ETL flows using PowerCenter. Completed Spring Boot training for developing modern and scalable backend applications. Backend developer specialized in Spring Boot, with experience in database design, analysis, development and testing of assigned tasks.

💼

02/2021 - 10/2021

Software programmer

Adesso.it (prima era WebScience srl)

Experience in AS-IS and TO-BE analysis, SEO evolutions and website evolutions to improve user performance and engagement.

🎓

2018 - 2025

Degree in Computer Science

University of Bari Aldo Moro

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

📚

2013 - 2018

Diploma - Corporate Information Systems

Technical Commercial Institute of 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.

Singleton and Factory Pattern: Controlled Object Creation

Creational design patterns manage object creation in a flexible and reusable way. Singleton ensures a single instance of a class, while Factory delegates object creation to specialized methods. Both are fundamental for solid software architecture.

🎯 What You'll Learn

Singleton pattern: unique global instance
Factory Method: delegate creation to subclasses
Abstract Factory: families of related objects
When to use each pattern

Singleton Pattern

The Singleton ensures a class has only one instance and provides a global access point to it. Useful for shared resources like database connections, loggers, caches.

TypeScript - Basic Singleton

class DatabaseConnection {{ '{' }}
  private static instance: DatabaseConnection;
  private connected: boolean = false;

  // Private constructor: prevents `new DatabaseConnection()`
  private constructor() {{ '{' }}
    console.log("DatabaseConnection created");
  {{ '}' }}

  // Static method to get the unique instance
  public static getInstance(): DatabaseConnection {{ '{' }}
    if (!DatabaseConnection.instance) {{ '{' }}
      DatabaseConnection.instance = new DatabaseConnection();
    {{ '}' }}
    return DatabaseConnection.instance;
  {{ '}' }}

  public connect(): void {{ '{' }}
    if (!this.connected) {{ '{' }}
      console.log("Connecting to database...");
      this.connected = true;
    {{ '}' }}
  {{ '}' }}

  public query(sql: string): void {{ '{' }}
    console.log(`Executing: #123;{ '{' }}sql{{ '}' }}`);
  {{ '}' }}
{{ '}' }}

// Usage
const db1 = DatabaseConnection.getInstance();
const db2 = DatabaseConnection.getInstance();

console.log(db1 === db2); // true - same instance!

db1.connect();
db2.query("SELECT * FROM users"); // Uses same connection

Singleton with Lazy Initialization

The instance is created only when needed, not at application startup:

Lazy Singleton

class Logger {{ '{' }}
  private static instance: Logger;
  private logs: string[] = [];

  private constructor() {{ '{' }}{{ '}' }}

  public static getInstance(): Logger {{ '{' }}
    // Created only on first call
    if (!Logger.instance) {{ '{' }}
      console.log("Logger instance created");
      Logger.instance = new Logger();
    {{ '}' }}
    return Logger.instance;
  {{ '}' }}

  public log(message: string): void {{ '{' }}
    const timestamp = new Date().toISOString();
    this.logs.push(`[#123;{ '{' }}timestamp{{ '}' }}] #123;{ '{' }}message{{ '}' }}`);
    console.log(this.logs[this.logs.length - 1]);
  {{ '}' }}

  public getLogs(): string[] {{ '{' }}
    return [...this.logs];
  {{ '}' }}
{{ '}' }}

// First call: creates instance
const logger = Logger.getInstance(); // "Logger instance created"
logger.log("Application started");

// Subsequent calls: reuse instance
const logger2 = Logger.getInstance(); // No creation log
logger2.log("User logged in");

console.log(logger.getLogs());
// ["[2024-12-26T...] Application started", "[2024-12-26T...] User logged in"]

Singleton: Pros and Cons

✅ Advantages:

Guarantees unique instance
Global access
Lazy initialization
Control over shared resources

❌ Disadvantages:

Global state (hard to test)
Violates Single Responsibility
Strong coupling
Problems with multi-threading

⚠️ Alternatives to Singleton

In many cases, Dependency Injection is preferable to Singleton. Frameworks like Angular use DI to provide single instances without Singleton pattern problems.

Factory Method Pattern

The Factory Method defines an interface for creating objects, but delegates to subclasses the decision on which concrete class to instantiate.

TypeScript - Factory Method

// Product interface
interface Vehicle {{ '{' }}
  drive(): void;
  getType(): string;
{{ '}' }}

// Concrete products
class Car implements Vehicle {{ '{' }}
  drive(): void {{ '{' }}
    console.log("Driving a car 🚗");
  {{ '}' }}
  getType(): string {{ '{' }}
    return "Car";
  {{ '}' }}
{{ '}' }}

class Motorcycle implements Vehicle {{ '{' }}
  drive(): void {{ '{' }}
    console.log("Riding a motorcycle 🏍️");
  {{ '}' }}
  getType(): string {{ '{' }}
    return "Motorcycle";
  {{ '}' }}
{{ '}' }}

class Truck implements Vehicle {{ '{' }}
  drive(): void {{ '{' }}
    console.log("Driving a truck 🚚");
  {{ '}' }}
  getType(): string {{ '{' }}
    return "Truck";
  {{ '}' }}
{{ '}' }}

// Abstract factory
abstract class VehicleFactory {{ '{' }}
  // Factory method (to be implemented in subclasses)
  abstract createVehicle(): Vehicle;

  // Method that uses the factory method
  public deliverVehicle(): void {{ '{' }}
    const vehicle = this.createVehicle();
    console.log(`Delivering a #123;{ '{' }}vehicle.getType(){{ '}' }}`);
    vehicle.drive();
  {{ '}' }}
{{ '}' }}

// Concrete factories
class CarFactory extends VehicleFactory {{ '{' }}
  createVehicle(): Vehicle {{ '{' }}
    return new Car();
  {{ '}' }}
{{ '}' }}

class MotorcycleFactory extends VehicleFactory {{ '{' }}
  createVehicle(): Vehicle {{ '{' }}
    return new Motorcycle();
  {{ '}' }}
{{ '}' }}

class TruckFactory extends VehicleFactory {{ '{' }}
  createVehicle(): Vehicle {{ '{' }}
    return new Truck();
  {{ '}' }}
{{ '}' }}

// Usage
function clientCode(factory: VehicleFactory) {{ '{' }}
  factory.deliverVehicle();
{{ '}' }}

clientCode(new CarFactory());
// "Delivering a Car"
// "Driving a car 🚗"

clientCode(new MotorcycleFactory());
// "Delivering a Motorcycle"
// "Riding a motorcycle 🏍️"

Simple Factory (Factory Pattern)

A simpler variant: a single factory method decides which class to instantiate:

Simple Factory

class VehicleSimpleFactory {{ '{' }}
  public static createVehicle(type: string): Vehicle {{ '{' }}
    switch (type) {{ '{' }}
      case 'car':
        return new Car();
      case 'motorcycle':
        return new Motorcycle();
      case 'truck':
        return new Truck();
      default:
        throw new Error(`Unknown vehicle type: #123;{ '{' }}type{{ '}' }}`);
    {{ '}' }}
  {{ '}' }}
{{ '}' }}

// Usage
const car = VehicleSimpleFactory.createVehicle('car');
car.drive(); // "Driving a car 🚗"

const truck = VehicleSimpleFactory.createVehicle('truck');
truck.drive(); // "Driving a truck 🚚"

Abstract Factory Pattern

Abstract Factory creates families of related objects without specifying concrete classes. Useful for UI themes, multi-vendor databases, etc.

Abstract Factory - UI Theme

// Product interfaces
interface Button {{ '{' }}
  render(): void;
{{ '}' }}

interface Checkbox {{ '{' }}
  render(): void;
{{ '}' }}

// Concrete products - Dark Theme
class DarkButton implements Button {{ '{' }}
  render(): void {{ '{' }}
    console.log("Rendering dark button");
  {{ '}' }}
{{ '}' }}

class DarkCheckbox implements Checkbox {{ '{' }}
  render(): void {{ '{' }}
    console.log("Rendering dark checkbox");
  {{ '}' }}
{{ '}' }}

// Concrete products - Light Theme
class LightButton implements Button {{ '{' }}
  render(): void {{ '{' }}
    console.log("Rendering light button");
  {{ '}' }}
{{ '}' }}

class LightCheckbox implements Checkbox {{ '{' }}
  render(): void {{ '{' }}
    console.log("Rendering light checkbox");
  {{ '}' }}
{{ '}' }}

// Abstract Factory
interface UIFactory {{ '{' }}
  createButton(): Button;
  createCheckbox(): Checkbox;
{{ '}' }}

// Concrete factories
class DarkThemeFactory implements UIFactory {{ '{' }}
  createButton(): Button {{ '{' }}
    return new DarkButton();
  {{ '}' }}
  createCheckbox(): Checkbox {{ '{' }}
    return new DarkCheckbox();
  {{ '}' }}
{{ '}' }}

class LightThemeFactory implements UIFactory {{ '{' }}
  createButton(): Button {{ '{' }}
    return new LightButton();
  {{ '}' }}
  createCheckbox(): Checkbox {{ '{' }}
    return new LightCheckbox();
  {{ '}' }}
{{ '}' }}

// Client code
class Application {{ '{' }}
  private button: Button;
  private checkbox: Checkbox;

  constructor(factory: UIFactory) {{ '{' }}
    this.button = factory.createButton();
    this.checkbox = factory.createCheckbox();
  {{ '}' }}

  render(): void {{ '{' }}
    this.button.render();
    this.checkbox.render();
  {{ '}' }}
{{ '}' }}

// Usage - Switch theme without modifying Application
const darkApp = new Application(new DarkThemeFactory());
darkApp.render();
// "Rendering dark button"
// "Rendering dark checkbox"

const lightApp = new Application(new LightThemeFactory());
lightApp.render();
// "Rendering light button"
// "Rendering light checkbox"

When to Use Each Pattern

      ✅ Use Singleton when:
      You need a single global instance (logger, cache, config)
Control over shared resource (DB connection)
Better: Use Dependency Injection instead if possible


      ✅ Use Factory Method when:
      The class doesn't know in advance which object to create
You want to delegate creation to subclasses
You need extensibility (new types without modifying existing code)


      ✅ Use Abstract Factory when:
      You need to create families of related objects
Objects must be used together (UI theme, cross-platform UI)
You want to hide implementation details

    

Practical Example: Notification System

Factory + Singleton Combined

// Singleton Logger
class NotificationLogger {{ '{' }}
  private static instance: NotificationLogger;
  private constructor() {{ '{' }}{{ '}' }}

  static getInstance(): NotificationLogger {{ '{' }}
    if (!this.instance) this.instance = new NotificationLogger();
    return this.instance;
  {{ '}' }}

  log(msg: string): void {{ '{' }}
    console.log(`[NOTIFICATION] #123;{ '{' }}msg{{ '}' }}`);
  {{ '}' }}
{{ '}' }}

// Factory for Notifications
interface Notification {{ '{' }}
  send(message: string): void;
{{ '}' }}

class EmailNotification implements Notification {{ '{' }}
  send(message: string): void {{ '{' }}
    NotificationLogger.getInstance().log(`Email sent: #123;{ '{' }}message{{ '}' }}`);
  {{ '}' }}
{{ '}' }}

class SMSNotification implements Notification {{ '{' }}
  send(message: string): void {{ '{' }}
    NotificationLogger.getInstance().log(`SMS sent: #123;{ '{' }}message{{ '}' }}`);
  {{ '}' }}
{{ '}' }}

class NotificationFactory {{ '{' }}
  static create(type: 'email' | 'sms'): Notification {{ '{' }}
    switch (type) {{ '{' }}
      case 'email':
        return new EmailNotification();
      case 'sms':
        return new SMSNotification();
    {{ '}' }}
  {{ '}' }}
{{ '}' }}

// Usage
const emailNotif = NotificationFactory.create('email');
emailNotif.send("Welcome!"); // [NOTIFICATION] Email sent: Welcome!

const smsNotif = NotificationFactory.create('sms');
smsNotif.send("Code: 1234"); // [NOTIFICATION] SMS sent: Code: 1234

Conclusion

Singleton and Factory are fundamental creational patterns. Singleton ensures a unique global instance, while Factory delegates creation for flexibility. Abstract Factory extends the concept to families of objects. Use them wisely: Dependency Injection is often preferable to Singleton, and Simple Factory may suffice instead of complex Factory Method.

🎯 Key Points

Singleton = single global instance (private constructor)
Factory Method = delegate creation to subclasses
Simple Factory = static method decides what to create
Abstract Factory = families of related objects
Prefer Dependency Injection to Singleton when possible