La Stele di Rosetta

Parlare di “coding” (programmazione) nel 2022 ha un sapore tutto nuovo, non solo grazie ai numerosi linguaggi di alto livello che hanno fatto proseliti anche molto lontano dagli ambienti informatici, ma anche e soprattutto grazie al fatto che oggi le macchine sono in grado di programmarsi in autonomia. Gli esseri umani sono diventati dei supervisori e questo ha consentito a figure professionali molto distanti di utilizzare il codice in modo impensabile fino a qualche decennio fa. Questo breve articolo, ad esempio, è stato scritto a due mani da me (il supervisore di turno) e l’IA (Intelligenza Artificiale) di OpenAI denominata ChatGPT (versione 15 Dec 2022).

Quello che intendiamo fare è una comparazione a livello sintattico tra alcuni linguaggi più datati e i due linguaggi attualmente più utilizzati nell’ambito del machine learning. Come criterio di confronto prendiamo la definizione di “Profit Factor”, una metrica di performance che è calcolata in analisi quantitativa mediante il rapporto tra il Gross Profit ed il Gross Loss. Vediamo che codificare tale calcolo, a partire da una sequenza di trade in C.

#include <stdio.h>
#include <stdlib.h>
#include <float.h>
#define MAX_TRADES 10
typedef struct {
  double result;
} Trade;
double calculate_profit_factor(Trade* trades, size_t num_trades) {
  double net_profit = 0.0;
  double net_loss = 0.0;
  for (size_t i = 0; i < num_trades; i++) {
    double result = trades[i].result;
    if (result > 0.0) {
      net_profit += result;
    } else {
      net_loss += result;
    }
  }
  if (net_loss == 0.0) {
    return DBL_MAX;
  }
  return net_profit / net_loss;
}
int main(void) {
  Trade trades[MAX_TRADES] = {
    {100.0},  // Winning trade
    {-50.0},  // Losing trade
    {200.0},  // Winning trade
    {-100.0}  // Losing trade
  };
  size_t num_trades = 4;
  double profit_factor = calculate_profit_factor(trades, num_trades);
  printf("Profit factor: %f\n", profit_factor);  // Output: 3.0
  return 0;
}

Si notino le importazioni delle librerie (.h), le dichiarazioni delle variabili,i segni di interpunzione, le parentesi graffe per orientarsi all’interno dei cicli e delle funzioni, il main program. Un approccio sicuramente efficiente ma non proprio alla portata di tutti.

Vediamo cosa otteniamo traducendo tale codice in Java.

import java.util.List;
public class TradeAnalyzer {
  public static double calculateProfitFactor(List<Trade> trades) {
    double netProfit = 0.0;
    double netLoss = 0.0;
    for (Trade trade : trades) {
      double result = trade.getResult();
      if (result > 0.0) {
        netProfit += result;
      } else {
        netLoss += result;
      }
    }
    if (netLoss == 0.0) {
      return Double.POSITIVE_INFINITY;
    }
    return netProfit / netLoss;
  }
  public static void main(String[] args) {
    List<Trade> trades = List.of(
      new Trade(100.0),  // Winning trade
      new Trade(-50.0),  // Losing trade
      new Trade(200.0),  // Winning trade
      new Trade(-100.0)  // Losing trade
    );
    double profitFactor = calculateProfitFactor(trades);
    System.out.println("Profit factor: " + profitFactor);  // Output: 3.0
  }
}
class Trade {
  private final double result;
  public Trade(double result) {
    this.result = result;
  }
  public double getResult() {
    return result;
  }
}

Utilizzando la Java Virtual Machine possiamo eseguire lo stesso codice su macchine MacOS, Windows o Linux, ma rimane una certa complessità e una struttura del codice che ricorda quella di C.

Per far comprendere al grande pubblico perchè linguaggi interpretati e di alto livello stiano andando per la maggiore, proviamo a tradurre il tutto in Python.

L’indentazione obbligatoria (ed automatica) rende più leggibile il codice, che risulta anche più sintetico. Mancano i segni di interpunzione e le parentesi, nonché la dichiarazione delle variabili (che è implicita e dinamica). Il tutto viene svolto dalla funzione “calculate_profit_factor” che prende in argomento una lista di trade e restituisce il rapporto tra net_profit e net_loss, verificando che non si verifichi una divisione per zero e in caso esponendo infinito come risultato. Si noti inoltre come in questa versione davvero basica, non si utilizzino librerie come Pandas, che renderebbe il codice ancora più sintetico.

Vediamo cosa cambia passando da un linguaggio interpretato come Python ad uno compilato JIT (Just in Time) come Julia.

function calculate_profit_factor(trades)
  net_profit = 0
  net_loss = 0
  for trade in trades
    result = trade["result"]
    if result > 0
      net_profit += result
    else
      net_loss += result
    end
  end
  if net_loss == 0
    return Inf
  end
  return net_profit / net_loss
end
trades = [
  {"result" => 100},  # Winning trade
  {"result" => -50},  # Losing trade
  {"result" => 200},  # Winning trade
  {"result" => -100}  # Losing trade
]
profit_factor = calculate_profit_factor(trades)
println(profit_factor)  # Output: 3.0

Il codice è sostanzialmente sovrapponibile e non riporta un aumento di complessità. A testimonianza che, a partire da Python ed altri linguaggi emersi negli ultimi 20 anni, si stiano evolvendo ulteriori declinazioni di compilatori in grado di garantire o di rasentare la velocità del C, ma con una sintassi decisamente più intellegibile ed intuitiva. E’ stata, per così dire, decifrata la stele di Rosetta dei linguaggi moderni. Ed oggi essere in grado di scrivere codice costituisce davvero una nuova alfabetizzazione.

Se desiderate apprendere Python da zero, attraverso una lezione gratuita di due ore che abbiamo creato per semplificare il vostro avvicinamento al mondo dell’open source, potete cliccare qui.

Giovanni Trombetta

Founder – Head of R&D
Gandalf Project