Translate

martes, 20 de junio de 2017

Un resumen de Scala for the Impatient, parte 22


Extender una Clase. 

Se puede extender una clase con la palabra extends :
class Employee extends Person {
var salary = 0.0

}

Como en Java, en la subclase se pueden agregar atributos y métodos y sobre escribir métodos existentes de la super clases.

Igual que Java, se pueden marcar las clases como final y no van a poder ser extendidas pero en scala se agrega que un método o atributo pueden ser final.

Sobre escribir métodos. 

En scala se debe utilizar el modificador override cuando se sobre escribe un método y este no es abstracto. Por ejemplo:

public class Person {

override def toString = getClass.getName + "[name=" + name + "]"
}

El modificador override es muy útil para encontrar errores muy comunes como los siguientes:

  • Cuando se escribe mal el método que quiero sobre escribir
  • Cuando se agrega un parámetro de más o de menos, y no tiene la misma firma. 
  • Cuando se modifica el método padre en la super clase.


Si se desea llamar a un método del padre se hace igual que java se llama por medio de la palabra clave super.

public class Employee extends Person {

override def toString = super.toString + "[salary=" + salary + "]"
}

Al llamar a super.toString se esta llamando a el método toString de la clase Person.

Chequeo de tipos y casteos. 

El desarrollador puede saber si un objeto es de una clase determinada con el método isInstanceOf. Si esta clase es de un método determinado se puede castear utilizando asInstanceOf, veamos un ejemplo:

if (p.isInstanceOf[Employee]) {
val s = p.asInstanceOf[Employee] // s has type Employee

}

isInstanceOf retorna si un objeto es de una clase y  asInstanceOf hace el casteo.

Si p es null, isInstanceOf retorna false y asInstanceOf retorna null.

Si p no es un objeto Employee, asInstanceOf lanza una excepción.

Si es necesario saber que p es un empleado pero no una subclase de empleado lo hacemos de este modo:

if (p.getClass == classOf[Employee])

La función classOf esta definido en scala.Predef que siempre es importado.

A continuación se muestra una comparación con formas de chequeo de java:

Scala Java
obj.isInstanceOf[Cl]
obj instanceof Cl
obj.asInstanceOf[Cl]
(Cl) obj
classOf[Cl]
Cl.class

A la vez el pattern matching es útil para saber los tipos:

p match {
case s: Employee => ... // Hacer cosas con el empleado
case _ => ... // p no es un empleado
}

Atributos y métodos protegidos

Como en java o c++ en scala existe los atributos o métodos protegidos, que son los que puede ver la clase y sus descendientes y no por otras clases.

Pero al contrario de java estos atributos no son visibles para los objetos de su paquete.

Constructor de la super clase.

Como recordaran existe un constructor principal de la clase y pueden existir n constructores auxiliares y que todos los constructores auxiliares llaman al constructor principal.

Como consecuencia de esto un constructor auxiliar no puede invocar a un constructor auxiliar de la super clase directamente.

El constructor auxiliares de la subclase deben llamar al constructor principal de la subclase y solo el constructor principal puede llamar al constructor principal de la super clase.

El constructor principal está relacionado con la definición de clase. La llamada al constructor de la superclase está igualmente relacionado. Veamos un ejemplo:

class Employee(name: String, age: Int, val salary : Double) extends
Person(name, age)

y el primer constructor llama al constructor de la super clase.

Note que el código es sumamente conciso y  podemos pensar a nuestro constructor principal con la mayoría de los datos y los auxiliares al llamarlo pondrán valores por defecto.

Una clase Scala puede extender de una clase java. Por ejemplo:

class Square(x: Int, y: Int, width: Int) extends
java.awt.Rectangle(x, y, width, width)


Un resumen de Scala for the Impatient, parte 21


Los imports pueden estar en cualquier lado.

En scala los import pueden estar en cualquier lugar. No solo en el principio del archivo. Por ejemplo:

class Manager {
import scala.collection.mutable._
val subordinates = new ArrayBuffer[Employee]
}

Esto es muy útil, dado que reduce las posibilidades de conflicto.

Renombrar y ocultar miembros.

En scala se pueden importar algunos miembros de un paquete usando el selector:

import java.awt.{Color, Font}

La sintaxis del selector permite renombrar las clases :

