Cursos Gugler

 Como todos los años se dictan los cursos gugler que son una buena opción para capacitarse. 

¿Listo para ver lo que la IA puede hacer por ti?

Recibi este mail y lo quería compartir con ustedes: 

¿Listo para ver lo que la IA puede hacer por ti? La IA no es el futuro, es el presente Con el ebook que te traemos, conocerás casos de uso que puedes tomar como ejemplo e impulsar tus procesos. Ir al ebook

Aprende gratis las bases de la IA y aprovecha su potencial Conoce todo sobre la certificación OCI AI Foundations La IA está dando de qué hablar en todos los sectores del mercado, y conocerla es indispensable para adelantarte a los cambios que vienen. Por eso hoy te invitamos a aprovechar esta certificación sin costo donde aprenderás sus conceptos fundamentales, sin importar tu nivel de experiencia ni tu especialidad. Empezar ahora ¿Quieres probar todas las posibilidades de la IA en tu empresa? Aprovecha hoy mismo el Modo Gratuito de Oracle Cloud Oracle Cloud Infrastructure Recibe US$300 en créditos para usar durante 30 días. Empezar ahora Habla con un especialista ¿Quieres conversar sobre las posibilidades de la IA? Iniciar el chat IA integrada en las aplicaciones de Oracle Cloud Obtenga mejores estadísticas empresariales Descubra cómo las aplicaciones de IA se adaptan a su forma de trabajar con el aprendizaje automático y la inteligencia artificial. Solicitar demostración Manténgase conectado

Modulos en Erlang

Trabajar con el shell interactivo a menudo se considera una parte vital del uso de lenguajes de programación dinámicos. Es útil para probar todo tipo de códigos y programas. La mayoría de los tipos de datos básicos de Erlang se utilizaron sin necesidad de abrir un editor de texto o guardar archivos. Podrías dejar caer el teclado, salir a jugar y dar por terminado el día, pero serías un pésimo programador de Erlang si te detuvieras ahí mismo. ¡El código debe guardarse en algún lugar para poder usarse!

Para eso están los módulos. Los módulos son un conjunto de funciones reagrupadas en un único archivo, bajo un único nombre. Además, todas las funciones en Erlang deben definirse en módulos. 

Los BIF del módulo erlang se diferencian de otras funciones en que se importan automáticamente cuando usa Erlang. Cualquier otra función definida en un módulo que vaya a utilizar debe llamarse con el formato Módulo:Función(Argumentos).

Puedes verlo por ti mismo:

1> erlang:element(2, {a,b,c}).

b

2> element(2, {a,b,c}).

b

3> lists:seq(1,4).

[1,2,3,4]

4> seq(1,4).

** exception error: undefined shell command seq/2

Aquí, la función seq del módulo de lista no se importó automáticamente, mientras que el element sí. El error 'exception error: undefined shell command seq/2' proviene de que el shell busca un comando de shell como f() y no puede encontrarlo. Hay algunas funciones del módulo erlang que no se importan automáticamente, pero no se usan con demasiada frecuencia.

Lógicamente, deberías poner funciones sobre cosas similares dentro de un solo módulo. Las operaciones comunes en listas se mantienen en el módulo de listas, mientras que las funciones para realizar entradas y salidas (como escribir en la terminal o en un archivo) se reagrupan en el módulo io. Uno de los únicos módulos que encontrará que no respeta ese patrón es el módulo erlang antes mencionado que tiene funciones que hacen matemáticas, conversiones, tratan con multiprocesamiento, modifican la configuración de la máquina virtual, etc. No tienen ningún punto en común excepto ser funciones integradas. Debes evitar la creación de módulos como erlang y, en su lugar, centrarte en separaciones lógicas limpias.

Los bloques { } en Gleam

import gleam/io

pub fn main() {

  let fahrenheit = {

    let degrees = 64

    degrees

  }

  // io.debug(degrees) // <- This will not compile

  // Changing order of evaluation

  let celsius = { fahrenheit - 32 } * 5 / 9

  io.debug(celsius)

}

Los bloques son una o más expresiones agrupadas entre llaves. Cada expresión se evalúa en orden y se devuelve el valor de la última expresión.

