Me escribió mi amigoAndriy Burkov. Y me dijo que ya se encuentra el capitulo 7 y 8 del libro gratuito Machine Learning Engineering.
No sé que más agregar, dejo el link : http://www.mlebook.com/wiki/doku.php?id=start
martes, 10 de marzo de 2020
Ya esta listo el capitulo 7 y 8 del libro Machine Learning Engineering.
Me escribió mi amigoAndriy Burkov. Y me dijo que ya se encuentra el capitulo 7 y 8 del libro gratuito Machine Learning Engineering.
No sé que más agregar, dejo el link : http://www.mlebook.com/wiki/doku.php?id=start
lunes, 9 de marzo de 2020
HTML + javascript + Haskell = ELM, parte 4
Seguimos con el post anteriro.
Como con cualquier lenguaje funcional, la base de Elm es la función. Definir una es trivial. Veamos algunas funciones :
> add x y = x + y
<function> : number -> number -> number
> double x = x * 2
<function> : number -> number
> anonymousInc = \x -> x + 1
<function> : number -> number
> double (add 1 2)
6 : number
> List.map anonymousInc [1, 2, 3]
[2,3,4] : [number]
La sintaxis para crear funciones es muy simple e intuitiva. add es una función con nombre con dos argumentos, x e y. Las funciones anónimas expresan parámetros como \ x, y el cuerpo de la función sigue los caracteres ->.
Como Elixir, Elm tiene el operador de tubería que permite componer funciones, de esta manera:
> 5 |> anonymousInc |> double
Tomamos 5 y lo pasamos como el primer argumento a anonymousInc, para obtener 6. Luego, lo pasamos como el primer argumento para duplicar. También podemos hacer que esa expresión se ejecute de derecha a izquierda:
> double <| anonymousInc <| 5
12 : number
Evan Czaplicki, creador de Elm, dice que obtuvo esta función de F#, que a su vez obtuvo la idea de las tuberías de Unix, por lo que esta idea ha existido por un tiempo, ¡pero es buena!
Al igual que con cualquier lenguaje funcional, hay muchas funciones que le permitirán trabajar con funciones de todo tipo de formas:
> List.map double [1..3]
[2,4,6] : List number
> List.filter (\x -> x < 3) [1..20]
[1,2] : List comparable
[1..3] es un rango. Puede explorar más funciones de la Lista con la biblioteca de listas.
Cuando está componiendo una solución con Elm, puede tener la tentación de codificar cada caso como un cuerpo de función separado como lo haría en Haskell, Erlang o Elixir, pero no se puede :( :
> factorial 1 = 1
<function> : number -> number'
> factorial x = x * factorial (x - 1)
<function> : number -> number
>
RangeError: Maximum call stack size exceeded
Parece que la segunda llamada reemplazó a la primera. En cambio, debe usar el mismo cuerpo de función y dividir el problema usando mayúsculas y minúsculas o si, de esta manera:
> factorial x = \
| if | x == 0 -> 1 \
| | otherwise -> x * factorial (x - 1)
<function> : number -> number
> factorial 5
120 : number
Suficientemente simple. factorial 0 es 1; de lo contrario, factorial x es x * factorial (x-1). Manejaría la recursividad de la lista de la misma manera:
> count list = \
| case list of \
| [] -> 0 \
| head::tail -> 1 + count tail
<function> : [a] -> number
> count [4, 5, 6]
3 : number
La cantidad de elementos de una lista vacía es cero y la cantidad de elementos de cualquier otra lista es 1 más la cantidad del resto. Veamos cómo atacar problemas similares con la coincidencia de patrones.
Por ahora vamos bien, pero seguimos en otro post...
domingo, 8 de marzo de 2020
HTML + javascript + Haskell = ELM, parte 3
Construimos tipos para el color y la pieza, y eso estuvo bien perooooooo nuestro ejemplo de ajedrez se volvió un poco más complicado cuando queríamos extraer el color. Lo que realmente necesitamos es una forma de acceder a los campos con nombre. Esa cosa es un registro, y es un compañero natural para los objetos de JavaScript. Digamos que queremos representar una pieza de ajedrez con los campos Color y Pieza:
> blackQueen = {color=Black, piece=Queen}
{ color = Black, piece = Queen } : { color : Repl.Color, piece : Repl.Piece }
> blackQueen.color
Black : Repl.Color
> blackQueen.piece
Queen : Repl.Piece
El Repl. es solo un alcance para los tipos, y el . es forma que llamamos a color es en realidad una función:
> .color blackQueen
Black : Repl.Color
Ahora, podemos acceder a los componentes de nuestro tipo estructurado. Al igual que con muchos lenguajes funcionales, los registros son inmutables, pero podemos crear uno nuevo con campos actualizados, o incluso campos cambiados, como este:
> whiteQueen = { blackQueen | color <- White }
{ color = White, piece = Queen } : { piece : Repl.Piece, color : Repl.Color }
> position = { column = "d", row = 1 }
{ column = "d", row = 1 } : {column : String, row : number}
> homeWhiteQueen = { whiteQueen | position = position }
{ color = White, piece = Queen, position = { column = "d", row = 1 } }
: { piece : Repl.Piece
, color : Repl.Color
, position : { column : String, row : number }
}
> colorAndPosition = { homeWhiteQueen - piece }
{ color = White, position = { column = "d", row = 1 } }
: { color : Repl.Color, position : { column : String, row : number }
}
> colorAndPosition.color
White : Repl.Color
Creamos tres nuevos registros, todos de diferentes tipos, transformando nuestro registro original.
Por ahora vamos bien, pero seguimos en otro post...
HTML + javascript + Haskell = ELM, parte 2
Seguimos con el post anteriro.
elm provee el if tradicional :
if x < 0 then "too small" else "ok"
"ok" : String
Similar al if de Ruby o al case de otros lengujes podemos escribir lo siguiente :
> x = 5
5 : number
> if | x < 0 -> "too small" \
| | x > 0 -> "too big" \
| | otherwise -> "just right"
"too big" : String
La barra invertida es porque estoy usando el RELP y tengo que avisarle de los enteres que no tienen sentido
Este if es muy similar a pattern matchinig pero Elm tiene pattern matching :
> list = [1, 2, 3]
[1,2,3] : [number]
> case list of \
| head::tail -> tail \
| [] -> []
[2,3] : [number]
Esta sentencia devuelve el final de una lista, si existe, las vacia, de otro modo. Se puede ver el uso de pattern matching.
La belleza y el poder de un sistema de tipos se ve cuando constrimos nuestros propios tipos de datos complejos. Veamos un ejemplo, una pieza de ajedrez tiene un tipo y un color. Lo que podemos hacer es lo siguiente :
> type Color = Black | White
> type Piece = Pawn | Knight | Bishop | Rook | Queen | King
> type ChessPiece = CP Color Piece
> piece = CP Black Queen
CP Black Queen : ChessPiece
Crearemos un tipo que funcione como Lista. Para esto debe saber que Cons construye una lista, dado un elemento y otra lista :
type List = Nil | Cons Int List
elm provee el if tradicional :
if x < 0 then "too small" else "ok"
"ok" : String
Similar al if de Ruby o al case de otros lengujes podemos escribir lo siguiente :
> x = 5
5 : number
> if | x < 0 -> "too small" \
| | x > 0 -> "too big" \
| | otherwise -> "just right"
"too big" : String
La barra invertida es porque estoy usando el RELP y tengo que avisarle de los enteres que no tienen sentido
Este if es muy similar a pattern matchinig pero Elm tiene pattern matching :
> list = [1, 2, 3]
[1,2,3] : [number]
> case list of \
| head::tail -> tail \
| [] -> []
[2,3] : [number]
Esta sentencia devuelve el final de una lista, si existe, las vacia, de otro modo. Se puede ver el uso de pattern matching.
La belleza y el poder de un sistema de tipos se ve cuando constrimos nuestros propios tipos de datos complejos. Veamos un ejemplo, una pieza de ajedrez tiene un tipo y un color. Lo que podemos hacer es lo siguiente :
> type Color = Black | White
> type Piece = Pawn | Knight | Bishop | Rook | Queen | King
> type ChessPiece = CP Color Piece
> piece = CP Black Queen
CP Black Queen : ChessPiece
Un constructor de tipos nos permite construir nuevas instancias de un tipo. Nuestro tipo ChessPiece consta de los caracteres CP, nuestro constructor de tipos, seguido de un Color y una Pieza. Ahora, podemos usar la combinación de mayúsculas y minúsculas para separar la pieza, así:
> color = case piece of \
| CP White _ -> White \
| CP Black _ -> Black
Black : Color
type List = Nil | Cons Int List
Esta es una definición recursiva, una lista es una lista vacia o una construcción de un elemento y una lista.
Ese tipo de datos es interesante, pero podemos hacerlo mejor. Podemos definir una lista abstracta, una que pueda contener cualquier tipo de datos, como este:
type List a = Empty | Cons a (List a)
Es igual que la definición anterior pero con tipo generico a.
Si desea saber cómo se evalúa una lista en Elm, observe el tipo de datos. Puede representar el tipo para la lista [1, 2] como Cons 1 (Cons 2 Empty).
Ahora, cuando te digo que puedes combinar el encabezado de una lista con la cola, tiene sentido. Cons funciona en tipos en tiempo de compilación. La contraparte en tiempo de ejecución del operador Cons que trabaja con datos es ::, y funciona así :
> 1 :: 2 :: 3 :: []
[1,2,3] : [number]
Por ahora vamos bien, pero seguimos en otro post...
eBook "C++17 IN DETAIL - Part 1"
Me llego el siguiente mail de Embarcadero, y como es un libro gratuito lo comparto con ustedes :
| ||||||||||||||||||||||||||
| ||||||||||||||||||||||||||
| ||||||||||||||||||||||||||
| ||||||||||||||||||||||||||
| ||||||||||||||||||||||||||
|
miércoles, 4 de marzo de 2020
HTML + javascript + Haskell = ELM
Supongamos que tenemos que hacer un juego en Html, css y javascript. Ante esta idea, viene otra muy rápidamente relacionada con el suicidio.
Por suerte existe ELM, que es un lenguaje inspirado en Haskell el cual esta orientado a sistemas reactivos y compila a HTML y javascript.
Antes de comenzar debemos instalar ELM. ELM cuenta con 2 herramientas, una es el RELP y otra es le server. Por ahora vamos a utilizar el RELP.
Para instalar el RELP, vamos a : https://guide.elm-lang.org/install/elm.html
O podemos utilizar el try : https://elm-lang.org/try
O podemos utilizar el try : https://elm-lang.org/try
Instalado el RELP, vamos a ver expresiones en ELM y literales :
> 4
4 : number
> "String"
"String" : String
> 5 < 4
False : Bool
Todo retorna un valor y ese valor tiene un tipo. ELM es de tipado estático y su tipado es muy poderoso pero algo quisquilloso :
> [1, "2"]
[1 of 1] Compiling Repl
( repl-temp-000.elm )
The 2nd element of this list is an unexpected type of value.
3|
[1, "2"]
^^^
...
> 4 + "4"
[1 of 1] Compiling Repl
...
( repl-temp-000.elm )
As I infer the type of values flowing through your program, I see a conflict
between these two types: number String
> "4" ++ "4"
"44" : String
> 4 ++ 4
[1 of 1] Compiling Repl
...
Expected Type: appendable
...
> [1, 2] ++ [3, 4]
[1,2,3,4] : [number]
( repl-temp-000.elm )
Por lo visto, ELM es de tipado fuerte y estático. ELM esta influenciado por el sistema de tipos de Haskell y ML. Su sistema de tipo contiene type classes. Esto se puede ver como las interfaces de Java. Es decir, un tipo implementa estas interfaces y todas las funciones que trabajan con este data type, puede ser utilizados con el tipo.
Por ejemplo tanto las listas como los Strings son appendable por lo tanto toda función que necesitan un appendable pueden ser utilizadas con listas o String por ejemplo ++.
A la vez ELM infiere el tipo, no es necesario indicar le tipo dado que este es inferido por el compilador :
> a = [1, 2, 3]
[1,2,3] : [number]
A la vez cuenta con un sistema de tipos polimorfico, lo que significa que puede tratar los tipos que heredan de la misma type class de la misma manera. Verá que Elm aprovecha al máximo su herencia de ML y Haskell para construir uno de los mejores sistemas de tipos del mundo.
> a[1] = 2
[1 of 1] Compiling Repl ( repl-temp-000.elm )
> a[1] = 2
<function> : List number -> number'
Elm es un lenguaje de tipado estático, y muy estricto, aunque en REPL, puede redefinir valores primitivos por conveniencia. Elm es como Elixir a este aspecto. : List number -> number'
Creo que por este post estamos, continuará ...
Dejo link : https://elm-lang.org/
lunes, 2 de marzo de 2020
Ballerina un lenguaje pensado para la nube, Parte 2
Si queres probar el código que vamos dejando, pueden hacerlo acá : https://play.ballerina.io/
Veamos un poco de código en Ballerina y empecemos con un hola mundo:
import ballerina/io;
public function main() {
io:println("Hello, World!");
}
import ballerina/io;
public function main() {
worker w1 {
io:println("Hello, World! #m");
} worker w2 {
io:println("Hello, World! #n");
} worker w3 {
io:println("Hello, World! #k");
}
}
import ballerina/http;
import ballerina/log;
service hello on new http:Listener(9090) {
resource function sayHello(http:Caller caller, http:Request req) {
var result = caller->respond("Hello, World!");
if (result is error) {
log:printError("Error sending response", result);
}
}
}
y ahora de cliente :
import ballerina/http;
import ballerina/io;
public function main() {
http:Client clientEP = new ("http://www.mocky.io");
var resp = clientEP->get("/v2/5ae082123200006b00510c3d/");
if (resp is http:Response) {
var payload = resp.getTextPayload();
if (payload is string) {
io:println(payload);
} else {
io:println(payload.detail());
}
} else {
io:println(resp.detail());
}
}
Puff... lo que se puede hacer con un "hola mundo". Primera conclusión, claramente se ve que Ballerina esta ampliamente influenciado por Node y javascript.
Veamos un objeto :
import ballerina/io;
type Person object {
public string name = "";
public int age = 0;
public Person? parent = ();
private string email = "default@abc.com";
string address = "No 20, Palm grove";
};
public function main() {
Person p1 = new;
io:println(p1.age);
Person p2 = new();
io:println(p2.age);
Person p3 = new Person();
io:println(p3.age);
}
Se ve que las clases se declaran con type y se pueden hacer cosas más complejas :
import ballerina/io;
type Person object {
public int age;
public string firstName;
public string lastName;
function __init(int age, string firstName, string lastName) {
self.age = age;
self.firstName = firstName;
self.lastName = lastName;
}
function getFullName() returns string {
return self.firstName + " " + self.lastName;
}
};
public function main() {
Person p1 = new(5, "John", "Doe");
io:println(p1.getFullName());
}
Ahora podemos ver la influencia de Go. Porque tiene la misma forma de manejar errores, los retorna y sigue la filosofía de que el error es un resultado más :
import ballerina/io;
const ACCOUNT_NOT_FOUND = "AccountNotFound";
const INVALID_ACCOUNT_ID = "InvalidAccountID";
function getAccountBalance(int accountID) returns int|error {
if (accountID < 0) {
return error(INVALID_ACCOUNT_ID, accountID = accountID);
} else if (accountID > 100) {
return error(ACCOUNT_NOT_FOUND, accountID = accountID);
}
return 600;
}
public function main() {
error simpleError = error("SimpleErrorType", message = "Simple error occurred");
io:println("Error: ", simpleError.reason(),
", Message: ", simpleError.detail()?.message);
int|error result = getAccountBalance(-1);
if (result is int) {
io:println("Account Balance: ", result);
} else {
io:println("Error: ", result.reason(),
", Account ID: ", result.detail()["accountID"]);
}
}
Y por último un ejemplo de interacción con Java :
import ballerinax/java;
import ballerina/io;
function newArrayDeque() returns handle = @java:Constructor {
class: "java.util.ArrayDeque"
} external;
function newArrayDequeWithInitialCapacity(int numElements) returns handle = @java:Constructor {
class: "java.util.ArrayDeque",
paramTypes: ["int"]
} external;
public function main() {
var arrayDeque = newArrayDeque();
io:println(arrayDeque);
var arrayDequeWithCapacity = newArrayDequeWithInitialCapacity(10);
io:println(arrayDequeWithCapacity);
}
No mucho que explicar, de esta manera podemos llamar clases java.
Conclusión, me gusto!
Toma buenas cosas de diferentes lenguajes y lo mezcla de forma equilibrada. Lo único que le critico es el ";" que no lo veo necesario. Por lo dicho, vamos a tener que estudiar un nuevo lenguaje :P
Dejo link: https://ballerina.io/v1-1/learn/by-example/
sábado, 29 de febrero de 2020
Ballerina un lenguaje pensado para la nube
Ballerina es un lenguaje de programación open-source y una plataforma para que los programadores de aplicaciones de la era de la nube escriban fácilmente software que simplemente funciona.
Durante décadas, los lenguajes de programación han tratado las redes simplemente como fuentes de entrada y salida. Ballerina presenta nuevas abstracciones fundamentales de objetos de clientes, servicios, funciones de recursos y oyentes para incorporar las redes al lenguaje de modo que los programadores puedan abordar directamente las problemática de la computación distribuida como parte de su lógica de aplicación. Esto facilita que las aplicaciones de red resistentes, seguras y de alto rendimiento estén al alcance de todos los programadores.
Los diagramas de secuencia han sido la herramienta favorita de todos para describir cómo funcionan los programas distribuidos y concurrentes. Sin embargo, ningún lenguaje de programación actual le permite escribir su lógica como un diagrama de secuencia en estas aplicaciones. En Ballerina, cada programa es un diagrama de secuencia que ilustra interacciones distribuidas y concurrentes automáticamente. El diagrama es el código y el código es el diagrama.
El tipado estático es el dolor de cabeza del programador de aplicaciones de red y el tipado dinámico es la pesadilla del ingeniero de aplicaciones confiables. El sistema de tipo estructural de tipo estático de Ballerina que está diseñado para ser compatible con el esquema de datos de red permite a los programadores de aplicaciones escribir código que se adhiera al Principio de Robustez: Sea conservador en lo que envía, sea liberal en lo que acepta.
En la era de la nube, ejecutar un programa ya no es solo una cuestión de compilación y ejecución, sino que se trata de compilar, construir la imagen, empujar la imagen, configurar la orquestación de contenedores y, finalmente, ejecutarla. Ballerina lleva todo el proceso de ejecución del programa a las manos del desarrollador con metadatos extensibles que se compilan en programas ejecutables para todas las principales plataformas en la nube.
Ballerina tiene todas las biblioteca estándar y la cadena de herramientas para ayudar a los desarrolladores a crear aplicaciones rápidamente. En el momento del desarrollo, Ballerina cubre documentación, pruebas, uso compartido, control de versiones y más.
Los programas en el mundo real se escriben una vez y se leen decenas a cientos de veces. Ballerina prioriza la conveniencia y productividad del programador con familiaridad, abstracciones más claras y conceptos más fáciles sobre el rendimiento del sistema.
Luego de leer todo esto, veamos un hola mundo, por lo menos :
import ballerina/io;
public function main() {
io:println("Hello Ballerina!");
}
Si queres probar este codigo pode ir a : https://play.ballerina.io/
Dejo link: https://ballerina.io/
miércoles, 26 de febrero de 2020
Libros de Java Code Geeks
|
martes, 25 de febrero de 2020
Generar sitios estáticos con Hugo
Hugo es uno de los generadores de sitios estáticos de código abierto más populares. Con su sorprendente velocidad y flexibilidad, Hugo hace que la creación de sitios web sea divertido.
Homebrew, un administrador de paquetes para macOS y linux, se puede instalar desde brew.sh. Luego de instalar brew
brew install hugo
Para verificar su nueva instalación:
hugo version
Ahora podemos crear el sitio :
hugo new site quickstart
cd quickstart
git init
git submodule add https://github.com/budparr/gohugo-theme-ananke.git themes/ananke
El tema lo podemos descargar desde: https://github.com/budparr/gohugo-theme-ananke/archive/master.zip si no queremos usar git. Extraemos ese archivo .zip para obtener un directorio "gohugo-theme-ananke-master". Luego cambiamos el nombre de ese directorio a "ananke" y lo movemos al directorio "themes /".
Luego, agregue el tema a la configuración del sitio:
echo 'theme = "ananke"' >> config.toml
Ahora agregamos el contenido :
Se puede crear archivos de contenido manualmente (por ejemplo, como contenido / <CATEGORY> / <FILE>. <FORMAT>) y proporcionar metadatos en ellos, sin embargo, puede usar un comando:
hugo new posts/my-first-post.md
Edite el archivo de contenido recién creado si lo desea, comenzará con algo como esto:
---
title: "My First Post"
date: 2019-03-26T08:47:11+01:00
draft: true
---
Ahora, vamos a iniciar el servidor Hugo:
hugo server -D
| EN
+------------------+----+
Pages | 10
Paginator pages | 0
Non-page files | 0
Static files | 3
Processed images | 0
Aliases | 1
Sitemaps | 1
Cleaned | 0
Total in 11 ms
Watching for changes in /Users/bep/quickstart/{content,data,layouts,static,themes}
Watching for config changes in /Users/bep/quickstart/config.toml
Environment: "development"
Serving pages from memory
Running in Fast Render Mode. For full rebuilds on change: hugo server --disableFastRender
Web Server is available at http://localhost:1313/ (bind address 127.0.0.1)
Press Ctrl+C to stop
Podemos navegar en http://localhost:1313/
Podemos editar o agregar contenido nuevo y luego simplemente actualizar el navegador para ver los cambios.
Cuando el sitio este listo, debemos cambiar las configuraciones. Debemos editar config.toml y cambiar los valores:
baseURL = "https://example.org/"
languageCode = "en-us"
title = "My New Hugo Site"
theme = "ananke"
Además, si ya tenemos un dominio listo, podemos configurar baseURL. Tenga en cuenta que este valor no es necesario cuando se ejecuta el servidor de desarrollo local.
Luego debemos reconstruir nuestro sitio con:
hugo -D
La salida estará en el directorio ./public/ de forma predeterminada (-d / - marca de destino para cambiarlo, o establecer publicar dir en el archivo de configuración).
Dejo link: https://gohugo.io/
lunes, 24 de febrero de 2020
ZIO
Su filosofía esta basada en fibras (que son como hilos de ejecución) altamente escalables y sin bloqueo que nunca desperdician ni pierden recursos, ZIO permite crear aplicaciones escalables, resistentes y reactivas que satisfagan las necesidades de su negocio. Entre las características podemos nombrar:
- Alto rendimiento.
- Tipe-safe.
- Concurrente.
- Asincrónico.
- Seguridad en los recursos.
- Probable
- Elástico.
- Funcional.
Antes de empezar debemos incluir a ZIO en el proyecto agregando la siguiente entrade en el build.sbt:
libraryDependencies += "dev.zio" %% "zio" % "1.0.0-RC17"
Si deseamos utilizar streams ZIO, también debe incluir la siguiente dependencia:
libraryDependencies += "dev.zio" %% "zio-streams" % "1.0.0-RC17"
Ahora veamos un pequeño ejemplo:
import zio.App
import zio.console._
object MyApp extends App {
def run(args: List[String]) =
myAppLogic.fold(_ => 1, _ => 0)
val myAppLogic =
for {
_ <- putStrLn("Hello! What is your name?")
name <- getStrLn
_ <- putStrLn(s"Hello, ${name}, welcome to ZIO!")
} yield ()
}
run debería devolver un valor ZIO que tenga todos sus errores manejados,
Como se puede ver myAppLogic, se plegó de tal forma que produce un valor si falla, habrá un 1; pero si tiene éxito, habrá un 0.
Si está integrando ZIO en una aplicación existente, utilizando inyección de dependencia, o no controla su función principal main, se puede crear un sistema de tiempo de ejecución para ejecutar sus programas ZIO:
import zio._
import zio.console._
object IntegrationExample {
val runtime = new DefaultRuntime {}
runtime.unsafeRun(putStrLn("Hello World!"))
}
ZIO proporciona un módulo para interactuar con la consola. Puede importar las funciones en este módulo con el siguiente fragmento de código:
import zio.console._
Si necesita imprimir texto en la consola, puede usar putStr y putStrLn:
// Print without trailing line break
putStr("Hello World")
// res8: ZIO[Console, Nothing, Unit] = zio.ZIO$Read@2ba3e0d1
// Print string and include trailing line break
putStrLn("Hello World")
// res9: ZIO[Console, Nothing, Unit] = zio.ZIO$Read@75e3acfe
Si necesita leer la entrada desde la consola, puede usar getStrLn:
val echo = getStrLn flatMap putStrLn
// echo: ZIO[Console, java.io.IOException, Unit] = zio.ZIO$FlatMap@72bc78be
Es importante utilizar la consola de zio porque cada fibra tiene sus propios recursos, y la consola de Zio soluciona la interacción con la consola.
Dejo link : https://zio.dev/
viernes, 21 de febrero de 2020
Machine Learning. Curso básico de Machine Learning Gratis!!!
Quiero recomendar este curso gratuito de Machine Learning, donde aprenderas a usar Numpy, Pandas, Seaborn, Matplotlib, Plotly y Sckit-Learn con Python.
Entre los temas tenemos:
- Usar Python para Machine Learning y Data Science
- Implementar algoritmos de Machine Learning
- Usar Scikit-learn, el módulo más utilizado para Machine Learning
- Usar Plotly para hacer gráficos interactivos
- Aprender Numpy para el procesamiento numérico
- Aprender a usar Matplotlib para hacer gráficos con los datos
- Aprender Regresión Lineal para Machine Learning
- Aprender Regresión Logística para Machine Learning
- Aprender Random Forest para Machine Learning
- Aprender a contruir árboles de decisión para el aprendizaje de máquinas
Dejo link : https://www.udemy.com/course/curso-machine-learning/?fbclid=IwAR12pEVsdyfhcG-Aa35QOWFmgL2ATMhgEYPLF5WEACauP4a8G99RsVo9WMg
Kubernetes
De esta manera Kubernetes comenzó a tener cada vez más relevancia y su comunidad crecía rápidamente. Hoy en día, kubernetes es uno de los proyectos con más crecimiento en Github y se convirtió en una de las plataformas más utilizadas para orquestación de containers.
Kubernetes ofrece un conjunto de primitivas distribuidas y técnicas de encapsulamiento para la creación de aplicaciones automatizables. Kubernetes ofrece un entorno de administración centrado en contenedores. Kubernetes orquesta la infraestructura de cómputo, redes y almacenamiento para que las cargas de trabajo de los usuarios no tengan que hacerlo. Esto ofrece la simplicidad de las Plataformas como Servicio (PaaS) con la flexibilidad de la Infraestructura como Servicio (IaaS) y permite la portabilidad entre proveedores de infraestructura.
Por ahora eso es todo...
Dejo links:
https://kubernetes.io
https://cloud.google.com/kubernetes/
Libros de Java Code Geeks
Download IT Guides!
|
| ||||||
|
|
jueves, 20 de febrero de 2020
Guía de Raku en castellano
Para los novatos en Raku sería un punto de partida y puesta en marcha.
Y como todo buen tutorial comienza con un "Hola Mundo" :
say 'hola mundo';
que también puede escribirse como:
'hola mundo'.say;
Suscribirse a:
Entradas (Atom)