import java.util.{HashMap => JavaHashMap}
import scala.collection.mutable._

Ahora JavaHashMap es java.util.HashMap y HashMap es scala.collection.mutable.HashMap

El selector => _ es útil para ocultar una implementación. Esto es útil en el caso particular de que se quiera dejar de usar una clase para utilizar otro por ejemplo dentro de una clase:

import java.util.{HashMap => _, _}
import scala.collection.mutable._

Ahora HashMap es scala.collection.mutable.HashMap dado que java.util.HashMap se oculto.

Imports implícito.

Cada programa de scala se importan de forma implícita los siguientes paquetes:

import java.lang._
import scala._
import Predef._

Como es un programa Java se importa todas las clases de java.lang y luego se importan las clases de scala que en cierto caso pisan alas de java. Por ejemplo scala.StringBuilder pisa a java.lang.StringBuilder.

Y por ultimo se importa el objeto Predef. Que es un objeto que contiene funciones útiles.

Como el paquete scala es importado por defecto no es necesario importarlo luego, por ejemplo:
collection.mutable.HashMap es scala.collection.mutable.HashMap pero no es necesario escribir el comienzo del paquete.



sábado, 17 de junio de 2017

Demuestra todo lo que sabes sobre la nube en el Azure Skills Challenge

Me llego el siguiente mail, me llamo la atención que es un juego, el cual sirve para publicitar  y enseñar Azure:

Azure Skills Challenge
Demuestra todo lo que sabes sobre la nube en el Azure Skills Challenge
Participa del juego que te ayuda a construir tu carrera profesional en la nube y tendrás la posibilidad de ganarte un voucher para un examen de certificación completamente GRATIS.
¿Aceptas el desafío?EMPIEZA A JUGAR AHORA
  

miércoles, 14 de junio de 2017

Programación Funcional en Erlang


Me acabo de anotar en un curso de programación funcional en erlang que se dicta de forma gratuita, por la pagina futurelearn y la universidad de Kent (superman?) 

Comienza el 19 de este mes. 

Dejo link : https://www.futurelearn.com/courses/functional-programming-erlang/
https://www.cs.kent.ac.uk/

martes, 13 de junio de 2017

EdX en español !!!

El sitio de cursos Edx me envío el siguiente correo:

Start learning on edX.org
 Los mejores cursos. Las mejores instituciones.
Aprende cuando quieras, donde quieras.
¡Ahora puedes experimentar el sitio web de edX en español! La página web edx.org/es ha mejorado para atender mejor a los estudiantes hispanohablantes, ahora es mucho más fácil la navegación en el sitio web y la búsqueda de cursos de las mejores universidades e instituciones a nivel mundial. 

Cómo funciona: Si tu navegador está en español, no necesitarás hacer nada para experimentar el sitio en tu idioma. En caso de que lo necesites, tienes la opción de cambiar la configuración del idioma en el seleccionador del lenguaje al final de la página en edx.org/es.

La página principal en idioma español y el sitio web tienen una variedad de cursos y programas, muchos enseñados en español y otros en inglés para beneficiarte de esta oferta única de instituciones de prestigio a nivel mundial. 

¡Visita el nuevo sitio web en español y comienza a aprender hoy mismo!

domingo, 11 de junio de 2017

Empezar con programación funcional en la plataforma Java

Como ustedes sabrán Java no es un lenguaje funcional y por más que le agreguemos clausuras, no deja de ser un lenguaje orientado objetos con clausuras. Y la plataforma java sigue esta premisa, por lo tanto podemos afirmar que es imposible la programación funcional pura en java, y esto es cierto. Pero tambien es cierto que se puede programar de modo funcional con un lenguaje funcional no puro.

Vamos desde el principio, que es la programación funcional? Si vemos la wikipedia :

"En ciencias de la computación, la programación funcional es un paradigma de programación declarativa basado en el uso de funciones matemáticas, en contraste con la programación imperativa, que enfatiza los cambios de estado mediante la mutación de variables. La programación funcional tiene sus raíces en el cálculo lambda, un sistema formal desarrollado en los años 1930 para investigar la definición de función, la aplicación de las funciones y la recursión. Muchos lenguajes de programación funcionales pueden ser vistos como elaboraciones del cálculo lambda.

