Download Dev Guides!
|
| ||||||
|
|
sábado, 26 de enero de 2019
4 libros gratuitos de java code geeks!
domingo, 20 de enero de 2019
Que es Gradle?
Gradle es una herramienta de automatización de compilación de proyectos de tecnología java, es de código abierto centrado en la flexibilidad y el rendimiento. Los scripts de compilación de Gradle se escriben utilizando un DSL Groovy o Kotlin. Lea sobre las características de Gradle para aprender lo que es posible con Gradle.
Altamente personalizable: Gradle se modela de una manera que es personalizable y extensible de la manera más fundamental.
Rápido: Gradle completa las tareas rápidamente, reutilizando los resultados de ejecuciones anteriores, procesando solo las entradas que han cambiado y ejecutando tareas en paralelo.
Potente: Gradle es la herramienta de compilación oficial para Android y es compatible con muchos lenguajes y tecnologías populares.
Porque tendria que usar Gradle en vez de Maven algunas razones son: flexibilidad, rendimiento, experiencia de usuario y administración de dependencias. En cuanto a la performance
Aunque los IDE son importantes, un gran número de usuarios prefieren ejecutar operaciones de compilación a través de una interfaz de línea de comandos. Gradle proporciona un CLI moderno que tiene características de detección como "tareas de gradle", así como un mejor registro y finalización de la línea de comandos.
Finalmente, Gradle proporciona una interfaz de usuario basada en la web interactiva para depurar y optimizar construcciones: análisis de compilación. También se pueden alojar en las instalaciones para permitir a una organización recopilar el historial de compilación y hacer análisis de tendencias, comparar compilaciones para depurar o optimizar el tiempo de compilación.
Dejo link: https://gradle.org
jueves, 17 de enero de 2019
Propiedades y campos en Kotlin parte 2
Los campos no pueden ser declarados directamente en las clases de Kotlin. Sin embargo, cuando una propiedad necesita un campo de respaldo, Kotlin lo proporciona automáticamente. Se puede hacer referencia a este campo de respaldo en los accesores utilizando el identificador de campo:
var counter = 0 // Nota: el inicializador asigna el campo de respaldo directamente
valor ajustado) {
if (valor> = 0) campo = valor
}
El identificador de campo solo se puede utilizar en los accesores de la propiedad.
Se generará un campo de respaldo para una propiedad si utiliza la implementación predeterminada de al menos uno de los accesores, o si un descriptor de acceso personalizado lo hace referencia a través del identificador de campo.
Por ejemplo, en el siguiente caso no habrá ningún campo de respaldo:
val isEmpia: booleano
get () = this.size == 0
Si desea hacer algo que no se ajuste a este esquema de "campo de respaldo implícito", siempre puede recurrir a una propiedad de respaldo:
private var _table: Map<String, Int>? = null
public val table: Map<String, Int>
get() {
if (_table == null) {
_table = HashMap() // Type parameters are inferred
}
return _table ?: throw AssertionError("Set to null by another thread")
}
En todos los aspectos, esto es lo mismo que en Java, ya que el acceso a las propiedades privadas con captadores y configuradores predeterminados está optimizado para que no se introduzca la sobrecarga de llamadas a funciones.
Las propiedades cuyo valor se conoce en tiempo de compilación se pueden marcar como constantes de tiempo de compilación utilizando el modificador const. Tales propiedades deben cumplir los siguientes requisitos:
- Nivel superior, o miembro de una declaración de objeto o un objeto complementario.
- Inicializado con un valor de tipo String o un tipo primitivo
- Sin adjetivo personalizado
Tales propiedades pueden ser utilizadas en anotaciones:
const val SUBSYSTEM_DEPRECATED: String = "This subsystem is deprecated"
@Deprecated(SUBSYSTEM_DEPRECATED) fun foo() { ... }
Normalmente, las propiedades declaradas con un tipo no nulo deben inicializarse en el constructor. Sin embargo, bastante a menudo esto no es conveniente. Por ejemplo, las propiedades pueden inicializarse a través de la inyección de dependencia, o en el método de configuración de una prueba de unidad. En este caso, no puede proporcionar un inicializador que no sea nulo en el constructor, pero aún así desea evitar las comprobaciones nulas al hacer referencia a la propiedad dentro del cuerpo de una clase.
Para manejar este caso, puede marcar la propiedad con el modificador lateinit:
public class MyTest {
lateinit var subject: TestSubject
@SetUp fun setup() {
subject = TestSubject()
}
@Test fun test() {
subject.method() // dereference directly
}
}
El modificador se puede usar en las propiedades var declaradas dentro del cuerpo de una clase (no en el constructor principal, y solo cuando la propiedad no tiene un captador o definidor personalizado) y, desde Kotlin 1.2, para propiedades de nivel superior y variables locales . El tipo de propiedad o variable no debe ser nulo y no debe ser un tipo primitivo.
El acceso a una propiedad de inicio tardío antes de que se haya inicializado genera una excepción especial que identifica claramente la propiedad a la que se accede y el hecho de que no se ha inicializado.
Para verificar si ya se ha inicializado una var de lateinit, use .isInitialized en la referencia a esa propiedad:
if (foo::bar.isInitialized) {
println(foo.bar)
}
Esta verificación solo está disponible para las propiedades que son accesibles léxicamente, es decir, declaradas en el mismo tipo o en uno de los tipos externos, o en el nivel superior en el mismo archivo.
Propiedades y campos en Kotlin
class Address {
var name: String = ...
var street: String = ...
var city: String = ...
var state: String? = ...
var zip: String = ...
}
Para usar una propiedad, simplemente nos referimos a ella por su nombre, como si fuera un campo en Java:
fun copyAddress(address: Address): Address {
val result = Address() // there's no 'new' keyword in Kotlin
result.name = address.name // accessors are called
result.street = address.street
// ...
return result
}
La sintaxis completa para declarar una propiedad es
var <propertyName>[: <PropertyType>] [= <property_initializer>]
[<getter>]
[<setter>]
El inicializador, getter y setter son opcionales. El tipo de propiedad es opcional si se puede inferir del inicializador (o del tipo de devolución del captador, como se muestra a continuación).
Ejemplos:
var allByDefault: Int? // error: explicit initializer required, default getter and setter implied
var initialized = 1 // has type Int, default getter and setter
La sintaxis completa de una declaración de propiedad de solo lectura difiere de la mutable en dos formas: comienza con val en lugar de var y no permite un definidor:
val simple: Int? // has type Int, default getter, must be initialized in constructor
val inferredType = 1 // has type Int and a default getter
Podemos definir accesores personalizados para una propiedad. Si definimos un captador personalizado, se llamará cada vez que accedamos a la propiedad (esto nos permite implementar una propiedad computada). Aquí hay un ejemplo de un captador personalizado:
val isEmpty: Boolean
get() = this.size == 0
Si definimos un configurador personalizado, se llamará cada vez que asignemos un valor a la propiedad. Un setter personalizado se ve así:
var stringRepresentation: String
get() = this.toString()
set(value) {
setDataFromString(value) // parses the string and assigns values to other properties
}
Por convención, el nombre del parámetro de establecimiento es valor, pero puede elegir un nombre diferente si lo prefiere.
Desde Kotlin 1.1, puede omitir el tipo de propiedad si se puede deducir del captador:
val isEmpty get() = this.size == 0 // has type Boolean
Si necesita cambiar la visibilidad de un elemento de acceso o anotarlo, pero no necesita cambiar la implementación predeterminada, puede definir el elemento de acceso sin definir su cuerpo:
var setterVisibility: String = "abc"
private set // the setter is private and has the default implementation
var setterWithAnnotation: Any? = null
@Inject set // annotate the setter with Inject
Seguiremos en otro post, por lo pronto dejo link:
https://kotlinlang.org/docs/reference/properties.html
martes, 15 de enero de 2019
NoSQL Performance Benchmark 2018
Me llego esta mail de la gente de Couchbase :
Si está pensando en cambiar a una base de datos NoSQL, es importante pensar con anticipación. Una opción popular como MongoDB ™ podría funcionar ahora para sus aplicaciones NoSQL a pequeña escala. Pero cuando llega el momento de escalar, las cosas pueden complicarse muy rápidamente.
Lee el NoSQL Performance Benchmark 2018 de Altoros para descubrir cómo Couchbase:
- Supera constantemente a MongoDB ™ y DataStax
- Maneja fácilmente diferentes configuraciones y cargas de trabajo masivas
- Ofrece una agilidad, flexibilidad y rendimiento inigualables en cualquier escala
- Obtendrá un análisis en profundidad del rendimiento de Couchbase, MongoDB ™ y DataStax en 3 configuraciones de clúster diferentes y 4 cargas de trabajo diferentes utilizando el Yahoo Cloud Serving Benchmark.
Dejo link: https://resources.couchbase.com/c/altoros-nosql-performance-benchmark?x=N-I_ik&mkt_tok=eyJpIjoiTVROalpqQTBNRFV3WVdVdyIsInQiOiJRbWxoWGdEMUd3M1dCVW5EeVhTXC9ZbkkwMmRnb2xXWnNLd3g4cjVCM3JIbktVK0JScENpU2pXWVJONmNqRVBzWFVtbHh3YkRsNHZPOXgrNzd2NUZjWThtRHUxamVGK3ArU0d2SjdvMTdDSG54NHQ1YUhTVTNXeU94TlwvNmY4SlpXIn0%3D
domingo, 13 de enero de 2019
Ubuntu Budgie
Pero mi otro problema fue Ubuntu 18.10, con el cual tuve muchos problemas:
- Lo instale y tiraba un error todo el tiempo haciendo que el disco se llene rápidamente.
- No funciono samba.
- Se cuelga o congela cada tanto, no se si sera un problema de drivers o que.
En fin, mi conclusión es que le falta unos minutos de horno o horas. No esta 100% listo, pero voy a ser tester y lo voy a seguir usando. Si me canso creo que voy a elegir otra distro.
Cual me aconsejan?
miércoles, 9 de enero de 2019
Más eBooks de java code geeks
|
| ||||||
|
|
domingo, 6 de enero de 2019
Que es la Arquitectura hexagonal?
La arquitectura hexagonal es un estilo que habla sobre la organización en capas de una manera que aísla su lógica central de elementos externos.
La capa central es la de lógica del negocio, y los elementos externos son como puntos de integración, por ejemplo, DBs, APIs externas, UIs, y otros. Divide el software en las partes internas y externas. Las partes internas contienen la lógica empresarial principal y la capa de dominio. La parte exterior consta de IU, base de datos, mensajería y otras cosas. Las partes internas y externas se comunican entre sí mediante puertos y adaptadores.
Para resumir, la arquitectura hexagonal es un enfoque utilizado para dividir la aplicación en partes internas y externas. Están conectados a través de puertos (expuestos por el interior) y adaptadores (implementados por el exterior). Por lo tanto, al aplicar este enfoque, el código de caso de uso central permanece intacto y puede servir para múltiples canales, soportando diferentes protocolos. También ayuda a hacer la aplicación fácil de probar. Tampoco esta bien implementar todas las funcionalidades de esta manera deberíamos ser selectivos.
Si me permiten una opinion, no veo mayor innovación en esto, es un nombre bonito para un estilo arquitectónico que venimos utilizando hace tiempo.
Nuevos cursos de MongoDB University
Me llego el siguiente mail promocionando cursos de mongodb y la noticia de nuevos cursos:
 | |
