LinuxParty

Este lenguaje de programación, llamado Mojo, fue presentado hace unas semanas por la empresa de inteligencia artificial Modular. Ha ganado mucha atención porque combina dos características muy notables: la simplicidad de Python y la velocidad de C.

Abundan las iniciativas de aceleración de Python, incluido Jax y, más recientemente, el compilador Codon Python. Sin mencionar otros lenguajes diseñados específicamente para la ciencia de datos, como Julia.

Python es superado por 35.000 veces.

Al ser "35.000 veces más rápido que Python" al ejecutar algoritmos numéricos como Mandelbrot gracias a la aceleración de hardware, Mojo puede destacarse de otros esfuerzos de mejora de Python, en palabras de sus desarrolladores.

Los desarrolladores del programa afirman que Mojo "combina las partes de Python que tanto les gustan a los investigadores con las capacidades de programación del sistema que requieren el uso de C, C y CUDA". ".

Según sus diseñadores, Mojo permite el uso de CPU, GPU, TPU y ASIC especializados de acuerdo con las ventajas de cada tipo de hardware. Mojo es más simple de aprender y usar para los desarrolladores experimentados de Python porque su sintaxis y semántica de alto nivel son similares a las de Python. ".

Para ser más ágil, Mojo compila estáticamente, lo que conduce a tiempos de ejecución más rápidos y una mejor optimización porque el código se compila antes de la ejecución.

Este curso te enseñará a programar en Python de forma gratuita. Es muy visual y te da acceso a todo el código.

Jeremy Howard, científico de datos y cofundador de Fast. ai, incluso llegó a afirmar que "Mojo puede ser el mayor avance en lenguaje de programación en décadas". ".

Afirma que este lenguaje tiene como objetivo abordar la "realidad bifurcada de la IA": los programadores de Python con frecuencia se encuentran conectando su código en módulos escritos en lenguajes de mayor rendimiento, como C, a pesar de que los modelos de IA se desarrollan con frecuencia en Python debido a la riqueza del ecosistema. . C y óxido. Además, este enfoque de "dos idiomas" dificulta la creación de perfiles, la depuración, el aprendizaje y la implementación de aplicaciones de aprendizaje automático.

Que persigue a Mojo.

Uno de sus precursores fue Chris Lattner. Anteriormente ocupó cargos en organizaciones como Apple, Google y Tesla y cofundó el marco del compilador MLIR, la cadena de herramientas del compilador LLVM y el lenguaje de programación Swift.

Tim Davis, cofundador de Modular y exjefe de Google ML, que supervisó las API de aprendizaje automático, los compiladores y la infraestructura de tiempo de ejecución del gigante de Internet, es otro de sus antepasados.

Imágenes de la web de Modular.

Algunos lenguajes con sintaxis similar. Ordenación QuickSort.

En este ejemplo, la subrutina QuickSort es la función principal que inicia el proceso de ordenación llamando a la función Partition recursivamente. La función Partition selecciona un pivote (en este caso, el último elemento del array) y reorganiza los elementos de manera que los elementos menores que el pivote se coloquen antes de él, y los elementos mayores se coloquen después. La subrutina Swap se utiliza para intercambiar los valores de dos elementos del array.

' Ejemplo en Basic

SUB QuickSort(arr(), left, right)
    IF left < right THEN
        pivotIndex = Partition(arr(), left, right)
        QuickSort(arr(), left, pivotIndex - 1)
        QuickSort(arr(), pivotIndex + 1, right)
    END IF
END SUB
' -------------------------

FUNCTION Partition(arr(), left, right)
    pivot = arr(right)
    i = left - 1
    FOR j = left TO right - 1
        IF arr(j) <= pivot THEN
            i = i + 1
            Swap(arr(i), arr(j))
        END IF
    NEXT j
    Swap(arr(i + 1), arr(right))
    RETURN i + 1
END FUNCTION
' ----------------------

SUB Swap(a, b)
    temp = a
    a = b
    b = temp
END SUB
' ---------------------

' Ejemplo de uso:
DIM numbers(10)
numbers(0) = 9
numbers(1) = 5
numbers(2) = 2
numbers(3) = 7
numbers(4) = 1
numbers(5) = 8
numbers(6) = 4
numbers(7) = 3
numbers(8) = 6
numbers(9) = 10

PRINT "Array original:"
FOR i = 0 TO 9
    PRINT numbers(i);
NEXT i

CALL QuickSort(numbers(), 0, 9)

PRINT "Array ordenado:"
FOR i = 0 TO 9
    PRINT numbers(i);
NEXT i

// Ejemplo en Pascal.

program QuickSort;

type
  TArray = array of Integer;