En la práctica, la diferencia entre una función matemática y la noción de una "función" utilizada en la programación imperativa, es que las funciones imperativas pueden tener efectos secundarios, como cambiar el valor de cálculos realizados previamente. Por esta razón carecen de transparencia referencial, es decir, la misma expresión sintáctica puede resultar en valores diferentes en varios momentos de la ejecución del programa. Con código funcional, en contraste, el valor generado por una función depende exclusivamente de los argumentos alimentados a la función. Al eliminar los efectos secundarios se puede entender y predecir el comportamiento de un programa mucho más fácilmente. Ésta es una de las principales motivaciones para utilizar la programación funcional.

Los lenguajes de programación funcional, especialmente los puramente funcionales, han sido enfatizados en el ambiente académico y no tanto en el desarrollo comercial o industrial. Sin embargo, lenguajes de programación funcional como Scheme, Erlang, Rust, Objective Caml , Scala, F# y Haskell, han sido utilizados en aplicaciones comerciales e industriales por muchas organizaciones. La programación funcional también es utilizada en la industria a través de lenguajes de dominio específico como R (estadística), Mathematica (matemáticas simbólicas), J y K (análisis financiero)." https://es.wikipedia.org/wiki/Programaci%C3%B3n_funcional

Pero que mide la pureza de un lenguaje funcional? Un lenguaje funcional es puro respecto de la integridad referencial. No permite ningún efecto colateral. Probablemente, sea su característica más importante. Y volviendo a la plataforma java no podemos asegurar esto, porque esta plataforma nacio basada en un paradigma que mantiene estados. De igual manera existen lenguajes en la plataforma que nos permiten ser bastante puros como es el caso de los lenguajes basados en Haskell como Frege
y Jaskell.

Con respecto a los lenguajes la plataforma Java cuenta con varios lenguajes funcionales y con Java, si Java es un lenguaje de la plataforma Java y este como ya lo saben no es funcional. Es decir a partir de java 8 se pueden utilizar lambda, pero eso es solo una característica de la programación funcional, no hace a java funcional. De igual manera existen framework que suman azúcar sintáctico para programar en java de modo funcional :

Con respecto a los lenguajes, la plataforma java tiene varios lenguajes funcionales es su plataforma: 

Y esto es simplemente para nombrar algunos porque varios lenguajes tienen características funcionales y corren en la plataforma de java, como por ejemplo Kotlin o Ceylon. 

En conclusión java es una buena plataforma para programación funcional, si bien no se puede implementar la programación funcional pura a nivel de plataforma provee lenguajes muy puros como Frege o Jaskell. Lo que pasa es que tampoco es fácil hacer una plataforma multiparadigma en serio. Conocen una plataforma la cual pueda ejecutar lenguajes funcionales puros y orientados a objetos? 




viernes, 9 de junio de 2017

Masivo de correos, la forma más fácil y rápida de hacer de publicitar tu empresa


No es muy común esta clase de post en el blog pero tuve una respuesta positiva enviando mails masivos. Por lo que quiero compartir con ustedes mi experiencia.

Que es el Email marketing??  Se lo conoce como ciberbuzoneo  o en inglés: e-mailing es un método de marketing directo que utiliza el correo electrónico como medio de comunicación comercial para enviar mensajes a una audiencia. De esta forma podes tener al tanto a tus clientes de las novedades de tu empresa, nuevos productos, ofertas, etc...

Si buscamos email marketing en la wikipedia:

"La publicidad por correo electrónico, email marketing, marketing por email, correo comercial o email comercial,1 es enviar un mensaje comercial directamente utilizando como canal el correo electrónico. En su sentido más amplio, cada email que se envía a un cliente o potencial cliente puede ser considerado como email marketing. Normalmente implica utilizar un correo para enviar anuncios, peticiones de negocios, solicitar ventas o donaciones, y está principalmente orientado a crear lealtad, confianza, o concienciación de marca.

La publicidad por correo electrónico puede efectuarse a listas compradas o una base de datos de clientes actual. En términos generales, el término marketing por email es normalmente utilizado para referirse a enviar mensajes de email con el propósito de mejorar la relación de una empresa con sus clientes actuales o anteriores, para generar lealtad del cliente y empresarial, adquiriendo clientes nuevos o convenciendo clientes actuales para adquirir algo inmediatamente, y añadiendo los anuncios a mensajes de email enviados por otras compañías a sus clientes."

