Clean Code Talks — Herencia, Polimorfismo y Tests

Son un usuario fanático de Twitter. Una cuenta a la que sigo es @delicious_prog, que envía varios mensajes por día, relacionados con programación, desarrollo de software en general. En uno de esos tweets, encontré el post

The Clean Code Talks — Inheritance, Polymorphism, & Testing

de Daniel Wild, donde incluye el vidio de una Google Talk:

[View:http://www.youtube.com/watch?v=4F72VULWFvc]

de Misko Hevery en Google Tech Talks.

Es claro e interesante. Es una charla explicando los usos del polimorfismo, y también, las formas de realizar test sobre métodos polimórficos. Me gusta encontrara en este vido varios argumentos similares a los que uso en mis charlas de desarrollo. Hace unos días, estuve usando polimorfirsmo en mi intérprete AjCat (un intérprete del lenguaje cat que me hizo conocer el bueno de @rodolfof):

http://code.google.com/p/ajcodekatas/source/browse/#svn/trunk/AjCat

Esta es mi implmentación de Integer Binary Operation:

    public abstract class IntegerBinaryOperation : Expression
    {
        public abstract int Apply(int op1, int op2);

        public override void Evaluate(Machine machine)
        {
            int op2 = (int) machine.Pop();
            int op1 = (int) machine.Pop();

            machine.Push(this.Apply(op1, op2));
        }
    }

Las operaciones Add y Subtract sobreescriben el método Apply:

    public class IntegerAddOperation : IntegerBinaryOperation
    {
        private static IntegerAddOperation instance = new IntegerAddOperation();

        private IntegerAddOperation()
        {
        }

        public static IntegerAddOperation Instance
        {
            get
            {
                return instance;
            }
        }

        public override int Apply(int op1, int op2)
        {
            return op1 + op2;
        }

        public override string ToString()
        {
            return "add_int";
        }
    }

    public class IntegerSubtractOperation : IntegerBinaryOperation
    {
        private static IntegerSubtractOperation instance = new IntegerSubtractOperation();

        private IntegerSubtractOperation()
        {
        }

        public static IntegerSubtractOperation Instance
        {
            get
            {
                return instance;
            }
        }

        public override int Apply(int op1, int op2)
        {
            return op1 - op2;
        }

        public override string ToString()
        {
            return "sub_int";
        }
    }

Es muy similar al ejemplo presentado en el video. Estuve algo más perezoso en mi implementación de operadores en AjPython (otro intérprete, de nuevo en C#, trabajo en progreso):

http://code.google.com/p/ajcodekatas/source/browse/#svn/trunk/AjPython

    public class BinaryOperatorExpression : BinaryExpression
    {
        private Operator @operator;

        public BinaryOperatorExpression(Expression left, Expression right, Operator oper)
            : base(left, right)
        {
            this.@operator = oper;
        }

        public override object Evaluate(Environment environment)
        {
            object leftvalue;
            object rightvalue;

            leftvalue = this.Left.Evaluate(environment);
            rightvalue = this.Right.Evaluate(environment);

            switch (this.@operator)
            {
                case Operator.Add:
                    return (int)leftvalue + (int)rightvalue;
                case Operator.Subtract:
                    return (int)leftvalue - (int)rightvalue;
                case Operator.Multiply:
                    return (int)leftvalue * (int)rightvalue;
                case Operator.Divide:
                    return (int)leftvalue / (int)rightvalue;
                case Operator.Power:
                    return System.Convert.ToInt32(System.Math.Pow((int)leftvalue, (int)rightvalue));
            }

            throw new System.InvalidOperationException();
        }
    }

Pero confío en refactorearlo, tengo espaldas para hacerlo, gracias una buena base de test ya escritos.

Es bueno encontrar este tipo de material, como esta charla, la recomiendo, gracias a @delicious_prog y a Daniel Wild!

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Leave a Reply Cancel reply