Me llego este mail de la gente de google y quería compartirlo:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
miércoles, 6 de marzo de 2024
Ponte al día con la IA generativa
martes, 5 de marzo de 2024
Igualdad en Gleam
import gleam/io
pub fn main() {
io.debug(100 == 100)
io.debug(1.5 != 0.1)
}
Gleam tiene los operadores == y != para verificar la igualdad.
Los operadores se pueden utilizar con valores de cualquier tipo, pero ambos lados del operador deben ser del mismo tipo.
La igualdad se verifica estructuralmente, lo que significa que dos valores son iguales si tienen la misma estructura y no si están en la misma ubicación de memoria.
lunes, 4 de marzo de 2024
Formatos de números en Gleam
import gleam/io
pub fn main() {
// Underscores
io.debug(1_000_000)
io.debug(10_000.01)
// Binary, octal, and hex Int literals
io.debug(0b00001111)
io.debug(0o17)
io.debug(0xF)
// Scientific notation Float literals
io.debug(7.0e7)
io.debug(3.0e-4)
}
Se pueden agregar guiones bajos a los números para mayor claridad. Por ejemplo, 1000000 puede ser complicado de leer rápidamente, mientras que 1_000_000 puede ser más fácil.
Los enteros se pueden escribir en formatos binario, octal o hexadecimal utilizando los prefijos 0b, 0o y 0x respectivamente.
Los flotantes se pueden escribir en notación científica.
El tipo Float de Gleam
import gleam/io
import gleam/float
pub fn main() {
// Float arithmetic
io.debug(1.0 +. 1.5)
io.debug(5.0 -. 1.5)
io.debug(5.0 /. 2.5)
io.debug(3.0 *. 3.5)
// Float comparisons
io.debug(2.2 >. 1.3)
io.debug(2.2 <. 1.3)
io.debug(2.2 >=. 1.3)
io.debug(2.2 <=. 1.3)
// Equality works for any type
io.debug(1.1 == 1.1)
io.debug(2.1 == 1.2)
// Division by zero is not an error
io.debug(3.14 /. 0.0)
// Standard library float functions
io.debug(float.max(2.0, 9.5))
io.debug(float.ceiling(5.4))
}
El tipo Float de Gleam representa números que no son enteros.
Los operadores numéricos de Gleam no están sobrecargados, por lo que existen operadores dedicados para trabajar con flotantes.
Los flotantes se representan como números de punto flotante de 64 bits tanto en Erlang como de JavaScript. El comportamiento del punto flotante es nativo de sus respectivos runtimes, por lo que su comportamiento exacto será ligeramente diferente en los dos runtimes.
En JavaScript, exceder el valor máximo (o mínimo) representable para un valor de punto flotante dará como resultado Infinity (o -Infinity). Si intentas dividir dos infinitos, obtendrás NaN como resultado.
Cuando se ejecuta en BEAM, cualquier desbordamiento generará un error. Por lo tanto, no hay ningún valor flotante NaN o Infinity en el tiempo de ejecución de Erlang.
La división por cero no se desbordará, sino que se define como cero.
El módulo de biblioteca estándar gleam/float contiene funciones para trabajar con flotantes.
Manipular datos binarios con Erlang
La mayoría de los lenguajes admiten la manipulación de datos como números, átomos, tuplas, listas, registros y/o estructuras, etc. La mayoría de ellos también solo tienen funciones muy básicas para manipular datos binarios. Erlang hace todo lo posible para proporcionar abstracciones útiles cuando se trata de valores binarios con coincidencia de patrones llevada al siguiente nivel. Hace que tratar con datos binarios sin procesar sea divertido y fácil, lo cual era necesario para las aplicaciones de telecomunicaciones para las que fue creado. La manipulación de bits tiene una sintaxis y modismos únicos que pueden parecer un poco extraños al principio, pero si sabes cómo funcionan generalmente los bits y los bytes, esto debería tener sentido.
La sintaxis de bits encierra datos binarios entre << y >>, los divide en segmentos legibles y cada segmento está separado por una coma. Un segmento es una secuencia de bits de un binario (no necesariamente en un límite de bytes, aunque este es el comportamiento predeterminado). Digamos que queremos almacenar un píxel naranja (24 bits). Si alguna vez comprobó los colores en Photoshop o en una hoja de estilos CSS para la web, sabrá que la notación hexadecimal tiene el formato #RRGGBB. Un tinte naranja es #F09A29 en esa notación, que podría ampliarse en Erlang a:
1> Color = 16#F09A29.
15768105
2> Pixel = <<Color:24>>.
<<240,154,41>>
Básicamente dice "Coloque los valores binarios de #F09A29 en 24 bits (rojo en 8 bits, verde en 8 bits y azul también en 8 bits) en la variable Píxel". Posteriormente se puede tomar el valor para escribirlo en un archivo. Esto no parece mucho, pero una vez escrito en un archivo, lo que obtendría al abrirlo en un editor de texto sería un montón de caracteres ilegibles. Cuando vuelva a leer el archivo, Erlang interpretará el binario en el bonito formato <<240,151,41>> nuevamente.
Lo que es más interesante es la capacidad de hacer coincidir patrones con archivos binarios para descomprimir contenido:
3> Pixels = <<213,45,132,64,76,32,76,0,0,234,32,15>>.
<<213,45,132,64,76,32,76,0,0,234,32,15>>
4> <<Pix1,Pix2,Pix3,Pix4>> = Pixels.
** exception error: no match of right hand side value <<213,45,132,64,76,32,76,
0,0,234,32,15>>
5> <<Pix1:24, Pix2:24, Pix3:24, Pix4:24>> = Pixels.
<<213,45,132,64,76,32,76,0,0,234,32,15>>
Lo que hicimos en el comando 3 fue declarar lo que serían exactamente 4 píxeles de colores RGB en binario.
En la expresión 4, intentamos descomprimir 4 valores del contenido binario. Lanza una excepción, porque tenemos más de 4 segmentos, ¡de hecho tenemos 12! Entonces, lo que hacemos es decirle a Erlang que cada variable del lado izquierdo contendrá 24 bits de datos. Eso es lo que significa Var:24. Luego podemos tomar el primer píxel y descomprimirlo en valores de un solo color:
6> <<R:8, G:8, B:8>> = <<Pix1:24>>.
<<213,45,132>>
7> R.
213
"Sí, eso es genial. ¿Y si solo quisiera el primer color desde el principio? ¿Tendré que descomprimir todos estos valores todo el tiempo?" ¡Ja! ¡No lo dudes! Erlang introduce más azúcar sintáctico y coincidencia de patrones para ayudarte con:
8> <<R:8, Rest/binary>> = Pixels.
<<213,45,132,64,76,32,76,0,0,234,32,15>>
9> R.
213
Bonito, ¿eh? Esto se debe a que Erlang acepta más de una forma de describir un segmento binario. Todos estos son válidos:
Value
Value:Size
Value/TypeSpecifierList
Value:Size/TypeSpecifierList
donde Tamaño representará bits o bytes (según el Tipo y Unidad a continuación) y TypeSpecifierList representa uno o más de los siguientes:
integer | float | binary | bytes | bitstring | bits | utf8 | utf16 | utf32
Esto representa el tipo de datos binarios utilizados. Tenga en cuenta que "bytes" es la abreviatura de "binario" y "bits" es la abreviatura de "cadena de bits". Cuando no se especifica ningún tipo, Erlang asume un tipo "entero".
Firma
Valores posibles: signed | unsigned
Solo importa para la coincidencia cuando el tipo es un número entero. El valor predeterminado es "sin firmar".
Endianidad
Valores posibles: big | little | native
La endianidad solo importa cuando el tipo es entero, utf16, utf32 o flotante. Esto tiene que ver con cómo el sistema lee los datos binarios. Como ejemplo, el formato de encabezado de imagen BMP mantiene el tamaño de su archivo como un número entero almacenado en 4 bytes. Para un archivo que tiene un tamaño de 72 bytes, un sistema little-endian lo representaría como <<72,0,0,0>> y uno big-endian como <<0,0,0,72>>. Uno se leerá como '72' mientras que el otro se leerá como '1207959552', así que asegúrese de utilizar el endianismo correcto. También existe la opción de usar 'nativo', que elegirá en tiempo de ejecución si la CPU usa little endianness o big endianness de forma nativa. De forma predeterminada, la endianidad está establecida en "grande".
Unidad
unidad unit:Integer
Este es el tamaño de cada segmento, en bits. El rango permitido es 1..256 y está establecido de forma predeterminada en 1 para números enteros, flotantes y cadenas de bits y en 8 para binarios. Los tipos utf8, utf16 y utf32 no requieren que se defina ninguna unidad. La multiplicación de Tamaño por Unidad es igual a la cantidad de bits que tomará el segmento y debe ser divisible por 8. El tamaño de la unidad generalmente se usa para garantizar la alineación de bytes.
TypeSpecifierList se construye separando los atributos por un '-'.
Algunos ejemplos pueden ayudar a digerir las definiciones:
10> <<X1/unsigned>> = <<-44>>.
<<"Ô">>
11> X1.
212
12> <<X2/signed>> = <<-44>>.
<<"Ô">>
13> X2.
-44
14> <<X2/integer-signed-little>> = <<-44>>.
<<"Ô">>
15> X2.
-44
16> <<N:8/unit:1>> = <<72>>.
<<"H">>
17> N.
72
18> <<N/integer>> = <<72>>.
<<"H">>
19> <<Y:4/little-unit:8>> = <<72,0,0,0>>.
<<72,0,0,0>>
20> Y.
72
Puede ver que hay más de una forma de leer, almacenar e interpretar datos binarios. Esto es un poco confuso, pero aún así es mucho más sencillo que utilizar las herramientas habituales que ofrecen la mayoría de los lenguajes.
Las operaciones binarias estándar (desplazamiento de bits a izquierda y derecha, 'y' binario, 'o', 'xor' o 'no') también existen en Erlang. Simplemente use las funciones bsl (Bit Shift Left), bsr (Bit Shift Right), band, bor, bxor y bnot.
2#00100 = 2#00010 bsl 1.
2#00001 = 2#00010 bsr 1.
2#10101 = 2#10001 bor 2#00101.
sábado, 2 de marzo de 2024
El tipo Int de Gleam
import gleam/io
import gleam/int
pub fn main() {
// Int arithmetic
io.debug(1 + 1)
io.debug(5 - 1)
io.debug(5 / 2)
io.debug(3 * 3)
io.debug(5 % 2)
// Int comparisons
io.debug(2 > 1)
io.debug(2 < 1)
io.debug(2 >= 1)
io.debug(2 <= 1)
// Equality works for any type
io.debug(1 == 1)
io.debug(2 == 1)
// Standard library int functions
io.debug(int.max(42, 77))
io.debug(int.clamp(5, 10, 20))
}
Existen operadores aritméticos y de comparación para enteros, así como el operador de igualdad que funciona en todos los tipos.
Cuando se ejecuta en la máquina virtual Erlang, los ints no tienen un tamaño máximo ni mínimo. Cuando se ejecuta en JavaScript, los ints se representan utilizando números de punto flotante de 64 bits de JavaScript,
El módulo de biblioteca estándar gleam/int contiene funciones para trabajar con ints.
viernes, 1 de marzo de 2024
Sistema de tipo en Gleam
import gleam/io
pub fn main() {
io.println("My lucky number is:")
// io.println(4)
}
Gleam tiene un robusto sistema de tipos estáticos que ayuda a escribir y editar código, detectando errores y mostrándole dónde realizar cambios.
Si descomentamos la línea io.println(4), Gleam lanza el siguiente error:
error: Type mismatch
┌─ /src/main.gleam:5:14
│
5 │ io.println(4)
│ ^
Expected type:
String
Found type:
Int
Para corregir el código, podemos cambiar io.println por io.debug, ya que esta función imprime un valor de cualquier tipo.
import gleam/io
pub fn main() {
io.println("My lucky number is:")
io.debug(4)
}
Gleam no tiene nulos, ni conversiones implícitas, ni excepciones, y siempre realiza una verificación de tipo completa. Si el código se compila, puede estar razonablemente seguro de que no tendrá inconsistencias que puedan causar errores o fallas.
jueves, 29 de febrero de 2024
Listas por comprensión en Erlang
Las listas por comprensión son formas de crear o modificar listas. También hacen que los programas sean breves y fáciles de entender en comparación con otras formas de manipular listas. Se basa en la idea de notación de conjuntos; Si alguna vez has tomado clases de matemáticas con teoría de conjuntos o si alguna vez has estudiado notación matemática, probablemente sepas cómo funciona. La notación de conjuntos básicamente le dice cómo construir un conjunto especificando las propiedades que deben satisfacer sus miembros. La comprensión de las listas puede ser difícil de entender al principio, pero vale la pena el esfuerzo.
Un ejemplo de notación de conjuntos sería {x ∈ ℜ x = x^2}. Esa notación de conjuntos le indica que los resultados que desea serán todos números reales iguales a su propio cuadrado. El resultado de ese conjunto sería {0,1}. Otro ejemplo de notación de conjuntos, más simple y abreviado sería {x : x > 0}. Aquí, lo que queremos son todos los números donde x > 0.
Las listas por comprensión en Erlang tratan de construir conjuntos a partir de otros conjuntos. Dado el conjunto {2n : n en L} donde L es la lista [1,2,3,4], la implementación de Erlang sería:
1> [2*N || N <- [1,2,3,4]].
[2,4,6,8]
Si comparamos la notación matemática con la de Erlang y no hay mucho que cambie: las llaves ({}) se convierten en corchetes ([]), los dos puntos (:) se convierten en dos barras verticales (||) y la palabra 'in' se convierte en la flecha. (<-). Sólo cambiamos símbolos y mantenemos la misma lógica. En el ejemplo anterior, cada valor de [1,2,3,4] coincide secuencialmente con el patrón N. La flecha actúa exactamente como el operador =, con la excepción de que no genera excepciones.
También puede agregar restricciones a la comprensión de una lista mediante operaciones que devuelvan valores booleanos. Si quisiéramos todos los números pares del uno al diez, podríamos escribir algo como:
2> [X || X <- [1,2,3,4,5,6,7,8,9,10], X rem 2 =:= 0].
[2,4,6,8,10]
Donde X rem 2 =:= 0 comprueba si un número es par. Las aplicaciones prácticas surgen cuando decidimos que queremos aplicar una función a cada elemento de una lista, obligándolo a respetar restricciones, etc. Como ejemplo, digamos que somos dueños de un restaurante. Un cliente entra, ve nuestro menú y pregunta si podría tener los precios de todos los artículos que cuestan entre $3 y $10 con los impuestos (digamos 7%) contados después.
3> RestaurantMenu = [{steak, 5.99}, {beer, 3.99}, {poutine, 3.50}, {kitten, 20.99}, {water, 0.00}].
[{steak,5.99},
{beer,3.99},
{poutine,3.5},
{kitten,20.99},
{water,0.0}]
4> [{Item, Price*1.07} || {Item, Price} <- RestaurantMenu, Price >= 3, Price =< 10].
[{steak,6.409300000000001},{beer,4.2693},{poutine,3.745}]
Por supuesto, los decimales no están redondeados de manera legible, pero entiendes el punto. Por lo tanto, la receta para la comprensión de listas en Erlang es NewList = [Expression || Patrón <- Lista, Condición1, Condición2, ... CondiciónN]. La parte Patrón <- Lista se denomina expresión Generadora.
5> [X+Y || X <- [1,2], Y <- [2,3]].
[3,4,4,5]
lunes, 26 de febrero de 2024
Imports en gleam
// Import the module and one of its functions
import gleam/io.{println}
pub fn main() {
// Use the function in a qualified fashion
io.println("This is qualified")
// Or an unqualified fashion
println("This is unqualified")
}
Normalmente, las funciones de otros módulos se utilizan de forma calificada, con el calificador del módulo antes del nombre de la función. Por ejemplo, io.println("¡Hola!").
También es posible especificar una lista de funciones para importar desde un módulo de forma no calificada, como la función println en el editor de código. Debido a que se importó de esta manera, se le puede llamar simplemente println.
Generalmente es mejor utilizar importaciones calificadas, ya que esto deja claro dónde está definida la función, lo que hace que el código sea más fácil de leer.
Hello world en Gleam
// Import a Gleam module from the standard library
import gleam/io
pub fn main() {
// Print to the console
io.println("Hello world!")
}
Aquí hay un programa que imprime el texto "Hello world!".
Para ello, utiliza la función println que se ha importado del módulo gleam/io, que forma parte de la biblioteca estándar de Gleam.
Para ejecutar este programa se usa el comando gleam run.
domingo, 25 de febrero de 2024
Instalando go zero
Ya hemos hablado de zero el framework de go para hacer microservicios. Ahora vamos a bajar las herramientas para trabajar con él.
Primero, tenemos que tener go instalado. Yo tengo la versión 1.22.0
$ go version
go version go1.22.0 linux/amd64
sábado, 24 de febrero de 2024
Gleam Language Tour
Como tengo tanto tiempo y siempre viene bien aprender un nuevo lenguaje, voy a hacer el Gleam Language Tour.
Ya he hablado de Gleam en otro post y no me quiero repetir. Les comparto el link y los invito a hacerlo conmigo.
Dejo link: https://tour.gleam.run/basics/hello-world/
jueves, 22 de febrero de 2024
Listas en Erlang
Las listas se utilizan para resolver todo tipo de problemas y son sin duda la estructura de datos más utilizada en Erlang. ¡Las listas pueden contener cualquier cosa! Números, átomos, tuplas, otras listas. La notación básica de una lista es [Elemento1, Elemento2,..., ElementoN] y puedes mezclar más de un tipo de datos en ella:
> [1, 2, 3, {numbers,[4,5,6]}, 5.34, atom].
[1,2,3,{numbers,[4,5,6]},5.34,atom]
domingo, 18 de febrero de 2024
Quickysort en Erlang
Un Algoritmo que me gusta mucho es el quicksort, porque es un algoritmo por demás claro. Ya he escrito lo fácil que es implementarlo en Rust, haskell y lisp
Ahora le toca a Erlang. Básicamente el algoritmo toma un pivot y agrupa los menores del pivot al principio y los mayores al final y aplica quicksort a estos 2 grupos. Y si la lista es vacia o tiene un elemento, ya esta ordenada.
Vamos al código:
sort([Pivot|T]) ->
sort([ X || X <- T, X < Pivot]) ++
[Pivot] ++
sort([ X || X <- T, X >= Pivot]);
sort([]) -> [].
Y listo!!
viernes, 16 de febrero de 2024
Chequeando "TODOs" con Roslyn
Vamos a buscar // TODO: ... con Roslyn
Para empezar en una aplicación de consola simple agreguemos algunos paquetes. Microsoft.CodeAnalysis.CSharp y Microsoft.CodeAnalysis.CSharp.Workspaces son lo que necesitamos.
Y hacemos esto:
const int ExitOK = 0;
const int ExitError = 99;
const int ExitIssueFound = 1;
static async Task<int> MainAsync(string[] args)
{
var workspace = await GetWorkspace().ConfigureAwait(false);
if (workspace == null)
return ExitError;
using (workspace)
{
var issueFound = false;
foreach (var project in workspace.CurrentSolution.Projects)
{
foreach (var document in project.Documents)
{
var documentWritten = false;
var root = await document.GetSyntaxRootAsync().ConfigureAwait(false);
foreach (var item in root.DescendantTrivia().Where(x => x.IsKind(SyntaxKind.SingleLineCommentTrivia)))
{
var match = Regex.Match(item.ToFullString(), @"//\s?TODO:\s*(.*)");
if (match.Success)
{
issueFound = true;
var text = match.Groups[1].Value;
if (!documentWritten)
{
documentWritten = true;
Console.WriteLine(MinimizePath(document.FilePath));
}
var position = item.GetLocation().GetMappedLineSpan();
var line = position.StartLinePosition.Line;
Console.WriteLine($"\tL{line}:\t{text}");
}
}
}
}
return issueFound ? ExitIssueFound : ExitOK;
}
}
static async Task<Workspace> GetWorkspace()
{
var workspace = MSBuildWorkspace.Create();
var solution = Directory.EnumerateFiles(Environment.CurrentDirectory, "*.sln", SearchOption.TopDirectoryOnly).FirstOrDefault();
if (solution != null)
{
await workspace.OpenSolutionAsync(solution).ConfigureAwait(false);
return workspace;
}
var project = Directory.EnumerateFiles(Environment.CurrentDirectory, "*.csproj", SearchOption.TopDirectoryOnly).FirstOrDefault();
if (project != null)
{
await workspace.OpenProjectAsync(project).ConfigureAwait(false);
return workspace;
}
return null;
}
static string MinimizePath(string path)
{
return path.Remove(0, Environment.CurrentDirectory.Length + 1);
}