Pero preparar una campaña de envío masivo de correos no es algo que se deba hacer a la ligera, dado que podemos ser vistos como spammer. El spammer hacen referencia a los mensajes no solicitados, no deseados o con remitente no conocido (correo anónimo), habitualmente de tipo publicitario, generalmente son enviados en grandes cantidades (incluso masivas) que perjudican de alguna o varias maneras al receptor. Pero si lo que enviamos al usuario es información útil y cuidada el puede ver con buenos ojos estos correos.

Para evitar caer en la bandeja de spam de tus suscriptores es interesante que cumplas con los siguientes factores:

  • Trabaja siempre con una base de datos propia actualizada y segmentada. Muchas empresas envían sin problemas cada día cientos de miles de correos electrónicos en campañas de Email Marketing orientadas a convertir sus listas de registros en clientes.
  • Tus mensajes deben ser relevantes siempre. Si tienes alguna duda, revisa y analiza los contenidos tanto de texto como audiovisuales para garantizar que son realmente de interés para quien los va a recibir.
  • No olvides incluir un enlace de baja de la suscripción bien visible. No tiene sentido seguir enviando emails a usuarios que no quieren recibirlos. No sólo es un riesgo que corre tu empresa de ser calificada por dichos usuarios como spam sino que, lo que es peor, es una inversión sin justificación ni retorno. Si no quieren recibir tus emails mejor que se puedan dar de baja fácilmente. Piensa siempre en tus usuarios, si muchos se dan de baja reflexiona sobre los contenidos que ofreces y adáptalos a tu audiencia.

Por otro lado, debes contar con una herramienta profesional para realizar el envío masivo de correos. Aunque algunas de las aplicaciones de correo electrónico habituales pueden ser utilizadas para lanzar ciertos mensajes, a partir de un número determinado comienzan a pesar más sus desventajas.

Todas las plataformas profesionales diseñadas para enviar miles de correos a la vez respetan la legalidad, funcionan con proveedores de servicios de internet de calidad con el fin de asegurar que tus correos son enviados y te ofrecen unas estadísticas y un soporte que resolverá tus dudas y, sobretodo, te permitirá tomar las decisiones adecuadas para mejorar la eficacia de tus campañas de Email Marketing.

Como conclusión les aconsejo que vean con buenos ojos el envio de correos masivos dado que si se lo realiza correctamente es una excelente oportunidad para su empresa. 

Dejo link: https://es.wikipedia.org/wiki/Email_marketing

Cristal, rápido como C, amigable como Ruby


Cristal es un lenguaje similar a ruby que viene creciendo bastante, entre sus características podemos nombrar:

Sintaxis: La sintaxis de cristal es muy similar a la de ruby, lo que lo hace fácil de leer y de escribir.

Veamos un ejemplo:

# A very basic HTTP server
require "http/server"

server = HTTP::Server.new(8080) do |context|
  context.response.content_type = "text/plain"
  context.response.print "Hello world, got #{context.request.path}!"
end

puts "Listening on http://127.0.0.1:8080"
server.listen


Es un lenguaje compilado, lo que lo hace más rápido y con menos uso de memoria.

Chequeo de tipos, cristal es de tipado estático y hace chequeos de tipo en tiempo de compilación.

Chequeo de posibles errores por valores nulos. 

if rand(2) > 0
  my_string = "hello world"
end


puts my_string.upcase

y si compilamos:

$ crystal hello_world.cr
Error in hello_world.cr:5: undefined method 'upcase' for Nil (compile-time type is (String | Nil))

puts my_string.upcase
                        ^~~~~~

Macros, que permiten extender el lenguaje:

class Object
  def has_instance_var?(name) : Bool
    {{ @type.instance_vars.map &.name.stringify }}.includes? name
  end
end

person = Person.new "John", 30
person.has_instance_var?("name") #=> true
person.has_instance_var?("birthday") #=> false

y mucho más!!


Dejo link:
https://crystal-lang.org/

martes, 6 de junio de 2017

Empezando con Elixir 4

Pattern Matching

Pattern Matching es una parte importante y poderosa de elixir. Esto permite machear valores simples, estructura de datos e incluso funciones. Veamos como trabaja:

