|
lunes, 16 de marzo de 2020
Que es SRE ?
Me llego un mail de O'Reilly sobre Site reliability engineering. Bien bien, no se bien que es Site reliability engineering pero básicamente es la ingeniería que permite escalar y tener un sitio accesible y confiable. Pero mejor me leo el libro para tener mejor idea :
domingo, 15 de marzo de 2020
HTML + javascript + Haskell = ELM, parte 5
Elm incluye Pattern Matching, Puede usarlo para simplificar algunas definiciones de funciones:
> first (head::tail) = head
<function> : List a -> a
> first [1, 2, 3]
1 : number
Se deberá cubrir todos los casos o se puede tener este error:
> first []
Error: Runtime error in module Repl (on line 23, column 22 to 26):
Non-exhaustive pattern match in case-expression.
Make sure your patterns cover every case!
Como head :: tail no coincide [], Elm no sabe qué hacer con esta expresión. Usar una coincidencia de patrón no exhaustiva es una de las pocas formas en que puede bloquear un lenguaje de la familia ML y es totalmente evitable.
Elm es un lenguaje curry como Haskell :
> add x y = x + y
<function> : number -> number -> number
Observe el tipo de datos de la función. Es posible que haya esperado una función que tome dos argumentos de tipo número y devuelva un tipo de número. Así es como funciona el curry. Elm puede aplicar parcialmente add, lo que significa que puede completar uno de los dos números, así:
> inc = (add 1)
<function> : number -> number
Acabamos de crear una nueva función parcialmente aplicada llamada inc. Esa nueva función aplica uno de los argumentos para agregar. Completamos x, pero no y, así que Elm básicamente está haciendo esto:
addX y = 1 + y
Curry significa cambiar las funciones de múltiples argumentos a una cadena de funciones que cada una toma un solo argumento. Ahora, podemos manejar el curry nosotros mismos. Recuerde, las funciones currificadas no pueden tomar más de un argumento a la vez:
> add x y = x + y
<function> : number -> number -> number
> add 2 1
3 : number
> (add 2) 1
3 : number
Además de curring, puedes usar funciones parcialmente aplicadas para crear algunos algoritmos geniales.
Elm infiere que vas a hacer aritmética con números. Elm usa el número de clase de tipo porque esa es la clase de tipo que admite el operador +. Sin embargo, no está limitado a enteros:
> add 1 2
3 : number
> add 1.0 2
3 : Float
> add 1.0 2.3
3.3 : Float
Y esto funciona porque Elm es polimórfico. Calcula el tipo más general que funcionará, en función de su uso de operadores. De hecho, puede ver el mismo comportamiento con el operador ++:
> concat x y = x ++ y
<function> : appendable -> appendable -> appendable
Elm asume que la función usa dos elementos anexables, como este:
> concat ["a", "b"] ["c", "d"]
["a","b","c","d"] : [String]
> concat "ab" "cd"
"abcd" : String
Eso es polimorfismo. Como es de esperar, también puede usar polimorfismo con puntos. Digamos que tengo un punto y quiero calcular la distancia al eje x. Eso es fácil de hacer:
> somePoint = {x=5, y=4}
{ x = 5, y = 4 } : {x : number, y : number'}
> xDist point = abs point.x
<function> : {a | x : number} -> number
> xDist somePoint
5 : number
La inferencia de tipos de Elm infiere que x e y son números dentro de un registro. Ahora, puedo pasarlo en cualquier punto:
> twoD = {x=5, y=4}
{ x = 5, y = 4 } : {x : number, y : number'}
> threeD = {x=5, y=4, z=3}
{ x = 5, y = 4, z = 3 } : {x : number, y : number', z : number''}
> xDist twoD
5 : number
> xDist threeD
5 : number
Alternativamente, podría usar la coincidencia de patrones, así:
> xDist {x} = abs x
<function> : { a | x : number } -> number
> xDist threeD
5 : number
Con Pattern Matching seleccionar el campo x, y el resto del ejemplo funciona de la misma manera. El punto es que los registros también son completamente polimórficos. A Elm no le importa que los registros que utilizamos sean del mismo tipo. Solo necesita el registro para tener un campo x. Estás viendo el poder de un sistema de tipos que hará todo lo posible para detectar problemas reales, pero que se saldrá del camino cuando no haya ninguno.
sábado, 14 de marzo de 2020
Apache Druid
Apache Druid es una base de datos analíticos en tiempo real de alto rendimiento.
La idea es vos conectas Apache Druid a un origen de datos por ejemplo Apache Kafka y con Druid pueden analizar la información en tiempo real. Me hace acordar a Presto.
Druid está diseñado para flujos de trabajo donde las consultas rápidas y la ingesta de datos realmente importan. Druid se destaca en la visibilidad instantánea de datos, consultas ad-hoc, análisis operacionales y manejo de alta concurrencia.
Druid puede transmitir datos de forma nativa desde buses de mensajes como Kafka, Amazon Kinesis y más, y cargar archivos por lotes desde data lakes como HDFS, Amazon S3 y más.
Druid ha sido comparado para superar en gran medida las soluciones heredadas para la ingestión de datos y las consultas de datos. La nueva arquitectura de Druid combina los mejores almacenes de datos, bases de datos de series de tiempo y sistemas de búsqueda.
Druid desbloquea nuevos tipos de consultas y flujos de trabajo para clickstream, APM, cadena de suministro, telemetría de red, marketing digital y muchas otras formas de datos basados en eventos. Druid está diseñado específicamente para consultas rápidas y ad-hoc sobre datos históricos y en tiempo real.
Druid se puede implementar en cualquier entorno * NIX en hardware básico, tanto en la nube como para instalaciones tradicionales. Implementar Druid es fácil: escalar hacia arriba y hacia abajo es tan simple como agregar y eliminar servicios de Druid.
Dejo link: https://druid.apache.org/
miércoles, 11 de marzo de 2020
Libro gratuito de Java code Geeks
Download IT Guides!
|
| ||||||
|
|
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/
Suscribirse a:
Entradas (Atom)
