 |
|
|
jueves, 13 de octubre de 2016
Flexbox en un nuevo curso de code school
Code school nos regala un nuevo curso, esta ves sobre Flexbox.
lunes, 10 de octubre de 2016
A desarrollar con Smalltalk!! 4
Vamos a hacer más flexible nuestro Saludador, vamos a permitir saludar con cualquier saludo, por lo tanto vamos a agregar un atributo:
Este atributo necesitar métodos para acceder a estos atributos. Por lo tanto hacemos menú contextual en la clase, refactoring->class refactoring->generate accesor. Y con esto nos va a generar los métodos para acceder a la variable de instancia.
Ahora podemos cambiar el método "saludar" para que pueda utilizar el saludo:
saludar
^ saludo.
Ahora vamos a probar nuestra nueva clase:
s := Saludador new.
s saludo: 'Hola!!'.
s saludar.
Esto retornara 'Hola!!'
Vamos a hacer un metodo que pida un parámetro y salude al nombre pasado por parámetro :
saludarA: nombre
^ saludo , ' ' , nombre.
Ahora podemos saludar a Pepe !!
s := Saludador new.
s saludo: 'Hola!!'.
s saludarA: 'Pepe'.
Por este post hemos hecho demasiado.
domingo, 9 de octubre de 2016
Microsoft liberó la versión 2 de typescript
Para las gente que no sabe que es typescript: TypeScript es un lenguaje que corre sobre javascript; muy similar a javascript pero con la salvedad de que TypeScript es un lenguaje fuertemente tipado. Es decir esta librería nos da un sistema de tipado para el lenguaje Javascript, además nos da clases; para poder utilizar la orientación a objetos por medio de clases como estamos más acostumbrados, no por prototipado.
Poco he hablado de typescript, dado que realmente a mi gusto no me cierra que haya tantos frameworks que busquen agregar o modificar javascript. No quiero decir que javascript sea malo, pero tal vez estamos queriendo usar un lenguaje para algo que no fue hecho y por eso tenemos que agregarle tantas cosas.
Luego de mi pequeña opinión y de una introducción, vamos a lo que concierne este post. Microsoft libero la versión 2 de typescript. Que trae como novedad?
Declaración Simplificada del archivo de dependencias,
Tipos no nuleables
Modificadores de solo lectura.
El tema de los tipos no nulos me encanta veamos un ejemplo:
// Compiled with --strictNullChecks
let x: number;
let y: number | undefined;
let z: number | null | undefined;
x = 1; // Ok
y = 1; // Ok
z = 1; // Ok
x = undefined; // Error
y = undefined; // Ok
z = undefined; // Ok
x = null; // Error
y = null; // Error
z = null; // Ok
x = y; // Error
x = z; // Error
y = x; // Ok
y = z; // Error
z = x; // Ok
z = y; // Ok
Podemos declarar un método de la siguiente manera:
// Compiled with --strictNullChecks
function sum(a: number | null, b: number | null) {
return a + b; // Produces value of type number
}
Y el readonly en las propiedades tambien esta bueno, va un ejemplo:
class Person {
readonly name: string;
constructor(name: string) {
if (name.length < 1) {
throw new Error("Empty name!");
}
this.name = name;
}
}
// Error! 'name' is read-only.
new Person("Daniel").name = "Dan";
Creo que son muy buenas, mejoras.
Dejo link:
https://www.typescriptlang.org/docs/release-notes/typescript-2.0.html
viernes, 7 de octubre de 2016
Oracle MySQL Cloud Service
Me llego este mail de oracle, sobre un nuevo servicio de cloud para mysql:
|
|
miércoles, 5 de octubre de 2016
AWS SDK para Smalltalk
El AWS SDK para Pharo Smalltalk permite a los desarrolladores de Smalltalk trabajar fácilmente con Amazon Web Services y Amazon DynamoDB, S3, Elastic Transcoder. Puede empezar en cuestión de minutos a utilizar Metacello y FileTree.
Dejo link: https://github.com/newapplesho/aws-sdk-smalltalk
martes, 4 de octubre de 2016
Que es template en c++?
Template es como generic de java. En resumen.
Pero voy a explayarme un poco más pero solo un poco con un ejemplo. Supongamos que tenemos que hacer una lista de enteros, lo hacemos y listo. Pero inmediatamente necesitamos una lista de string y lo hacemos. Pero inmediatamente necesitamos una lista de double y creo que se va entendiendo la idea.
En los lenguajes de tipado estáticos, tenemos ese problema, por cada tipo debemos hacer una estructura de ese tipo particular. Y de este problema nace un concepto que se lo llama programación genérica. Es decir, la programación genérica nos permite programar estructuras sin definir un tipo determinado y esto nos permite generalizar.
Esto ayuda muchísimo a la reutilización y en c++ tenemos una librería estandar que nos provee estructuras genéricas. Pilas, colas, mapas, etc.
Veamos un ejemplo de un árbol b :
arbol.h
#ifndef ARBOL_H
#define ARBOL_H
template <class T>
//con template digo que mi clase va a ser una plantilla
class Arbol
{
private:
Arbol<T> * izq = 0;
Arbol<T> * der = 0;
T dato;
public:
Arbol(T dato);
void agregar(T otroDato);
void listarEnOrden();
};
#endif // ARBOL_H
arbol.cpp
#include "arbol.h"
#include <iostream>
using namespace std;
template <class T>
Arbol<T>::Arbol(T dato)
{
this->dato = dato;
}
template <class T>
void Arbol<T>::agregar(T otroDato){
if (this->dato > otroDato) {
if (this->izq != 0) {
this->izq->agregar(otroDato);
} else {
this->izq = new Arbol(otroDato);
}
} else {
if (this->der != 0) {
this->der->agregar(otroDato);
} else {
this->der = new Arbol(otroDato);
}
}
}
template <class T>
void Arbol<T>::listarEnOrden() {
if (this->izq != 0) {
this->izq->listarEnOrden();
}
cout << this->dato << " ";
if (this->der != 0) {
this->der->listarEnOrden();
}
}
Veamos como usar este árbol:
#include <iostream>
#include "arbol.cpp"
using namespace std;
int main()
{
Arbol<int> arbolEntero(5); // Como vemos le tengo que indicar el tipo donde estaba T
arbolEntero.agregar(3);
arbolEntero.agregar(2);
arbolEntero.agregar(6);
arbolEntero.agregar(7);
arbolEntero.listarEnOrden();
return 0;
}
Otro ejemplo un map:
map.h
#ifndef MAP_H
#define MAP_H
template <class K, class V>
class Map
{
private:
int count = 0;
K * keys;
V * values;
public:
Map();
void put(K key, V value);
V get(K key);
};
#endif // MAP_H
map.cpp:
#include "map.h"
template <class K, class V>
Map<K,V>::Map()
{
this->count = 0;
}
template <class K, class V>
void Map<K,V>::put(K key, V value){
K * auxKey = new K (count + 1);
K * auxValue = new V (count + 1);
for(int i = 0; i < count; i++){
auxKey[i]= this->keys[i];
auxValue[i] = this->values[i];
}
auxKey[count] = key;
auxValue[count] = value;
if (this->count > 0) {
delete this->keys;
delete this->values;
}
count++;
this->keys = auxKey;
this->values = auxValue;
}
template <class K, class V>
V Map<K,V>::get(K key){
int index = 0;
for(int i = 0; i < count; i++){
if (key == this->keys[i]) {
index = i;
}
}
return this->values[index];
}
Veamos como usar el map:
#include <iostream>
#include "map.cpp"
using namespace std;
int main()
{
Map<int,int> myMap = Map<int,int>();
myMap.put(1,2);
myMap.put(2,3);
myMap.put(4,5);
cout<< myMap.get(1) << " "<<myMap.get(2) << " "<< myMap.get(4);
return 0;
}
Dejo link: http://c.conclase.net/curso/?cap=040
jueves, 29 de septiembre de 2016
Codeschool nos trae un nuevo curso sobre Go!
Codeschool nos trae un nuevo curso, ahora sobre Go!
|
|
|
domingo, 25 de septiembre de 2016
A desarrollar con Smalltalk!! 3
Continuamos con nuestro ejemplo. Ahora vamos a crear una instancia de nuestra recién creada clase Saludador. Para evaluar algo de código, podemos utilizar otra herramienta que un ambiente Smalltalk nos brinda: El Playground.
El Playground (espacio de trabajo) es una ventana que nos permite ordenar el código que vamos evaluando de forma interactiva en nuestro ambiente.
El Playground es una herramienta conveniente, pero es importante resaltar que en Smalltalk se puede evaluar código en cualquier panel de texto y no sólo en los Playground.
Para abrir un Playground usaremos nuevamente el Menú y dentro la opción 'Playground' :
Luego escribimos un programa que instancie nuestra clase y que llame al método saludar. Y luego podemos presionar el botón de play:
Y nos saluda!!
Aprende Python con PyCharm Edu !!
PyCharm Edu, una herramienta gratuita y de código abierto para aprender a programar con Python. PyCharm Edu 3 es una edición educativa de PyCharm, el medio ambiente de desarrollo de la empresa JetBrains para Python.
Además del editor y del entorno de programación, PyCharm Edu tiene integradas lecciones interactivas para que podamos aprender python y las características del lenguaje y a las herramientas del entorno de programación (el IDE).
Dejo link: https://www.jetbrains.com/pycharm-edu/
A desarrollar con Smalltalk!! 2
Al crear una nueva categoría, esta se selecciona automáticamente y vemos en el panel inferior una plantilla (un template) para crear una clase nueva. Para crear una nueva clase tenemos que enviarle un mensaje a la superclase, para eso nos podemos valer de la plantilla que el Browser de Clases nos ofrece. Simplemente reemplazamos donde dice NameOfSubclass por el nombre de la clase que queremos crear.
Vamos a hacer una clase que salude, por lo tanto le vamos a llamar saludador:
Y Ya tenemos nuestra primera clase!!
Como la probamos? lo verán en el próximo post.
Vamos a hacer una clase que salude, por lo tanto le vamos a llamar saludador:
Y Ya tenemos nuestra primera clase!!
Como la probamos? lo verán en el próximo post.
jueves, 22 de septiembre de 2016
Elm el lenguaje funcional que compila a javascript
Elm es un lenguaje funcional que compila a JavaScript. Elm tiene un fuerte énfasis en la simplicidad, facilidad de uso y herramientas de calidad.
Les quiero compartir una muy buena guia para comenzar: https://guide.elm-lang.org/
miércoles, 21 de septiembre de 2016
Swift 3 fue liberado
Swift 3.0 ha sido liberado, escribe ingeniero de Apple, Ted Kremenek, y trae consigo una gran cantidad de cambios en el lenguaje y su biblioteca estándar.
Swift 3 es la primera versión principal de Swift, desde que es código abierto. Y con esta versión llegan grandes cambios.
Además esta versión trae un sistema de paquetes para Linux.
Dejo link: https://swift.org/blog/swift-3-0-released/
Ceylon 1.3.0 esta aquí!!
Ceylon 1.3.0 esta disponible para descargar! Si si si!
Ceylon 1.3.0 es un release muy importante con aproximadamente de 330 problemas solucionados. Este es el primer release que soporta desarrollo Android, tambien soporta lo paquetes Node Package Manager (npm).
Y trae muchas novedades, entre las que podemos nombrar:
- Soporte para IntellJ
- Soporte para eclipse
- Soporte para Android
- Soporte para el sistema de paquetes, npm
- Soporte para la creación de microservice con WildFly Swarm
- Full soporte para Java 8
- Y más!!
Dejo link: https://ceylon-lang.org/blog/2016/09/19/ceylon-1-3-0/
lunes, 19 de septiembre de 2016
Que es Abstract Data Types?
Haskell apoya la definición de tipos de datos abstractos a través del sistema de módulos. Los tipos paramentados se pueden ver como una especie de tipo abstracto, porque dejan algunas partes del tipo de datos no definido, o abstracto.
Veamos un ejemplo:
data Tree a = Nil
| Node { left :: Tree a,
value :: a,
right :: Tree a }
Este tipo es abstracto, ya que deja algunos aspectos de su estructura indefinida, que será asumida por el usuario del tipo de datos. Esta es una forma débil de tipo abstracto de datos.
Un usuario puede utilizar esta estructura con enteros:
three_number_tree :: Tree Integer
three_number_tree = Node (Node Nil 1 Nil) 2 (Node Nil 3 Nil)
Otro usuario diferente podría especificar un tipo diferente para ese parámetro. Esta flexibilidad es lo que permite este tipo que se utiliza en muchos contextos diferentes.
Por el contrario, un tipo de datos concreto es uno que no proporciona tal flexibilidad.
Un tipo abstracto de datos más tradicional oculta completamente la estructura interna, o representación, de los datos. El siguiente ejemplo ilustra esta forma más tradicional de tipo abstracto de datos.
Podemos implementar una pila polimórfico simple usando una lista sin tener que decir algo a los consumidores acerca de su funcionamiento interno. El módulo sólo exporta el constructor de tipos (pero no el constructor de datos) y las funciones:
module Stack (Stack, empty, isEmpty, push, top, pop) where
empty :: Stack a
isEmpty :: Stack a -> Bool
push :: a -> Stack a -> Stack a
top :: Stack a -> a
pop :: Stack a -> (a,Stack a)
newtype Stack a = StackImpl [a] -- opaque!
empty = StackImpl []
isEmpty (StackImpl s) = null s
push x (StackImpl s) = StackImpl (x:s)
top (StackImpl s) = head s
pop (StackImpl (s:ss)) = (s,StackImpl ss)
Si más tarde decide cambiar la pila de ejecución, la API no cambia. También puede estar seguro de que el usuario no puede modificar "sus" estructuras de datos dentro del tipo de datos abstracto.
Dejo link: https://wiki.haskell.org/Abstract_data_type
Suscribirse a:
Entradas (Atom)
