LinuxParty

NUESTRO SITIO necesita la publicidad para costear hosting y el dominio. Por favor considera deshabilitar tu AdBlock en nuestro sitio. También puedes hacernos una donación entrando en linuxparty.es, en la columna de la derecha.
Inicio desactivadoInicio desactivadoInicio desactivadoInicio desactivadoInicio desactivado
 

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

Mojo es un lenguaje de descripción de hardware de alto nivel (HDL, por sus siglas en inglés) utilizado para diseñar y desarrollar hardware digital. Se basa en el lenguaje de programación Perl y está diseñado para simplificar y agilizar el proceso de diseño de circuitos digitales.

Mojo se utiliza comúnmente junto con la plataforma Mojo V3, que es una placa de desarrollo FPGA (Field-Programmable Gate Array) de bajo costo y fácil de usar. La placa Mojo V3 proporciona una interfaz para cargar y ejecutar el código Mojo en un FPGA, lo que permite a los desarrolladores crear prototipos de circuitos digitales de manera rápida y sencilla.

El lenguaje Mojo permite describir la funcionalidad del hardware en un nivel de abstracción más alto que los lenguajes HDL tradicionales como VHDL o Verilog. Esto facilita el diseño y la depuración del hardware, ya que se puede utilizar una sintaxis más concisa y expresiva.

En resumen, Mojo es un lenguaje de descripción de hardware de alto nivel utilizado en combinación con la placa de desarrollo Mojo V3 para la creación rápida de prototipos de circuitos digitales en FPGA.

 

 

Pin It

No estás registrado para postear comentarios



Redes:



   

 

Suscribete / Newsletter

Suscribete a nuestras Newsletter y periódicamente recibirás un resumen de las noticias publicadas.

Donar a LinuxParty

Probablemente te niegues, pero.. ¿Podrías ayudarnos con una donación?


Tutorial de Linux

Filtro por Categorías