|
sábado, 5 de enero de 2019
Las 10 mejores distros livianas para este año 2019
Leí este post y me resulto muy interesante hacer un post sobre distros linux livianas, no solo porque cuando desarrollamos necesitamos mucho hardware y una ditro liviana puede ser de gran ayuda, sino tambien porque esta buenisimo empezar con una distro liviana y básica y a medida que se va utilizando poder agregarle cosas. Terminas teniendo un sistema super personalizado y eficiente.
- Bodhi Linux
- Puppy Linux
- Linux Lite
- Ubuntu MATE
- Lubuntu
- Arch Linux + Lightweight Desktop environment
- LXLE
- Peppermint OS
- antiX
- Manjaro Linux Xfce Edition
Dejo link: https://maslinux.es/las-10-mejores-distros-livianas-para-este-ano-2019/
miércoles, 2 de enero de 2019
3 libros gratuitos de AWS Lambda, cybersecurity y React
|
lunes, 31 de diciembre de 2018
Minilibros gratuitos.
Quiero compartir estos 2 libros gratuitos de Java Code Geeks :
Download Minibooks!
|
|
jueves, 27 de diciembre de 2018
The Hundred-Page Machine Learning Book
Podemos bajarnos el libro "The Hundred-Page Machine Learning Book" la versión draf hasta que sea publicado.
Sin más dejo el link: http://themlbook.com/wiki/doku.php
lunes, 24 de diciembre de 2018
Feliz Navidad!!
Desde el blog queremos desearle una muy Feliz Navidad!!!
nano navidad.sh
#!/bin/bash
trap "tput reset; tput cnorm; exit" 2
clear
tput civis
lin=2
col=$(($(tput cols) / 2))
c=$((col-1))
est=$((c-2))
color=0
tput setaf 2; tput bold
# Tree
for ((i=1; i<20; i+=2))
{
tput cup $lin $col
for ((j=1; j<=i; j++))
{
echo -n \*
}
let lin++
let col--
}
tput sgr0; tput setaf 3
# Trunk
for ((i=1; i<=2; i++))
{
tput cup $((lin++)) $c
echo 'mWm'
}
new_year=$(date +'%Y')
let new_year++
tput setaf 1; tput bold
tput cup $lin $((c - 6)); echo FELICES FIESTAS
tput cup $((lin + 1)) $((c - 9)); echo Y mucho CODIGO en $new_year
let c++
k=1
# Lights and decorations
while true; do
for ((i=1; i<=35; i++)) {
# Turn off the lights
[ $k -gt 1 ] && {
tput setaf 2; tput bold
tput cup ${line[$[k-1]$i]} {column[$[k-1]$i]}; echo \*
unset line[$[k-1]$i]; unset column[$[k-1]$i] # Array cleanup
}
li=$((RANDOM % 9 + 3))
start=$((c-li+2))
co=$((RANDOM % (li-2) * 2 + 1 + start))
tput setaf $color; tput bold # Switch colors
tput cup $li $co
echo o
line[$k$i]=$li
column[$k$i]=$co
color=$(((color+1)%8))
# Flashing text
sh=1
for l in C O D I G O
do
tput cup $((lin+1)) $((c-3+sh))
echo $l
let sh++
sleep 0.01
done
}
k=$((k % 2 + 1))
done
Y ahora ejecutamos:
bash navidad.sh
Suscribirse a:
Entradas (Atom)