Cualquier variable asignada dentro del bloque solo se puede utilizar dentro del bloque.

Los bloques { } también se pueden utilizar para cambiar el orden de evaluación de expresiones de operadores binarios.

* se resuelve antes que + por lo que la expresión 1 + 2 * 3 se evalúa como 7. Si 1 + 2 debe evaluarse primero para que la expresión se evalúe como 9, entonces la expresión se puede envolver en un bloque: { 1 + 2 } * 3. Esto es similar a agrupar entre paréntesis en otros lenguajes.

Alias de tipos en Gleam

import gleam/io

pub type UserId =  Int

pub fn main() {

  let one: UserId = 1

  let two: Int = 2

  // UserId and Int are the same type

  io.debug(one == two)

}

Se puede utilizar un alias de tipo para hacer referencia a un tipo con un nombre diferente. Darle un alias a un tipo no crea un nuevo tipo, sigue siendo el mismo tipo.

El nombre de un tipo siempre comienza con una letra mayúscula, a diferencia de las variables y funciones, que comienzan con una letra minúscula.

Cuando se utiliza la palabra clave pub, el alias de tipo es público y otros módulos pueden hacer referencia a él.

Anotaciones de tipo en gleam

pub fn main() {

  let _name: String = "Gleam"

  let _is_cool: Bool = True

  let _version: Int = 1

}

let se pueden escribir con una anotación de tipo después del nombre.

Las anotaciones de tipo pueden ser útiles para fines de documentación, pero no cambian la forma en que Gleam verifica el código más allá de garantizar que la anotación sea correcta.

Normalmente, el código Gleam no tendrá anotaciones de tipo para las asignaciones.

Comprensiones binarias en Erlang

 Las comprensiones binarias son para la sintaxis de bits lo que las listas por comprensión son para las listas: una forma de hacer que el código sea breve y conciso. Son relativamente nuevos en el mundo de Erlang como lo fueron en revisiones anteriores de Erlang, pero requirieron un módulo que los implementara para usar un indicador de compilación especial para poder funcionar. Desde las revisiones R13B (las que se usan aquí), se han convertido en estándar y se pueden usar en cualquier lugar, incluido el shell:

1> [ X || <<X>> <= <<1,2,3,4,5>>, X rem 2 == 0].    

[2,4]

El único cambio en la sintaxis con respecto a las listas por comprensión normales es <- que se convirtió en <= y usa binarios (<<>>) en lugar de listas ([]). Anteriormente vimos un ejemplo en el que había un valor binario de muchos píxeles en el que utilizamos la coincidencia de patrones para capturar los valores RGB de cada píxel. Estaba bien, pero en estructuras más grandes, posiblemente sería más difícil de leer y mantener. El mismo ejercicio se puede hacer con una comprensión binaria de una línea, que es mucho más clara:

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

3> RGB = [ {R,G,B} || <<R:8,G:8,B:8>> <= Pixels ].

[{213,45,132},{64,76,32},{76,0,0},{234,32,15}]

Cambiando <- a <= usemos un flujo binario como generador. La comprensión binaria completa básicamente cambió los datos binarios a números enteros dentro de tuplas. Existe otra sintaxis de comprensión binaria que le permite hacer exactamente lo contrario:

4> << <<R:8, G:8, B:8>> ||  {R,G,B} <- RGB >>.

<<213,45,132,64,76,32,76,0,0,234,32,15>>

Los elementos del binario resultante requieren un tamaño claramente definido si el generador devolvió binarios:

5> << <<Bin>> || Bin <- [<<3,7,5,4,7>>] >>.

** exception error: bad argument

6> << <<Bin/binary>> || Bin <- [<<3,7,5,4,7>>] >>. 

<<3,7,5,4,7>>

También es posible tener una comprensión binaria con un generador binario, siempre que se respete la regla de tamaño fijo anterior:

7> << <<(X+1)/integer>> || <<X>> <= <<3,7,5,4,7>> >>.

<<4,8,6,5,8>>

Discard patterns o underscore o guion bajo en Gleam

 

pub fn main() {

  // This variable is never used

  let _score = 1000

}

Si se asigna una variable pero no se utiliza, Gleam emitirá una advertencia.