El operador Match
En elixir el operador = es un operador de macheo. Elixir espera que coincida los valores de la mano izquierda con los valores de la mano derecha. Si coinciden, devuelve el valor de la ecuación. De lo contrario, se produce un error. Vamos a ver un ejemplo:

iex> x = 1
1

Ahora vamos a probar el macheo:

iex> 1 = x
1
iex> 2 = x
** (MatchError) no match of right hand side value: 1

Ahora veamos ejemplos con varias estructuras:

# Lists
iex> list = [1, 2, 3]
iex> [1, 2, 3] = list
[1, 2, 3]
iex> [] = list
** (MatchError) no match of right hand side value: [1, 2, 3]

iex> [1 | tail] = list
[1, 2, 3]
iex> tail
[2, 3]
iex> [2 | _] = list
** (MatchError) no match of right hand side value: [1, 2, 3]

# Tuples
iex> {:ok, value} = {:ok, "Successful!"}
{:ok, "Successful!"}
iex> value
"Successful!"
iex> {:ok, value} = {:error}
** (MatchError) no match of right hand side value: {:error}

Operador Pin

El operador de = realiza la asignación cuando el lado izquierdo de la coincidencia incluye una variable. En algunos casos, este comportamiento no es deseable. Para estas situaciones tenemos el operador pin: ^.

Veamos un ejemplo:

iex> x = 1
1
iex> ^x = 2
** (MatchError) no match of right hand side value: 2
iex> {x, ^x} = {2, 1}
{2, 1}
iex> x
2


iex> key = "hello"
"hello"
iex> %{^key => value} = %{"hello" => "world"}
%{"hello" => "world"}
iex> value
"world"
iex> %{^key => value} = %{:hello => "world"}
** (MatchError) no match of right hand side value: %{hello: "world"}

En Elixir 1.2 se agrega soporte para que el pin funcione en mapas o funciones.

iex> key = "hello"
"hello"
iex> %{^key => value} = %{"hello" => "world"}
%{"hello" => "world"}
iex> value
"world"
iex> %{^key => value} = %{:hello => "world"}
** (MatchError) no match of right hand side value: %{hello: "world"}

Veamos un ejemplo con funciones:

iex> greeting = "Hello"
"Hello"
iex> greet = fn
...>   (^greeting, name) -> "Hi #{name}"
...>   (greeting, name) -> "#{greeting}, #{name}"
...> end
#Function<12.54118792/2 in :erl_eval.expr/5>
iex> greet.("Hello", "Sean")
"Hi Sean"
iex> greet.("Mornin'", "Sean")
"Mornin', Sean"

Dejo link: https://elixirschool.com/lessons/basics/pattern-matching/

domingo, 4 de junio de 2017

9 lenguajes que deberías aprender en el 2017


Muy pocas veces me encuentro con un articulo que dice que debemos aprender algo y coincido, normalmente son tecnologías ya consolidadas pero esta vez me encontré con un articulo que no le importo hacer futurología y tiro algunos nombres de lenguajes que son poco comunes en estas listas.

Los lenguajes que debemos aprender son:

  • Kotlin: como era de esperar, todo el mundo habla de él luego de convertirse en el lenguaje soportado por Android. 
  • Elm: Lenguaje funcional por demás interesante, permite compilar a html y javascript.
  • Julia: Similar a python pero dedicado a la ciencia. 
  • Elixir: Lenguaje funcional que hemos hablado ciento de veces en el blog.
  • Rust: Lenguaje de propósito general, que se parece mucho a C++
  • Crystal: Este si no lo conocía, se viene un post en breve. 
  • Groovy: En serio? yo creía que venia bajando su popularidad y de repente aparece en esta lista. 
  • R: Si haces algo con estadísticas debes conocer a R, es un lenguaje funcional dedicado a la estadísticas, que cada vez adquiere más adeptos. 
  • Go: El lenguaje de google viene lento pero seguro ganando mercado. 

Entre las cosas que me llamaron la atención puedo nombrar:

  • El 90% de los lenguajes nombrados tienen al menos un post en el blog! (tengo que hacer algo de publicidad)
  • Podríamos decir que la mitad o más son lenguajes funcionales, o que aplican técnicas de programación funcional, Entonces, a aprender funcional, no?


Por lo tanto decidí compartir este articulo:
http://www.rankred.com/new-programming-languages-to-learn/


Un resumen de Scala for the Impatient, parte 20