procedure Swap(var a, b: Integer);
var
  temp: Integer;
begin
  temp := a;
  a := b;
  b := temp;
end;
// --------------

function Partition(var arr: TArray; low, high: Integer): Integer;
var
  pivot, i, j: Integer;
begin
  pivot := arr[high];
  i := low - 1;
  
  for j := low to high - 1 do
  begin
    if arr[j] < pivot then
    begin
      i := i + 1;
      Swap(arr[i], arr[j]);
    end;
  end;
  
  Swap(arr[i + 1], arr[high]);
  Result := i + 1;
end;
// -------------------

procedure QuickSort(var arr: TArray; low, high: Integer);
var
  pivotIndex: Integer;
begin
  if low < high then
  begin
    pivotIndex := Partition(arr, low, high);
    QuickSort(arr, low, pivotIndex - 1);
    QuickSort(arr, pivotIndex + 1, high);
  end;
end;
// ------------------

var
  numbers: TArray;
  i: Integer;
begin
  SetLength(numbers, 10);
  numbers[0] := 9;
  numbers[1] := 5;
  numbers[2] := 2;
  numbers[3] := 7;
  numbers[4] := 1;
  numbers[5] := 8;
  numbers[6] := 4;
  numbers[7] := 3;
  numbers[8] := 6;
  numbers[9] := 10;

  Writeln('Array original:');
  for i := 0 to Length(numbers) - 1 do
    Write(numbers[i], ' ');

  QuickSort(numbers, 0, Length(numbers) - 1);

  Writeln;
  Writeln('Array ordenado:');
  for i := 0 to Length(numbers) - 1 do
    Write(numbers[i], ' ');

  Readln;
end.

# Ejemplo en Python

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    else:
        pivot = arr[-1]
        smaller = []
        greater = []
        equal = []
        for num in arr:
            if num < pivot:
                smaller.append(num)
            elif num > pivot:
                greater.append(num)
            else:
                equal.append(num)
        return quick_sort(smaller) + equal + quick_sort(greater)

# Ejemplo de uso:
numbers = [9, 5, 2, 7, 1, 8, 4, 3, 6, 10]

print("Array original:")
print(numbers)

sorted_numbers = quick_sort(numbers)

print("Array ordenado:")
print(sorted_numbers)

// Ejemplo en C

#include <stdio.h>

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}
// ----------------

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = (low - 1);
    
    for (int j = low; j <= high - 1; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}
// -----------------

void quick_sort(int arr[], int low, int high) {
    if (low < high) {
        int pivot_index = partition(arr, low, high);
        
        quick_sort(arr, low, pivot_index - 1);
        quick_sort(arr, pivot_index + 1, high);
    }
}
// ----------------------

// Ejemplo de uso:
int main() {
    int numbers[] = {9, 5, 2, 7, 1, 8, 4, 3, 6, 10};
    int size = sizeof(numbers) / sizeof(numbers[0]);

    printf("Array original:\n");
    for (int i = 0; i < size; i++) {
        printf("%d ", numbers[i]);
    }

    quick_sort(numbers, 0, size - 1);

    printf("\nArray ordenado:\n");
    for (int i = 0; i < size; i++) {
        printf("%d ", numbers[i]);
    }

    return 0;
}

// Ejemplo en PHP

function quickSort(&$arr, $low, $high) {
    if ($low < $high) {
        $pivotIndex = partition($arr, $low, $high);
        
        quickSort($arr, $low, $pivotIndex - 1);
        quickSort($arr, $pivotIndex + 1, $high);
    }
}
// ---------------------------

function partition(&$arr, $low, $high) {
    $pivot = $arr[$high];
    $i = $low - 1;
    
    for ($j = $low; $j <= $high - 1; $j++) {
        if ($arr[$j] < $pivot) {
            $i++;
            swap($arr, $i, $j);
        }
    }
    // Llamada a la función Swap
    swap($arr, $i + 1, $high);
    return $i + 1;
}
//--------------------

function swap(&$arr, $i, $j) {
    $temp = $arr[$i];
    $arr[$i] = $arr[$j];
    $arr[$j] = $temp;
}
// --------------------

// Ejemplo de uso:
$numbers = [9, 5, 2, 7, 1, 8, 4, 3, 6, 10];

echo "Array original: ";
foreach ($numbers as $number) {
    echo $number . " ";
}

quickSort($numbers, 0, count($numbers) - 1);

echo "\nArray ordenado: ";
foreach ($numbers as $number) {
    echo $number . " ";
}

Tenemos que decir que Mojo, está estrechamente ligado a un hardware específico, por lo que no es lo más apropiado para un desarrollo genérico...