Hablaremos sobre maquetación web utilizando las últimas novedades de HTML5, CSS3 y frameworks CSS.
El acceso es libre y gratuito.
Para presenciar el evento diríjase al siguiente link: Webinario Introducción al Frontend, ingresando con su nombre y apellido.
Te esperamos !!!
Los dos componentes principales de .NET Framework son Common Language Runtime y .NET Framework Class Library.
Common Language Runtime (CLR) es el motor de ejecución que maneja las aplicaciones en ejecución. Proporciona servicios como administración de subprocesos, recolección de basura, seguridad de tipos, manejo de excepciones y más.
La biblioteca de clases proporciona un conjunto de API y tipos para una funcionalidad común. Proporciona tipos de cadenas, fechas, números, etc. La biblioteca de clases incluye API para leer y escribir archivos, conectarse a bases de datos, dibujar y más.
Las aplicaciones .NET están escritas en lenguaje de programación C#, F# o Visual Basic. El código se compila en un Lenguaje Intermedio Común (CIL) independiente del lenguaje. El código compilado se almacena en ensamblados: archivos con una extensión de archivo .dll o .exe.
Cuando se ejecuta una aplicación, CLR toma el ensamblado y usa un compilador just in time (JIT) para convertirlo en código de máquina que se puede ejecutar en la arquitectura específica de la computadora en la que se está ejecutando.
Supongamos que queremos correr un proceso pero por un cierto tiempo, si demora más de ese tiempo debemos lanzar un error y si no retornar el valor.
Para esto podemos utilizar java.util.concurrent.Future.
En pocas palabras, la clase Future representa un resultado futuro de un cálculo asincrónico, un resultado que eventualmente aparecerá en el Future una vez que se complete el procesamiento.
Los métodos de ejecución prolongada son buenos candidatos para el procesamiento asincrónico y la interfaz Future. Esto nos permite ejecutar algún otro proceso mientras esperamos que se complete la tarea encapsulada en Future.
Algunos ejemplos de operaciones que aprovecharían la naturaleza asincrónica de Future son:
Ya hable de java 16, ahora vamos a ver una de sus mejoras: Records
El objetivo de los records es poder diseñar de forma rápida, tipos de datos compuestos inmutables. Esta característica no viene a remplazar nuestras queridas clases.
Antes de java 16 debíamos hacer una clase para representar un tipo de dato inmutable, por ejemplo Point :
class Point {
private final int x;
private final int y;
Point(int x, int y) {
this.x = x;
this.y = y;
}
int x() { return x; }
int y() { return y; }
public boolean equals(Object o) {
if (!(o instanceof Point)) return false;
Point other = (Point) o;
return other.x == x && other.y == y;
}
public int hashCode() {
return Objects.hash(x, y);
}
public String toString() {
return String.format("Point[x=%d, y=%d]", x, y);
}
}
Ahora podemos utilizar records :
record Point(int x, int y) { }
Por lo visto, mucho menos código; record nos ofrece metodos y constructores por defecto y por supuesto que podemos sobreescribirlos, un ejemplo sería :
record SmallPoint(int x, int y) {
public int x() { return this.x < 100 ? this.x : 100; }
public int y() { return this.y < 100 ? this.y : 100; }
}
Sin más dejo link: https://openjdk.java.net/jeps/395
Antes de esta característica hacíamos esto :
if (obj instanceof String) {
String s = (String) obj; // grr...
...
}
luego de java 16, podemos resolver el casteo de la siguiente manera :
if (obj instanceof String s) {
// Y aca usamos s como un string
...
}
Dejo link : https://openjdk.java.net/jeps/394
Retarde llegue con la noticia pero bueno, nobleza obliga, llego java 16. Ya a esta altura, de casualidad estoy usando java 11. Paren el tren!!! }
Más allá de mi experiencia personal de estos cambios de versiones, vamos a ver que nos trae Java 16.
A nivel de lenguaje lo más importante son Pattern Matching para instanceof y records (a mi entender).
Sin más dejo link: https://jdk.java.net/16/
Primero debemos instalarlo, utilizando una terminal con el siguiente comando:
dotnet tool install --global --version 1.10.0-beta1 Clojure.Main
Hoy estoy en powershell, sería algo así :
PS C:\dotnet> dotnet tool install --global --version 1.10.0-beta1 Clojure.Main
You can invoke the tool using the following command: Clojure.Main
Tool 'clojure.main' (version '1.10.0-beta1') was successfully installed.
Y luego, escribimos Clojure.Main en la terminal y podemos acceder al RELP :
PS C:\dotnet> Clojure.Main
Clojure 1.10.0-beta1
user=> (defn mayor [L]
(cond
(empty? (rest L)) (first L)
(> (first L) (mayor (rest L))) (first L)
:else (mayor (rest L))
)
)
#'user/mayor
user=> (mayor '(1 2 3 50 40))
50
Dejo link : https://github.com/clojure/clojure-clr
En dicha pagina podemos comenzar de 0 a programar software sencillo. Esta muy bueno, para empezar.
Dejo link: https://dotnet.microsoft.com/learn/dotnet/hello-world-tutorial/intro
Ya se encuentra disponible el formulario de inscripción a los cursos de extensión que dicta el Laboratorio de Investigación Gugler en modalidad semipresencial y a distancia.
Dejo el link para inscribirse : https://www.gugler.com.ar/
Esta pequeña expresión nos permite saber el mayor de una lista. Su funcionamiento es fácil, si la lista tiene un solo elemento, ese es el mayor y si la lista tiene varios elementos, bueno compara el primero con el mayor del resto de la lista, si es mayor, entonces es el mayor, sino retorna el mayor del resto de la lista.
Puff espero que se haya entendido...
Clojure provee manejo de excepciones como Java (try/catch/finally), veamos un ejemplo :
(try
(/ 2 1)
(catch ArithmeticException e
"divide by zero")
(finally
(println "cleanup")))
Tambien podemos lanzar excepciones:
(try
(throw (Exception. "something went wrong"))
(catch Exception e (.getMessage e)))
Clojure provee información extra con :
Veamos un ejemplo :
(try
(throw (ex-info "There was a problem" {:detail 42}))
(catch Exception e
(prn (:detail (ex-data e)))))
Clojure no es un lenguaje funcional puro, por lo tanto tiene funciones con efecto secundario. Vamos a ver algunas :
dotimes :
user=> (dotimes [i 3]
(println i))
0
1
2
nil
Muy parecido a un for, empieza de 0 y sigue hasta 3 - 1.
doseq :
user=> (doseq [n (range 3)]
(println n))
0
1
2
nil
Itera sobre una secuencia (evaluandola si es lazy). Tambien existe la variante que procesa todas las permutaciones del contenido de la secuencia, veamos un ejemplo :
user=> (doseq [letter [:a :b]
number (range 3)] ; list of 0, 1, 2
(prn [letter number]))
[:a 0]
[:a 1]
[:a 2]
[:b 0]
[:b 1]
[:b 2]
nil
for :
user=> (for [letter [:a :b]
number (range 3)] ; list of 0, 1, 2
[letter number])
([:a 0] [:a 1] [:a 2] [:b 0] [:b 1] [:b 2])
La función for se utiliza para generar listas, como listas por comprensión.
cond es una serie de condiciones y expresiones. Cada condición se evalúa en orden y la expresión se evalúa y devuelve el resultado de la primera expresión en que condición fue verdadera.
(let [x 5]
(cond
(< x 2) "x is less than 2"
(< x 10) "x is less than 10"))
Si no se cumple ninguna condición, se devuelve nil. Un modismo común es usar una condición final de :else. Las palabras clave (como :else) siempre se evalúan como verdaderas, por lo que siempre se seleccionará de forma predeterminada.
(let [x 11]
(cond
(< x 2) "x is less than 2"
(< x 10) "x is less than 10"
:else "x is greater than or equal to 10"))
case compara un argumento con una serie de valores para encontrar una coincidencia. ¡Esto se hace en tiempo constante (no lineal)! Sin embargo, cada valor debe ser un literal en tiempo de compilación (números, cadenas, palabras clave, etc.).
A diferencia de cond, case arrojará una excepción si ningún valor coincide.
user=> (defn foo [x]
(case x
5 "x is 5"
10 "x is 10"))
#'user/foo
user=> (foo 10)
x is 10
user=> (foo 11)
IllegalArgumentException No matching clause: 11
case puede tener una expresión final que se evaluará si ninguna prueba coincide.
user=> (defn foo [x]
(case x
5 "x is 5"
10 "x is 10"
"x isn't 5 or 10"))
#'user/foo
user=> (foo 11)
x isn't 5 or 10
|
|
| |||||
El PEP 634 nos muestra como va a ser el pattern matching en Python 3.10. Veamos el ejemplo que es super claro :
match subject:
case <pattern_1>:
<action_1>
case <pattern_2>:
<action_2>
case <pattern_3>:
<action_3>
case _:
<action_wildcard>
Muy parecido a scala pero en vez de => usa los 2 puntos.
Para que quede aun más claro veamos un ejemplo de uso:
def http_error(status):
match status:
case 400:
return "Bad request"
case 404:
return "Not found"
case 418:
return "I'm a teapot"
case _:
return "Something's wrong with the Internet"
y también se va a poder enumerar opciones con el | :
case 401 | 403 | 404:
return "Not allowed"
A la vez, igual que en scala se va poder hacer matching con el valor y estructura de los objetos :
# point is an (x, y) tuple
match point:
case (0, 0):
print("Origin")
case (0, y):
print(f"Y={y}")
case (x, 0):
print(f"X={x}")
case (x, y):
print(f"X={x}, Y={y}")
case _:
raise ValueError("Not a point")
Y como este matching más complejo podemos utilizar mejor el wildcard, etc... pero este post no trata de hablar de toda la potencia de esta nueva característica sino de trasnmitir la noticia.
Dejo link :
https://docs.python.org/3.10/whatsnew/3.10.html#pep-634-structural-pattern-matching
En Clojure, todos los valores son lógicamente verdaderos o falsos. Los únicos valores "falsos" son falsos y nulos; todos los demás valores son lógicamente verdaderos.
user=> (if true :truthy :falsey)
:truthy
user=> (if (Object.) :truthy :falsey) ; objects are true
:truthy
user=> (if [] :truthy :falsey) ; empty collections are true
:truthy
user=> (if 0 :truthy :falsey) ; zero is true
:truthy
user=> (if false :truthy :falsey)
:falsey
user=> (if nil :truthy :falsey)
:falsey
El if solo toma una sola expresión para el "entonces" y "si no". Si necesitamos más devemos utilizar el do para crear bloques más grandes que sean una sola expresión.
(if (even? 5)
(do (println "even")
true)
(do (println "odd")
false))
when es un if con solo una rama then. Verifica una condición y luego evalúa cualquier número de declaraciones como un cuerpo (por lo que no se requiere do). Y devuelve el valor de la última expresión. Si la condición es falsa, se devuelve nil.
(when (neg? x)
(throw (RuntimeException. (str "x must be positive: " x))))
Dejo link: https://assets.softwareag.com/spanish-ebooks
En Clojure, ¡todo es una expresión! Todo devuelve un valor y un bloque de varias expresiones devuelve el último valor. Las expresiones que realizan exclusivamente efectos secundarios devuelven cero.
Los operadores de control de flujo también se pueden ampliar a través de macros, que permiten ampliar el compilador mediante el código de usuario.
if es la expresión condicional más importante: consta de una condición, un "entonces" y un "más". if solo evaluará la rama seleccionada por el condicional.
user=> (str "2 is " (if (even? 2) "even" "odd"))
2 is even
user=> (if (true? false) "impossible!") ;; else is optional
nil