Encadenado de paquetes

La definición de paquetes puede tener nombres encadenados por punto, por ejemplo:

package com.horstmann.impatient {
   package people {
     class Person
     …
  }
}

Notación Top-of-File

Similar a java podemos optar por notación al principio de la clase, este paquete va a finalizar en el final del archivo. Por ejemplo:

package com.horstmann.impatient
package people
class Person


Esto es similar a :

package com.horstmann.impatient {
package people {
class Person
...
// Until the end of the file
}
}

Esta notación es útil cuando tenemos un solo paquete para todo un archivo.

Objetos paquete

Un paquete puede contener object, class o traits pero no una definición de funciones o variables por limitaciones en la maquina virtual java. Pero se puede definir un objeto paquete, este objeto contendrá variables o funciones globales en el paquete.

Veamos un ejemplo:

package com.horstmann.impatient
package object people {
val defaultName = "John Q. Public"
}
package people {
class Person {
var name = defaultName // A constant from the package
}
...
}

Note que defaultName no es necesario dado que se encuentra en un objeto con el mismo nombre del paquete, y podemos acceder a los valores desde otro paquete con el siguiente nombre: com.horstmann.impatient.people.defaultName

Es buena idea crear usar el mismo esquema de paquetes que los directorios de los archivos fuente. Y podemos poner un archivo package.scala donde van a estar los objetos de paquete, para tener una convención.

Visibilidad de paquetes. 

En java si una clase no es declarada como publica, privada o protected, es default y solo puede ser vista en el paquete. En scala existen calificadores que nos permiten hacer esto y tener mayor control de la visibilidad:

package com.horstmann.impatient.people
class Person {
private[people] def description = "A person with name " + name
...
}

Y se puede extender la visibilidad a paquetes padres:

private[impatient] def description = "A person with name " + name

Imports

Podemos importar una clase particular, para no utilizar el nombre largo:

import java.awt.Color

o podemos importar todos los elementos de un paquete de la siguiente manera:

import java.awt._

Como podemos ver es similar al * de java. También se pueden importar todos los miembros de una clase o objeto:

import java.awt.Color._
val c1 = RED // Color.RED
val c2 = decode("#ff0000") // Color.decode

Esto es similar a static import de java.

Importado todo un paquete podemos acceder a los objetos o clases de los subpaquetes con el nombre del subpaquete + el nombre de la clase o objeto:

import java.awt._
def handler(evt: event.ActionEvent) { // java.awt.event.ActionEvent
...
}

Como dice el comentario estamos usando  java.awt.event.ActionEvent cuando nombramos  event.ActionEvent porque  java.awt fue importado en su totalidad.

sábado, 3 de junio de 2017

Realm. un sitio donde publican buenos cursos.



Quiero compartir este sitio, donde publican buenos cursos que son bastantes teóricos.

Hay de todos los temas, pero los temas más importantes:

  • Android  
  • Apple  
  • Javascript  
  • Xamarin  
  • Architecture

Y encontré muy buenos cursos sobre programación funcional.

Dejo link: http://news.realm.io/news

martes, 30 de mayo de 2017

Plasma, simple por defecto, potente cuando se necesita

Tenemos el anunció de Plasma 5.10 y hago este post porque me sorprendió, muy bonito y funcional.

En el siguiente video se ven muchas novedades, vamos q tener que instalarlo y usarlo!!



domingo, 28 de mayo de 2017

Un resumen de Scala for the Impatient, parte 19


Paquetes

Los paquetes en Scala son similares a lo propuesto en java o en los espacios de nombre de C++, esto es un mecanismo para el manejo de nombres, por ejemplo el nombre Map puede referirse a una estructura de datos mapa o diccionario de datos del paquete scala.collection.immutable y scala.collection.mutable sin que haya conflicto. Uno puede acceder a esta clase por medio de su nombre, scala.collection.immutable.Map o scala.collection.mutable.Map. Alternativamente podemos utilizar alias.

Para agregar algo a un paquete  

package com {
package horstmann {
package impatient {
class Employee

}
}
}

Ahora la clase Employee es accesible desde el paquete com.horstmann.impatient.

A diferencia de las clases u objetos, los paquetes pueden ser definidos en multiples archivos. Por ejemplo si decidimos agregar la clase Manager al paquete anterior:

package com {
package horstmann {
package impatient {
class Manager

}
}
}
 
Notemos que no existe una relación entre el directorio que contiene a la clase y el sistema de paquetes.

package com {
package horstmann {
package impatient {
class Employee

}
}
}

package com {
package bigjava {
class Counter

}
}
}

Reglas de Alcance

En Scala, las reglas de ámbito para los paquetes son más consistentes que en Java. Los paquetes de Scala anidan como todos los demás ámbitos, es decir se puede acceder a los nombres del ámbito de que están incluidos en ese ambito. Por ejemplo,

package com {
package horstmann {
object Utils {
def percentOf(value: Double, rate: Double) = value * rate / 100
...
}
package impatient {
class Employee {
...
def giveRaise(rate: scala.Double) {
salary += Utils.percentOf(salary, rate)
}
}
}
}
}

Como se puede ver Utils puede ser accedido por Employee porque esta en el ambito.

package com {
package horstmann {
package impatient {
class Manager {
val subordinates = new collection.mutable.ArrayBuffer[Employee]
...
}
}
}
}

Este código aprovecha el hecho de que el paquete scala siempre se importa. Por lo tanto, el paquete es en realidad scala.collection.

Y ahora supongamos que alguien crea el siguiente paquete, tal vez en un archivo diferente:

package com {
package horstmann {
package collection {
...
}
}
}

Ahora la clase Manager ya no compila. Dado que busca un miembro mutable dentro del paquete com.horstmann.collection y no lo encuentra.

En Java, este problema no puede ocurrir porque los nombres de los paquetes son siempre absolutos, comenzando en la raíz de la jerarquía del paquete. Pero en Scala, los nombres de los paquetes son relativos, al igual que los nombres de las clases internas. Con las clases internas, uno no suele tener problemas porque todo el código está en un archivo, bajo el control de quien está a cargo de ese archivo. Pero los paquetes son estructuras abiertas. Cualquier persona puede contribuir a un paquete en cualquier momento.

Una solución es utilizar nombres de paquetes absolutos, empezando por _root_, por ejemplo:

val subordinates = new _root_.scala.collection.mutable.ArrayBuffer[Employee]

Otro enfoque es usar cláusulas de paquete "encadenadas".

Un resumen de Scala for the Impatient, parte 18


Enumeraciones

Al contrario de java o c++, Scala no cuenta con enumeraciones. Pero la librería estándar de scala cuenta con una clase Enumeration, que nos ayudara a trabajar con enumeraciones.

Lo que tenemos que hacer es un objeto que extienda de la clase Enumeration:

object TrafficLightColor extends Enumeration {
  val Red, Yellow, Green = Value
}

Este objeto tiene 3 propiedades Red, Yellow, Green inicializadas como valor. Alternativamente se le puede pasar al valor un id y un nombre o las dos cosas:

val Red = Value(0, "Stop")
val Yellow = Value(10) // Name "Yellow"
val Green = Value("Go") // ID 11

Si no se especifica el id, se asignara uno más del asignado previamente y por defecto el nombre es el nombre del campo.

Ahora usted se puede referirse a la enumeración TrafficLightColor como TrafficLightColor.Red, TrafficLightColor.Yellow, TrafficLightColor.Green. Si esto resulta tedioso, puede importar la clase:

import TrafficLightColor._

Hay que recordar que los valores Red, Green y Yellow son de tipo Value, no TrafficLightColor, si se  quiere se puede definir un alias:

object TrafficLightColor extends Enumeration {
type TrafficLightColor = Value
val Red, Yellow, Green = Value
}

Ahora el tipo TrafficLightColor.TrafficLightColor, se va importar y podremos usarlo:

import TrafficLightColor._

def doWhat(color: TrafficLightColor) = {
if (color == Red) "stop"
else if (color == Yellow) "hurry up"
else "go"
}

El id es el valor retornado cuando se llama a la enumeración y el nombre es lo que se llama cuando se llama al método toString

Si llamamos a TrafficLightColor.values podremos obtener todos los valores:

for (c <- TrafficLightColor.values) println(c.id + ": " + c)

Para terminar, podemos buscar un valor por id o nombre, si deseamos buscar el valor Red :
TrafficLightColor(0) // Calls Enumeration.apply
TrafficLightColor.withName("Red")