Si se pretende que una variable no se utilice, el nombre puede tener como prefijo un guión bajo, silenciando la advertencia.

Si al ejemplo le quitamos el _ vamos a obtener el siguiente warning : 

warning: Unused variable

  ┌─ /src/main.gleam:3:7

  │

  │   let score = 1000

  │       ^^^^^ This variable is never used

Hint: You can ignore it with an underscore: `_score`.

Otro ejemplo de Stl de C++

Escribamos un programa que muestre las palabras y la cantidad de veces que aparecen dentro de un archivo de texto. 

vector<string> v;

map<string, int> m;

copy(istream_iterator<string>(ifstream("words.txt")), istream_iterator<string>(), back_inserter(v));

for (auto vi = v.begin(); vi != v.end(); ++vi) ++m[*vi];

for (auto mi = m.begin(); mi != m.end(); ++mi) 

    cout << mi->first << ": " << mi->second << endl;

Y listo!

Asignaciones en Gleam

import gleam/io

pub fn main() {

  let x = "Original"

  io.debug(x)

  // Assign `y` to the value of `x`

  let y = x

  io.debug(y)

  // Assign `x` to a new value

  let x = "New"

  io.debug(x)

  // The `y` still refers to the original value

  io.debug(y)

}

Se puede asignar un valor a una variable usando let.

Los nombres de las variables se pueden reutilizar mediante enlaces let posteriores, pero los valores a los que hacen referencia son inmutables, por lo que los valores en sí no se modifican ni mutan de ninguna manera.

Un ejemplo utilizando STL de C++

Voy hacer unos post con ejemplos de utilización de la Stl de C++. Vamos con el primero: 

Leamos una cantidad arbitraria de valores enteros (n>=1) del archivo “numbers.txt” y mostramos:

• Mínimo, máximo
• Media
• Promedio
• Media geométrica ((y1 * y2 * … yn)^(1/n))

Con Stl sería así: 

vector<int> v;

copy(istream_iterator<int>(ifstream("numbers.txt")), istream_iterator<int>(), back_inserter(v));

sort(v.begin(), v.end());

cout << "min/max: " << v.front() << " " << v.back() << endl;

cout << "median : " << *(v.begin() + (v.size()/2)) << endl;

cout << "average: " << accumulate(v.begin(), v.end(), 0.0) / v.size() << endl;

cout << "geomean: " << pow(accumulate(v.begin(),v.end(),1.0,multiplies<double>()), 1.0/v.size()) 

<< endl;

Y listo!

Strings en Gleam

import gleam/io

import gleam/string

pub fn main() {

  // String literals

  io.debug("👩‍💻 こんにちは Gleam 🏳️‍🌈")

  io.debug(

    "multi

    line

    string",

  )

  io.debug("\u{1F600}")

  // Double quote can be escaped

  io.println("\"X\" marks the spot")

  // String concatenation

  io.debug("One " <> "Two")

  // String functions

  io.debug(string.reverse("1 2 3 4 5"))

  io.debug(string.append("abc", "def"))

}

En Gleam, las cadenas se escriben como texto entre comillas dobles, pueden abarcar varias líneas y contener caracteres Unicode.

El operador <> se puede utilizar para concatenar cadenas.

Se admiten varias secuencias de escape:

\" - comillas dobles

\\ - barra invertida

\f - avance de formulario

\n - nueva línea

\r - retorno de carro

\t - pestaña

\u{xxxxxx} - punto de código Unicode

El módulo de biblioteca estándar gleam/string contiene funciones para trabajar con cadenas.

Primera API con Go-zero

Después de completar la instalación de goctl, podemos crear un servicio HTTP mínimo para obtener una descripción general del servicio API go-zero de goctl.

# Create workspaces and enter the directory

$ mkdir -p ~/workspace/api && cd ~/workspace/api

# Execute instructions generated demo service

$ goctl api new demo

Done.

Después de ejecutar la instrucción, se generará un directorio de demostración en el directorio actual que contiene un servicio HTTP minimizado, verificaremos la estructura del directorio del servicio.

$ cd ~/workspace/api/demo

$ ls

demo.api demo.go  etc      go.mod   internal

$ tree

.

├── demo.api

├── demo.go

├── etc

│   └── demo-api.yaml

├── go.mod

