Quiero hacer ágil, ¿y ahora qué: Java, Ruby o Scala?

Quiero hacer ágil, ¿ y ahora qué: Java, Ruby o Scala ? Leo Antoli @lantoli Conferencia Agile-Spain 2011 - Castellón

Antes de empezar
Hacer ágil o ser ágil, esa es la cuestión
¿ Se puede Cobol ágil o Ruby sin tests y en cascada ?
¿ Se puede ser ágil con Java ?
El lenguaje es muy importante... pero es sólo una herramienta
¿ Por qué Java, Scala y Ruby ?
¿ Cuáles son las buenas prácticas técnicas (aplicables a ágil y cascada ?
¿ Se pueden usar nuevos lenguajes en tus desarrollos actuales ?

Fuera de la sesión
Lenguajes en cliente
Frameworks
Sólo se tratan algunos lenguajes

Un lenguaje para dominarlos a todos

Popularidad
1 - Java
2 - C
3 - C++
4 - C#
5 - PHP
6 - Objective-C
7 - Visual Basic
8 - Python
9 - Perl
10 - Javascript 11 - Ruby 25 - COBOL 27 - Scheme (LISP) 30 - Fortran 35 - Haskell 40 - Prolog 50 - Scala >51 Groovy

Popularidad
Google Code Jam 2011

Causa/efecto o correlación

Sopa de letras

Diseño simple, arquitectura
- Pasa todas las pruebas (hace lo que tiene que hacer, pero no más) - Minimiza las duplicaciones (si quiero cambiar el comportamiento lo hago en un solo sitio) - Maximiza la claridad (expresa bien las intenciones, es fácil de entender) - Es conciso (usa el menor número de clases y métodos, cumpliendo las otras reglas)
Estos mandamientos se resumen en dos:
- Quitar duplicación de código
- Mejorar los nombres mal puestos
Arquitectura: El conjunto de decisiones de diseño significativas (costosas de cambiar)

Entrega continua de valor: ¿ sólo con pruebas automáticas ?

¿ TDD/BDD obligatorio ? ... Anda antes de correr

Dinámico o Estático
- Estáticos tienen problemas, muchas redundancias y son menos legibles que los dinámicos
- La solución son los dinámicos o hay algo entre medias ?

Conciso o verboso
...
public class StringCalculator {
public int add ( String inputStr ) {
String firstLine = getLineDelimiters ( inputStr );
String textWithNumbers = getStringWithoutDelimiterLine ( inputStr );
List < String > delimiters = getDelimiters ( firstLine );
List < Integer > numbers = getAllowedNumbers ( getNumbers ( textWithNumbers, delimiters ));
checkNegativeNumbers ( numbers );
return getSum ( numbers );
}
...
private static int getSum ( List < Integer > numbers ) { SUMA LOS ELEMENTOS DE UNA LISTA
int sum = 0 ;
for ( int num : numbers ) {
sum += num ;
}
return sum ;
}
private static void checkNegativeNumbers ( List < Integer > numbers) throws IllegalArgumentException {
List < Integer > negatives = new ArrayList < Integer >(); DECLARAR VARIABLE
for ( int num : numbers ) { LISTA NUMEROS NEGATIVOS
if ( num < 0 ) {
negatives . add ( num );
}
}
if ( negatives . size () > 0 ) {
throw new IllegalArgumentException ( "no se permiten negativos: " + negatives . toString ());
}
}
...
121 líneas

Conciso o verboso
class Integer
def negative?
self < 0
end
def suitable_for_string_calculator?
self <= 1000
end
end

class Calculator
def add (args)
strnumbers, delimiter = extract_strnumbers_and_delimiter args
numbers = get_number_list strnumbers, delimiter
get_only_suitable_numbers numbers
check_negatives_numbers numbers
numbers . inject 0 , :+ SUMA LOS ELEMENTOS DE UNA LISTA
end
def get_number_list (numbers_str, delimiter)
numbers_str . split(delimiter) . collect { | num | num . to_i }
end
def get_only_suitable_numbers (numbers)
numbers . select! & :suitable_for_string_calculator?
end
def check_negatives_numbers (numbers)
negatives = numbers . select & :negative? LISTA NUMEROS NEGATIVOS
raise "negatives not allowed (#{ negatives . join( ', ' ) })" if negatives . any? IF AL FINAL
end
def extract_strnumbers_and_delimiter (args)
delimiters = /[n,]/
text = args . dup
first_line = text . slice!( %r{^//(.+)n} )
delimiters = first_line . scan( %r{[([^]]+)]} ) . flatten << delimiters if first_line
return text, Regexp . union(delimiters)
end
end
43 líneas

Conciso o verboso
...
@Test
public void testAddEmpty () throws Exception {
assertEquals ( "adding empty string" , 0 , calc . add ( "" ));
}
@Test
public void testSingleElement () throws Exception {
assertEquals ( "adding simple element" , 1 , calc . add ( "1" ));
assertEquals ( "adding more simple elements" , 345 , calc . add ( "345" ));
}
@Test
public void testTwoElementsSum () throws Exception {
assertEquals ( "adding two elements" , 3 , calc . add ( "1,2" ));
assertEquals ( "adding two more elements" , 201 , calc . add ( "123,78" ));
}
@Test
public void testNewLineDelimitier () throws Exception {
assertEquals ( "adding with different delimiter" , 6 , calc . add ( "1n2,3" ));
}
PROBANDO EXCEPCIONES
@Test
public void testNegativesThrowsException () throws Exception {
try {
calc . add ( "6,-8,3,-52" );
fail ( "testing negative numbers, shouldn't be here" );
} catch ( Exception e ) {
String msg = e . getMessage ();
assertTrue ( "contains negative sentence" ,
msg . contains ( "no se permiten negativos" ));
assertTrue ( "contains negative number" , msg . contains ( "-8" ));
assertTrue ( "contains negative number" , msg . contains ( "-52" ));
}
}
...

Conciso o verboso
describe "String calculator" do
before do
@calculator = Calculator . new
end
it "empty should be 0" do
@calculator . add( "" ) . should == 0
end
PROBANDO VARIOS CASOS CON HASHTABLE
{ "" => 0 , "1" => 1 , "345" => 345 , "1,1" => 2 , "3,4" => 7 , "1,1,1" => 3 ,
"1,2,3" => 6 , "5n2n3" => 10 , "123,78" => 201 } . each do | numbers, result |
it "adding #{ numbers } should be #{ result }" do
@calculator . add(numbers) . should == result
end
end
it "delimiter , and n should work" do
@calculator . add( "1n2,3" ) . should == 6
end
it "different delimiters specified in first line should work" do
@calculator . add( "//[%]n2%6" ) . should == 8
@calculator . add( "//[;]n1;2" ) . should == 3
@calculator . add( "//[+]n8+12,43" ) . should == 63
end
it "doesn't allow negative numbers" do PROBANDO EXCEPCIONES
expect { @calculator . add( "1n-2n-3n4" ) } . to raise_error( Exception , "negatives not allowed (-2, -3)" )
end
it "big numbers should be ignored" do
@calculator . add( "2,1001" ) . should == 2
@calculator . add( "2,1000" ) . should == 1002
end
...

Conciso o verboso
...
ROMANS = { M: 1000 , CM : 900 , D: 500 , CD : 400 , C: 100 , XC : 90 , L: 50 , XL : 40 , X: 10 , IX : 9 , V: 5 , IV : 4 , I: 1 }
class Fixnum
def to_roman
return nil unless self > 0 && self < 4000
remaining_number = self
ROMANS . inject ( "" ) do | roman_str, current_number |
times,remaining_number = remaining_number . divmod current_number [ 1 ]
roman_str + current_number [ 0 ]. to_s * times
end
end
end
TRANSFORMATIONS = {
I: 1 , II : 2 , III : 3 , IV : 4 , V: 5 , VI : 6 , VII : 7 , VIII : 8 , IX : 9 , X: 10 , XI : 11 , XII : 12 , XIV : 14 , XV : 15 ,
XIX : 19 , XXXIX : 39 , XL : 40 , XLI : 41 , L: 50 , LXXXIX : 89 , XC : 90 , XCIX : 99 , C: 100 , CCCXCIX : 399 , CD : 400 ,
D: 500 , DCCCXCIX : 899 , CM : 900 , M: 1000 , MMXI : 2011 , MMMCMXCIX : 3999
}
describe "From arabic to roman numerals. " do
TRANSFORMATIONS . each do | roman, arabic |
it( "transforms #{ arabic } to #{ roman }" ) do
arabic . to_roman . should == roman . to_s
end
end
[ - 10 , 0 , 4000 , 4100 ]. each do | bad_arabic |
it( "#{ bad_arabic } can not be transformed to roman numeral" ) do
bad_arabic . to_roman . should == nil
end
end
end

Llamar métodos por nombre / introspección
class Integer
def to_fizzbuzz1
return "FizzBuzz" if fizzbuzz?
return "Fizz" if fizz?
return "Buzz" if buzz?
self
end
FIZZBUZZ3 = { fizzbuzz?: "FizzBuzz" , buzz?: "Buzz" , fizz?: "Fizz" }
def to_fizzbuzz3
FIZZBUZZ3 .each do | method , name |
return name if send method
end
self
end
def multiple_of? n
self % n == 0
end
def fizz?
multiple_of? 3
end
...
def fizzbuzz?
multiple_of? 15
end

Llamar métodos por nombre / introspección
describe "FizzBuzz identity cases" do
it "1 should be 1" do
1 . to_fizzbuzz . should == 1
end
it "4 should be 4" do
4 . to_fizzbuzz . should == 4
end
end
...
describe "FizzBuzz FizzBuzz cases" do
it "15 should be Buzz" do
15 . to_fizzbuzz . should == "FizzBuzz"
end
...
end
describe "FizzBuzz testing all implementations" do
[ :to_fizzbuzz1 , :to_fizzbuzz2 , :to_fizzbuzz3 ]. each do | impl |
( 1 . . 100 ) . each do | n |
it "trying impl. #{ impl } for number #{ n }" do
n . send(impl) . should == n . to_fizzbuzz
end
end
end
end

Inferencia de tipos
Java
int x = 1 + 2 * 3;
String y = x.toString();
List<String> lista = new ArrayList<String>();
Map<String, Integer> m = new HashMap<String, Integer>();
public int incrementar(int x) {
return x + 1;
}
Java 7:
Map<String, List<String>> myMap = new HashMap<>();
Scala
val x = 1 + 2 * 3
val y = x.toString()
val lista : List[String] = new ArrayList[String]
val lista = new ArrayList[String]
val lista = List
val lista = List("elm1", "elm2")
val m = new HashMap[String,Int]
def incrementar(x: Int) : Int = x + 1
def incrementar(x: Int) = x + 1

Tipos covariantes y contracovariantes, not reified (type erasure), ...
Java:
Vehiculo[] v = new Vehiculo[10];
Coche[] c = new Coche[10];
v = c; // CORRECTO
List<Vehiculo> vlist = new ArrayList<Vehiculo>();
List<Coche> vcoche = new ArrayList<Coche>();
vlist = vcoche;
// ERROR - Type mismatch: cannot convert from List<Coche> to List<Vehiculo>
Scala:
class Stack[+A] {
def push[B >: A](elem: B) ....

Abrir clases o conversiones implícitas (vistas)
2 days ago
5 days from_now
class DateHelper(number: Int) {
def days(when: String) : Date = {
var date = Calendar.getInstance()
when match {
case "ago" => date.add(Calendar.DAY_OF_MONTH, -number)
case "from_now" => date.add(Calendar.DAY_OF_MONTH, number)
case _ => date
}
date.getTime()
}
}
implicit def convertInt2DateHelper(number: Int) = new DateHelper(number)
final class RichChar(c: Char)
{
def isDigit: Boolean = Character.isDigit(c) // isLetter, isWhitespace, etc.
}
object RichCharTest {
implicit def charWrapper(c: char) = new RichChar(c)
def main(args: Array[String]) { println( '0' .isDigit)
}
}

Duck typing, Interfaces o Structural typing
class Duck {
def quack = println ( "Quaaaaaack !" )
def feathers = println ( "The duck has white and gray feathers." )
}
class Person {
def quack = println ( "The person imitates a duck." )
def feathers = println ( "The person takes a feather from the ground and shows it." )
}
...
def inTheForest ( duck : { def quack ; def feathers }) = {
duck.quack
duck.feathers
} type ActAsADuck = {
def quack
def feathers
}

Missing method, invokedynamic (java7), Dynamic trait
class Roman
def romanToInt(str)
# ...
end
def method_missing(methId)
str = methId.id2name
romanToInt(str)
end
end
r = Roman.new
r.iv #=> 4
r.xxiii #=> 23
r.mm #=> 2000
miXml.persona.nombre , o miJson.persona.nombre ;-)
Rails lo usa muchísimo, por ejemplo find_by_columns

Módulos, mixins, traits, herencia múltiple, ...
class miclase
{
include Enumerable # tengo gratis inject, all?, any?, collect...
def each ....
}
Comparable, con <=> tengo <, <=, ==, >, >=, between?
Puedo mezclar los módulos que quiera

JVM
Groovy
Scala
JRuby
Jython
Clojure
...
Quien lo iba a imaginar

Rendimiento
¿ Compilado o interpretado ?
¿ Estáticos o dinámicos ?
¿ Intensivo IO o CPU ?
¿ Funcionales (y no-SQL), objectivo contrario a lenguajes dinámicos ?
Actors ? transactional memory ? "let it crash" ? Monads ?
"SETI@home has been a success,obviously not in finding aliens,but in demonstrating the potential of large-scale distributed computing"

Funcionales, recursión, complejidad, O(N), ...
def to_fib_recursive
return self if zero? or one?
( self - 1 ) . to_fib_recursive + ( self - 2 ) . to_fib_recursive
end
def to_fib_tail
first,second = 0 , 1
( self - 1 ) . times do
first,second = second, first + second
end
second
end
def to_fib_inject
fib = ( self - 1 ) . times . inject( [ 0 , 1 ] ) do | group, n |
[ group [ 1 ] , group [ 0 ] + group [ 1 ] ]
end
fib [ 1 ]
end
def to_fib_formula
( ( ( GOLDEN_RATIO ** self ) - (( - GOLDEN_RATIO ) ** ( - self )) ) / ROOT_FIVE ) . to_i
end
def one?
self == 1
end
ROOT_FIVE = Math . sqrt( 5 )
GOLDEN_RATIO = ( 1 + ROOT_FIVE ) / 2
end

No olvidemos...
IDE y herramientas
Rendimiento
Chequeos compilación
Independencia plataforma
Lenguaje
Librerías
Muy bueno para frameworks genéricos (Rails, RSpec, Cucumber, etc.) pero para APIs ni interfaces ni tipos
Los dinámicos son de verdad más productivos ?

¡WARNING! La siguiente sección contiene opiniones subversivas que pueden herir la sensibilidad

Tipos de tipados :-)
¿Se realiza chequeo de tipos?
Sí -> Tipado fuerte
No -> Tipado débil
¿Cuándo se realiza el chequeo de tipos?
En tiempo de ejecución -> Tipado dinámico
En tiempo de compilación -> Tipado estático

Tipos de tipados :-)
¿Java, Scala, C#...? Tipado fuerte y estático
¿JS, Ruby ....? Tipado fuerte y dinámico
¿C, C++? Tipado débil (al menos en mis tiempos)

El compilador es tonto
Necesita información extra para chequear los tipos
Ruido sintáctico -> Boilerplate code
Dependencia del IDE (CTRL+Space)
Reza para que sea rápido (ADA, ¿Scala?)
Los errores de tipos son los sencillos
Es incapaz de detectar los errores semánticos, los realmente complicados

Enter TDD (que cansino...)
No existe técnica para resolver el problema de detección de errores funcionales al 100%
Pero TDD y BDD son muy efectivos!

Ahora os cuento un secreto....

Ahora os cuento un secreto....
¡ TDD también detecta errores sintácticos y de tipos !
¡ Y los detecta al 100 % !
(al menos en mi experiencia)

Tipado dinámico wins!
Invocando el principio KISS:
IF ( "TDD lo necesito sí o sí"
&& "TDD detecta errores de tipado y de sintaxis") {
DO Eliminar compilador
}
Y de paso elimino el ruido sintáctico:
Escribo menos código
El código es más legible
Ciclo de desarrollo más ágil

Tipado estático strikes back
Inferencia de tipos
Tipado estructural
¿Tanta complejidad hará que el compilador sea lento?
¿Realmente que me aporta?
¿Qué gano respecto a un lenguaje dinámico usando TDD?

¿Y los DSL?
Hacen tu código más cercano al dominio del problema
Legibilidad aumenta
Lenguajes dinámicos son buenos para esto
Son maleables
Muchas capacidades de metaprogramación
¡Ruby y Groovy!
Los lenguajes estáticos normalmente son malos para esto: JMock Vs. Spock Vs. RSpec Vs. Jasmine
! Pero Scala es muy bueno !

¡YA ME VOY! Y ahora pasemos a las conclusiones (Gracias Leo!)

Conclusiones
- ¿ Dinámicos para equipos pequeños con gente muy buena ?
- ¿ Estáticos para proyectos grandes o con varios equipos ?
- ¿ Funcionales para problemas específicos ?
Kent Beck: "Simplemente cuenta la historia. No me gustan las conclusiones morales al final de las historias."
Así que cada uno saque sus propias conclusiones :-)
Muchas gracias
Leo Antoli @lantoli Enrique Amodeo @eamodeorubio

Quiero hacer ágil, ¿y ahora qué: Java, Ruby o Scala?

by Agile Spain on Nov 06, 2011

Accessibility

Tags

Upload Details

Usage Rights

Statistics

Quiero hacer ágil, ¿y ahora qué: Java, Ruby o Scala? — Presentation Transcript