Sin más les dejo el mail:
|
|
lunes, 13 de febrero de 2017
Ganar ventaja competitiva con MySQL
Me llego un mail por demás interesante sobre mysql. Oracle regala un paper que nos indica como hacer una diferencia comercial.
Sin más les dejo el mail:
Sin más les dejo el mail:
domingo, 12 de febrero de 2017
Como aprender smalltalk puede hacerte mejor desarrollador
Smalltalk es ampliamente percibido como un viejo lenguaje moribundo, una antigüedad de una época pasada. Nada mas lejos de la verdad.
Smalltalk sigue siendo muy relevante. Es un excelente lenguaje para la enseñanza de programación a personas que no tienen antecedentes técnicos. Es un lenguaje de prototipado superlativo para las startups. Es un lenguaje utilizado por las empresas grandes y pequeños en todo el mundo. Hay buenas razones para considerar el uso de Smalltalk moderno hoy en día, ya que ha cambiado mucho en los últimos años.
No es necesario que use Smalltalk en la producción, pero intente codificar algo en Smalltalk y va a ver cómo se siente. Debe sentirse familiar, porque la implementación de Smalltalk del paradigma orientado a objetos (OO) es tan excelente que ha influido en toda una generación de lenguajes OO, como Objective-C, Python, Ruby, CLOS, PHP 5, Perl 6, Erlang , Groovy, Scala, Dart, Swift, y así sucesivamente.
Al aprender Smalltalk, comprenderá cómo todas esas características útiles en los idiomas OO actuales llegaron a ser. Aprender Smalltalk también podría darle una gran ventaja en las habilidades de programación entre sus compañeros, y podría ser una gran herramienta para la enseñanza de la programación para los principiantes.
Que nos ha dejado smalltalk?
- Smalltalk introdujo el mundo en la máquina virtual de lenguaje (o VM), que permite que el software sea independiente de la plataforma. Esta es la misma tecnología que sustenta Java (JVM) y .NET, así como Android (Dalvik).
- Smalltalk también fue pionero en la compilación JIT (just-in-time), una técnica para mejorar drásticamente el rendimiento de software de bytecode como Java.
- Desde Smalltalk surgió el primer IDE moderno (entorno de desarrollo integrado), que incluía un editor de texto, un navegador de sistema o clase, un inspector de objetos o propiedades y un depurador. Esto llevó a los muchos IDE que los desarrolladores favorecen hoy en día, como Visual Studio, Xcode e IntelliJ IDEA. P
- Desde el principio, Smalltalk tenia clausuras, que son funciones de primera clase. En esencia, una clausura es una función que puede ser asignada a una variables. Esto puede ayudarle a escribir código mucho más compacto y legible. Las clausuras están encontrando su camino en muchos lenguajes, como Java, C # y PHP.
- Smalltalk fue el padre de la depuración como la conocemos.
- Smalltalk presentó MVC (Model-View-Controller) al mundo. MVC es un patrón de arquitectura de software para implementar interfaces de usuario. Es popular entre las aplicaciones GUI de escritorio y las aplicaciones web. En estos días, es la arquitectura que la mayoría de los desarrolladores web aprender primero.
- En gran medida, Smalltalk es responsable de darnos el desarrollo basado en pruebas (o TDD) y la programación extrema (o XP), que son ambos muy influyentes en las prácticas ágiles estándar actuales.
- Smalltalk fue pionera en el desarrollo de bases de objetos. El mejor ejemplo de un producto de base de objetos es GemStone / S, que se adapta perfectamente a sistemas distribuidos escalables, de alto rendimiento y multitotal.
- Smalltalk nos dio el primer navegador de refactorización. Por supuesto, refactorización de apoyo se puede encontrar en la mayoría de los IDEs de hoy.
- Smalltalk fue instrumento en el desarrollo de la interfaz gráfica de usuario (GUI) y la interfaz de usuario "lo que ves es lo que obtienes" (WYSIWYG).
Que más decir son varias razones.
Dejo link:
Machine Learning with Spark
Sin más dejo el link:
https://www.packtpub.com/packt/offers/free-learning/?utm_source=googlep-dp&utm_medium=social-dp&utm_campaign=FL-dp
jueves, 9 de febrero de 2017
lunes, 6 de febrero de 2017
Introducción a R
Dejo el link:
http://www.attuneww.com/publications/getting-started-with-r.html
domingo, 5 de febrero de 2017
devfreebooks
Queres libros de programación, frameworks, diseño, etc. libres y gratuitos? Bueno pasa por devfreebooks, un sitio muy recomendable donde podes encontrar libros de diferentes lenguajes como diferente tecnologías.
Sin más dejo el link: https://devfreebooks.github.io/
viernes, 3 de febrero de 2017
Un resumen de Scala for the Impatient, parte 8
Arrays de longitud fija
Si necesitamos usar un array de longitud fija, puede utilizar una estructura Array, veamos un ejemplo:
val nums = new Array[Int](10)
// Se crea un arreglo de 10 elementos de tipo entero inicializados en 0
val a = new Array[String](10)
// un arreglo de string inicializados en null
val s = Array("Hello", "World")
// Un arreglo de 2 strings
s(0) = "Goodbye"
// Array("Goodbye", "World")
// Se puede usar () en vez de []
Arreglos de longitud variable
Java tiene ArrayList y C++ el vector de la STL, equivalente en scala es el ArrayBuffer.
import scala.collection.mutable.ArrayBuffer
val b = ArrayBuffer[Int]()
// o new ArrayBuffer[Int]
// ahora tenemos un array de 0 elementos (vacio)
b += 1
// ArrayBuffer(1)
// Agregamos un elemento al final con +=
b += (1, 2, 3, 5)
// ArrayBuffer(1, 1, 2, 3, 5)
// agregamos multiples elementos al final con += y los elementos entre parentesis
b ++= Array(8, 13, 21)
// ArrayBuffer(1, 1, 2, 3, 5, 8, 13, 21)
// Se puede agregar colecciones con el operador ++=
b.trimEnd(5)
// ArrayBuffer(1, 1, 2)
// remueve los últimos 5 elementos del final
Se pueden insertar elementos en cualquier parte del vector con insert:
b.insert(2, 6)
// ArrayBuffer(1, 1, 6, 2)
// inserta en la posición 3 es decir en el índice 2 (recuerden que el índice comienza en 0)
b.insert(2, 7, 8, 9)
// ArrayBuffer(1, 1, 7, 8, 9, 6, 2)
// se pueden insertar multiples elementos
b.remove(2)
// ArrayBuffer(1, 1, 8, 9, 6, 2)
b.remove(2, 3)
// ArrayBuffer(1, 1, 2)
// El segundo parámetro nos indica cuantos elementos borrar.
En ciertas ocasiones debemos utilizar un array y no un ArrayBuffer por lo que podemos convertir estos tipos con las funciones toArray y toBuffer
En c++ y Java existen muchas diferencias entre la sintaxis de un array y una lista o vector dinámico, en scala esto es mucho más uniforme.
Por ejemplo aquí podemos ver como recorrer un Array o un ArrayBuffer:
for (i <- 0 until a.length)
println(i + ": " + a(i))
La variable i va ir desde 0 hasta a.length – 1
until es un método de RichInt que retorna el rango desde el elemento hasta el parámetro -1 (es decir sin incluir este elemento)
0 until 10
// Range(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
Podemos llamar a este método con 0.until(10)
Por lo tanto podemos deducir que el for trabaja de la siguiente manera:
for (i <- rango)
y por cada iteración i toma un valor del rango. until guarda más secretos, podemos hacer rangos con saltos:
0 until (a.length, 2)
// Range(0, 2, 4, ...)
o podemos hacer rangos y luego darlos vuelta:
(0 until a.length).reverse
// Range(..., 2, 1, 0)
Si no necesitamos índices para recorrer el arreglo, solo podemos asignar los elementos de la colección:
for (elem <- a)
println(elem)
Como se puede ver es similar a iterar con un rango.
Transformar un arreglo
Podemos transformar arreglos de forma similar que Java o C++ pero tenemos una herramienta mucho más simple. Podemos transformar los arreglos por comprensión:
val a = Array(2, 3, 5, 7, 11)
val result = for (elem <- a) yield 2 * elem
// result is Array(4, 6, 10, 14, 22
yield es una palabra reservada, este operador permite retornar otro arreglo con los elementos modificados según la operación que se aplique. En el ejemplo result contiene el arreglo resultado.
También podemos filtrar con el for y luego aplicar la transformación:
for (elem <- a if a % 2 == 0) yield 2 * elem
Esto no afecta la colección original.
Noten que también podríamos usar funciones de map que son más potentes:
a.filter(_ % 2 == 0).map(2 * _)
o también
a filter { _ % 2 == 0 } map { 2 * _ }
Algoritmos comunes
Similar a la STL de c++ o a las clases Collections y Arrays de java. Scala cuenta con métodos que nos permiten acumular o ordenar:
Array(1, 7, 2, 9).sum
// 19
// Esto también funciona con ArrayBuffer
Note que sum funciona para valores de tipo numéricos, que se pueden sumar. De igual manera min y max funciona para valores que se pueden comparar.
ArrayBuffer("Mary", "had", "a", "little", "lamb").max
// "little"
El método para ordenar retorna una colección ordenada, sin modificar la colección original:
val b = ArrayBuffer(1, 7, 2, 9)
val bSorted = b.sorted(_ < _)
// b is unchanged; bSorted is ArrayBuffer(1, 2, 7, 9)
Para los arreglos podemos utilizar mkString con el cual podemos hacer strings a partir de nuestros arreglos:
a.mkString(" and ")
// "1 and 2 and 7 and 9"
a.mkString("<", ",", ">")
// "<1,2,7,9>"
Arreglos multidimensionales.
Similar a Java, scala implementa arreglos multidimensionales como arreglos de arreglos. Por ejemplo:
val matrix = Array.ofDim[Double](3, 4)
y para acceder a los valores es necesario poner paracentesis con el índice de la fila y luego paréntesis con el índice de la columna.
matrix(row)(column) = 42
lunes, 30 de enero de 2017
Functional Programming vs. Imperative Programming en c#
El paradigma de programación funcional fue creado explícitamente para la resolución de problemas con enfoque matemático puro. La programación funcional es una forma de programación declarativa. En cambio, la mayoría de los lenguajes convencionales, incluidos los lenguajes de programación orientada a objetos (OOP) como C #, Visual Basic, C ++ y Java, fueron diseñados principalmente para soportar la programación imperativa (de procedimiento).
En la programación orientada a objetos tradicional (OOP), la mayoría de los desarrolladores están acostumbrados a la programación en el estilo imperativo / procedimental. Para cambiar al desarrollo en un estilo funcional puro, tienen que hacer una transición en su pensamiento y su acercamiento al desarrollo.
Para resolver problemas, los desarrolladores de OOP diseñan jerarquías de clases, se enfocan en la encapsulación apropiada y piensan en términos de contratos de clases. El comportamiento y el estado de los tipos de objetos son primordiales, y se proporcionan características del lenguaje, como clases, interfaces, herencia y polimorfismo, para abordar estas preocupaciones.
Por el contrario, la programación funcional aborda los problemas computacionales como un ejercicio de evaluación de las transformaciones funcionales puras de las colecciones de datos. La programación funcional evita los datos de estado y mutables, y en su lugar enfatiza la aplicación de funciones.
Afortunadamente, C # no requiere el salto completo a la programación funcional, ya que soporta los enfoques de programación tanto imperativos como funcionales. Un desarrollador puede elegir qué enfoque es el más apropiado para un escenario en particular. De hecho, los programas a menudo combinan ambos enfoques.
Dejo link:
https://msdn.microsoft.com/en-us/library/mt693186.aspx
sábado, 28 de enero de 2017
Que lenguaje de programación fue el que más popular en el 2016?
Según el índice TIOPE : Go!Si el lenguaje de google sigue creciendo y se lleva la distinción del lenguaje más popular.
La pagina de tiope dice lo siguiente (más o menos) :
TIOBE recompensa el lenguaje de programación que ha ganado la mayor popularidad en un año con el premio de lenguaje de programación del año. Sin prácticamente ninguna competencia Go ha ganado el premio para el año 2016. El lenguaje google Go ganó con un 2,16% en un año. Seguido de Dart (+ 0.95%) y Perl (+ 0.91%). Los principales impulsores del éxito de Go son su facilidad de aprendizaje y naturaleza pragmática. No se trata de conceptos teóricos como la herencia virtual y las mónadas, sino la experiencia práctica. Aparte de eso, Go incorpora soporte para la programación en paralelo. por lo que cada vez más clientes de nuestra empresa TIOBE están adoptando Go en un entorno industrial. Es un buen indicador.
Personalmente opino que no es bueno que un lenguaje triunfe solo por pragmático, claramente en los conceptos podemos desarrollarnos. Pero solo una opinion personal.
Bueno que más decir, felicitaciones Go!
Dejo link: http://www.tiobe.com/tiobe-index/?imm_mid=0ec6d0&cmp=em-prog-na-na-newsltr_20170121
sábado, 21 de enero de 2017
Scala by the pictures
Quiero compartir una pagina que esta muy buena, y se pueden ver buenas infografias de Scala.
Dejo link:
http://sciabarra.com/book/
martes, 17 de enero de 2017
Libro Aprendiendo Ruby on Rails 5 - Capítulo 6 disponible
Me llego este mail y lo comparto para todos los que quieran aprender Ruby:
| |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
|
domingo, 15 de enero de 2017
Que lenguajes de programación son usados por cada compañía?
Yo creo que esto ya lo publique, pero bueno, el publico se renueva.
Dejo el link: http://www.improgrammer.net/the-programming-language-used-by-the-company/
Un resumen de Scala for the Impatient, parte 7
Los procedimientos en Scala retornan el tipo Unit y tienen una especial notación sin el =
def box(s : String) { // Look carefully: no =
val border = "-" * s.length + "--\n"
println(border + "|" + s + "|\n" + border)
}
Algunas personas no les gusta esta notación por lo que eligen utilizar la misma que las funciones:
def box(s : String): Unit = {
...
}
Lazy Values
Cuando un valor es declarado como lazy el calculo de este valor se realiza cuando se necesita, no antes:
lazy val words = scala.io.Source.fromFile("/usr/share/dict/words").mkString
De esta manera, si words no es utilizado el archivo nunca se abrirá.
Lazy values es útil para retrasar declaraciones de inicialización costosas. También pueden solucionar otros problemas de inicialización, como las dependencias circulares. Además, son esenciales para desarrollar estructuras de datos perezosas como Streams.
val words = scala.io.Source.fromFile("/usr/share/dict/words").mkString
// Se evalúa en el momento que es definido
lazy val words = scala.io.Source.fromFile("/usr/share/dict/words").mkString
// Se evalúa en el momento que es usado
def words = scala.io.Source.fromFile("/usr/share/dict/words").mkString
// Se evalúa cada vez que es usado
Exceptions
Las excepciones funcionan igual que C++ o Java. Cuando se lanza una excepción, por ejemplo:
throw new IllegalArgumentException("x should not be negative")
Se anula la ejecución y el sistema de ejecución busca un manejador de excepciones que puede manejar la excepción IllegalArgumentException. Si esta es manejada se reanuda la ejecución donde es manejado, si no existe un manejador, el programa finaliza. Igual a java.
Como en Java, las excepciones que se lanzan deben ser una subclase de java.lang.Throwable. Sin embargo, a diferencia de Java, Scala no tiene excepciones "verificadas o chequeadas" es decir que nunca se debe declarar una función o un método que lanza una excepción.
Una expresión throw retornan el tipo especial Nothing. Esto es útil en las expresiones if / else. Si una rama tiene el tipo Nothing, el tipo de la expresión if / else es el tipo de la otra rama. Por ejemplo, considere:
if (x >= 0) { sqrt(x)
} else throw new IllegalArgumentException("x should not be negative")
Esta expresión retornara Double, dado que el else retorna Nothing.
La expresión try puede utilizar pattern matching:
try {
process(new URL("http://horstmann.com/fred-tiny.gif"))
} catch {
case _: MalformedURLException => println("Bad URL: " + url)
case ex: IOException => ex.printStackTrace()
}
Cuando no necesitamos las variables podemos utilizar el _ (guión bajo)
La instrucción try / finally le permite disponer de un recurso independientemente de que se haya producido o no una excepción. Por ejemplo:
var in = new URL("http://horstmann.com/fred.gif").openStream()
try {
process(in)
} finally {
in.close()
}
La cláusula finally se ejecuta independientemente de si la función de proceso lanza una excepción. La variable in siempre cerrara el recurso.
Este código es un poco sutil, y plantea varios problemas.
- ¿Qué pasa si el constructor de URL o el método openStream lanza una excepción? Entonces el bloque try nunca se ingresa, y tampoco es la cláusula finally. Por lo tanto nunca se inicializara.
- ¿Por qué no es val in = nueva URL (...). OpenStream () dentro del bloque try? Entonces el alcance de en no se extendería a la cláusula final.
- ¿Qué pasa si in.close () lanza una excepción? Entonces esa excepción es expulsada de la declaración, reemplazando cualquier anterior. (Esto es igual que en Java, y no es muy agradable.) Idealmente, la antigua excepción permanecería unida a la nueva.
Note que try / catch y try / finally tienen objetivos complementarios. La sentencia try / catch maneja las excepciones, y la sentencia try / finally toma alguna acción (normalmente cleanup) cuando no se maneja una excepción. Es posible combinarlas en una sola instrucción try / catch / finally:
try { ... } catch { ... } finally { ... }
miércoles, 11 de enero de 2017
Codeschool lanza un nuevo curso de PHP
Codeschool viene con todo y cada vez más amplia sus tecnologías, ahora nos ofrece un curso de PHP:
 |
|
|
Los Programadores Andan Diciendo
Me reí muchísimo con este grupo en facebook, por lo que lo comparto:
https://www.facebook.com/ProgramadoresAndanDiciendo/?pnref=story
https://www.facebook.com/ProgramadoresAndanDiciendo/?pnref=story
Suscribirse a:
Entradas (Atom)