└── internal

    ├── config

    │   └── config.go

    ├── handler

    │   ├── demohandler.go

    │   └── routes.go

    ├── logic

    │   └── demologic.go

    ├── svc

    │   └── servicecontext.go

    └── types

        └── types.go

Después de completar la generación del código anterior, podemos encontrar los archivos ~/workspace/api/demo/internal/logic/demologic.go, y podemos completar el códigos entre las líneas 27 y 28:

resp = new(types.Response)

resp.Message = req.Name

Después de escribir el código anterior, podemos iniciar el servicio con las siguientes instrucciones:

# Enter service directory

$ cd ~/workspace/api/demo

# to organize dependencies

$ go mod tidy

# Run go program

$ go run demo.go

Cuando vea el siguiente resultado "Starting server at 0.0.0.0.0:888.." indica que el servicio se ha iniciado correctamente, entonces visitamos el servicio HTTP.

$ curl --request GET 'http://127.0.0.0.1:8888/from/me'

Cuando vea el resultado en la terminal {"message":"me"} en nombre de su servicio se inició con éxito.

Y listo!!

Dejo link: https://go-zero.dev/en/docs/tasks/cli/api-demo

Bools en Gleam

import gleam/io

import gleam/bool

pub fn main() {

  // Bool operators

  io.debug(True && False)

  io.debug(True && True)

  io.debug(False || False)

  io.debug(False || True)

  // Bool functions

  io.debug(bool.to_string(True))

  io.debug(bool.to_int(False))

}

Un Bool es Verdadero o Falso.

El ||, &&, y ! Los operadores se pueden utilizar para manipular bools.

El || y los operadores && están en cortocircuito, lo que significa que si el lado izquierdo del operador es Verdadero para || o False para && entonces no se evaluará el lado derecho del operador.

El módulo de biblioteca estándar gleam/bool contiene funciones para trabajar con bools.

Ponte al día con la IA generativa

 Me llego este mail de la gente de google y quería compartirlo: 

Ponte al día con la IA generativa

¿Quieres saber cómo la IA generativa afectará a tu empresa? Estos recursos te ayudarán a mantenerte al día respecto de este tema tan cambiante.

Hola Emanuel,

El revuelo que causa la IA generativa no es algo que pueda ignorarse. De hecho, el 82% de los ejecutivos prevén que esta tecnología transformará considerablemente su industria.1 Con tanto alboroto, seguir el paso puede ser una tarea difícil.

Este es el primer correo electrónico que recibirás de una serie que te brindará recursos útiles relacionados con la IA generativa. En las próximas semanas, exploraremos todas las tendencias clave y los problemas que los líderes empresariales como tú deben conocer, lo que te permitirá materializar su potencial en tu negocio.

Descubre la jerga de la IA generativa

Para adoptar la tecnología revolucionaria de la IA generativa, es necesario conocer todos los nuevos términos y frases que se relacionan con ella. Por ejemplo, el ajuste de instrucciones o "prompt tuning" en inglés, las incorporaciones, los modelos de base y mucho más.

Si eres un ejecutivo atareado, comprender la terminología de una tecnología nueva puede parecerte difícil de lograr. Este artículo útil explica el lenguaje que debes conocer para explorar cómo la IA generativa podría transformar tu negocio.

Lee el manual de la IA generativa

Explora las oportunidades en las diferentes industrias

A través de sus diversos usos, como posibilitar interacciones en línea más conversacionales o un acceso intuitivo a datos complejos, la IA generativa está reformulando los procesos de negocio.

Con un potencial tan amplio, a los líderes empresariales les interesa conocer los usos y las oportunidades específicas para su industria o su organización. En este artículo, se examinan las posibilidades en varias industrias clave.

Lee el artículo

Domina los conceptos más importantes de la IA generativa

Si bien la IA generativa es un tema increíblemente amplio, surgieron algunos conceptos clave en los últimos meses. Para finalizar, te recomendamos que leas este artículo, que resume los conceptos clave más relevantes para líderes empresariales como tú.

Obtén más información sobre los conceptos principales de la IA generativa

Nos vemos en la nube, El equipo de Google Cloud

1. Google Cloud Gen IA Benchmarking Study, julio de 2023