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.

Inheritance vs Composition: Two Approaches to Code Reuse

Inheritance and composition are two fundamental mechanisms for code reuse in object-oriented programming. Both allow building complex software from simpler components, but with very different approaches and implications.

🎯 What You'll Learn

When to use inheritance and when composition
Differences between abstract classes and interfaces
The "Composition over Inheritance" principle
How to avoid common inheritance problems

Inheritance: The "IS-A" Relationship

Inheritance expresses an "is-a" relationship. A dog is an animal, a circle is a shape. The child class inherits all members of the parent class and can extend or override them.

TypeScript - Basic Inheritance

class Vehicle {{ '{' }}
  protected speed: number = 0;

  constructor(protected brand: string) {{ '{' }}{{ '}' }}

  accelerate(amount: number): void {{ '{' }}
    this.speed += amount;
    console.log(`#123;{ '{' }}this.brand{{ '}' }} accelerates to #123;{ '{' }}this.speed{{ '}' }} km/h`);
  {{ '}' }}

  getInfo(): string {{ '{' }}
    return `#123;{ '{' }}this.brand{{ '}' }} - Speed: #123;{ '{' }}this.speed{{ '}' }} km/h`;
  {{ '}' }}
{{ '}' }}

class Car extends Vehicle {{ '{' }}
  private doors: number;

  constructor(brand: string, doors: number) {{ '{' }}
    super(brand); // Calls parent constructor
    this.doors = doors;
  {{ '}' }}

  // Extends parent functionality
  getInfo(): string {{ '{' }}
    return `#123;{ '{' }}super.getInfo(){{ '}' }} - Doors: #123;{ '{' }}this.doors{{ '}' }}`;
  {{ '}' }}

  openTrunk(): void {{ '{' }}
    console.log("Trunk opened");
  {{ '}' }}
{{ '}' }}

const myCar = new Car("Tesla", 4);
myCar.accelerate(50);
console.log(myCar.getInfo());
// Output: Tesla - Speed: 50 km/h - Doors: 4

Abstract Classes vs Interfaces

TypeScript offers both abstract classes and interfaces to define contracts and reusable structures.

Abstract Classes:

Can have implementations
Support modifiers (private, protected)
Single inheritance (extends only one)
Use them to share common code

Interfaces:

Only signatures, no implementation
All members are public
Multiple implementation (implements multiple interfaces)
Use them to define contracts

TypeScript - Abstract Classes

abstract class Shape {{ '{' }}
  protected color: string;

  constructor(color: string) {{ '{' }}
    this.color = color;
  {{ '}' }}

  // Concrete method (with implementation)
  getColor(): string {{ '{' }}
    return this.color;
  {{ '}' }}

  // Abstract methods (to be implemented in subclasses)
  abstract area(): number;
  abstract perimeter(): number;
{{ '}' }}

class Circle extends Shape {{ '{' }}
  constructor(private radius: number, color: string) {{ '{' }}
    super(color);
  {{ '}' }}

  area(): number {{ '{' }}
    return Math.PI * this.radius ** 2;
  {{ '}' }}

  perimeter(): number {{ '{' }}
    return 2 * Math.PI * this.radius;
  {{ '}' }}
{{ '}' }}

const circle = new Circle(5, "red");
console.log(circle.area()); // 78.54
console.log(circle.getColor()); // "red"

TypeScript - Multiple Interfaces

interface Flyable {{ '{' }}
  fly(): void;
  altitude: number;
{{ '}' }}

interface Swimmable {{ '{' }}
  swim(): void;
  depth: number;
{{ '}' }}

// A class can implement multiple interfaces
class Duck implements Flyable, Swimmable {{ '{' }}
  altitude: number = 0;
  depth: number = 0;

  fly(): void {{ '{' }}
    this.altitude = 100;
    console.log(`Flying at #123;{ '{' }}this.altitude{{ '}' }}m altitude`);
  {{ '}' }}

  swim(): void {{ '{' }}
    this.depth = 2;
    console.log(`Swimming at #123;{ '{' }}this.depth{{ '}' }}m depth`);
  {{ '}' }}
{{ '}' }}

const duck = new Duck();
duck.fly();   // "Flying at 100m altitude"
duck.swim();  // "Swimming at 2m depth"

Composition: The "HAS-A" Relationship

Composition expresses a "has-a" relationship. A car has an engine, a computer has a CPU. Instead of inheriting, you include instances of other classes as members.

TypeScript - Composition

class Engine {{ '{' }}
  constructor(private horsepower: number) {{ '{' }}{{ '}' }}

  start(): void {{ '{' }}
    console.log(`#123;{ '{' }}this.horsepower{{ '}' }}HP engine started`);
  {{ '}' }}

  getHorsepower(): number {{ '{' }}
    return this.horsepower;
  {{ '}' }}
{{ '}' }}

class Transmission {{ '{' }}
  constructor(private type: string) {{ '{' }}{{ '}' }}

  shift(gear: number): void {{ '{' }}
    console.log(`#123;{ '{' }}this.type{{ '}' }} transmission: gear #123;{ '{' }}gear{{ '}' }}`);
  {{ '}' }}
{{ '}' }}

// Car "has an" Engine and "has a" Transmission
class CarComposed {{ '{' }}
  private engine: Engine;
  private transmission: Transmission;

  constructor(horsepower: number, transmissionType: string) {{ '{' }}
    this.engine = new Engine(horsepower);
    this.transmission = new Transmission(transmissionType);
  {{ '}' }}

  start(): void {{ '{' }}
    this.engine.start();
  {{ '}' }}

  drive(): void {{ '{' }}
    this.transmission.shift(1);
    console.log("Car is moving");
  {{ '}' }}

  getSpecs(): string {{ '{' }}
    return `#123;{ '{' }}this.engine.getHorsepower(){{ '}' }}HP`;
  {{ '}' }}
{{ '}' }}

const car = new CarComposed(200, "automatic");
car.start();  // "200HP engine started"
car.drive();  // "automatic transmission: gear 1"
              // "Car is moving"

Composition Over Inheritance

The "Composition over Inheritance" principle suggests preferring composition over inheritance when possible. Why?

      ✅ Advantages of Composition:
      Flexibility: Change behaviors at runtime
Reusability: Combine components in different ways
Testing: Test components independently
Loose coupling: Safer modifications


      ⚠️ Problems with Inheritance:
      Rigid hierarchy difficult to modify
Strong coupling between parent and child
Fragile Base Class Problem
Diamond Problem (multiple inheritance)

    

When to Use Inheritance

Inheritance is appropriate when:

There's a clear "is-a" relationship (Dog is an Animal)
The subclass is a true specialization of the superclass
You need polymorphism (treat different objects with common interface)
The hierarchy is stable and won't change frequently

Good Use of Inheritance

// Clear and stable hierarchy
abstract class Employee {{ '{' }}
  constructor(
    protected name: string,
    protected salary: number
  ) {{ '{' }}{{ '}' }}

  abstract calculateBonus(): number;

  getDetails(): string {{ '{' }}
    return `#123;{ '{' }}this.name{{ '}' }} - Salary: €#123;{ '{' }}this.salary{{ '}' }}`;
  {{ '}' }}
{{ '}' }}

class Manager extends Employee {{ '{' }}
  calculateBonus(): number {{ '{' }}
    return this.salary * 0.2; // 20% bonus
  {{ '}' }}
{{ '}' }}

class Developer extends Employee {{ '{' }}
  constructor(name: string, salary: number, private language: string) {{ '{' }}
    super(name, salary);
  {{ '}' }}

  calculateBonus(): number {{ '{' }}
    return this.salary * 0.15; // 15% bonus
  {{ '}' }}
{{ '}' }}

When to Use Composition

Composition is preferable when:

The relationship is "has-a" (Car has an Engine)
You need flexible reuse of functionality
Behaviors need to be interchangeable
The structure can evolve over time

Composition for Flexibility

// Strategy pattern with composition
interface PaymentStrategy {{ '{' }}
  pay(amount: number): void;
{{ '}' }}

class CreditCardPayment implements PaymentStrategy {{ '{' }}
  pay(amount: number): void {{ '{' }}
    console.log(`Payment of €#123;{ '{' }}amount{{ '}' }} with credit card`);
  {{ '}' }}
{{ '}' }}

class PayPalPayment implements PaymentStrategy {{ '{' }}
  pay(amount: number): void {{ '{' }}
    console.log(`Payment of €#123;{ '{' }}amount{{ '}' }} with PayPal`);
  {{ '}' }}
{{ '}' }}

class ShoppingCartComposed {{ '{' }}
  private items: number[] = [];
  private paymentStrategy!: PaymentStrategy;

  addItem(price: number): void {{ '{' }}
    this.items.push(price);
  {{ '}' }}

  // Change strategy at runtime!
  setPaymentStrategy(strategy: PaymentStrategy): void {{ '{' }}
    this.paymentStrategy = strategy;
  {{ '}' }}

  checkout(): void {{ '{' }}
    const total = this.items.reduce((sum, price) => sum + price, 0);
    this.paymentStrategy.pay(total);
  {{ '}' }}
{{ '}' }}

const cart = new ShoppingCartComposed();
cart.addItem(50);
cart.addItem(30);

cart.setPaymentStrategy(new CreditCardPayment());
cart.checkout(); // "Payment of €80 with credit card"

cart.setPaymentStrategy(new PayPalPayment());
cart.checkout(); // "Payment of €80 with PayPal"

Conclusion

Inheritance and composition are not enemies but complementary tools. Inheritance is powerful for modeling stable hierarchies with polymorphism, while composition offers flexibility and modular reuse. The practical rule: start with composition, use inheritance only when the "is-a" relationship is clear and the benefits outweigh the costs.

🎯 Key Points

Inheritance = "is-a", Composition = "has-a"
Abstract classes for shared code, interfaces for contracts
Composition over Inheritance for greater flexibility
Use inheritance for stable hierarchies with clear polymorphism