diff --git a/expression.py.back b/expression.py.back
deleted file mode 100644
index 75c3e4e..0000000
--- a/expression.py.back
+++ /dev/null
@@ -1,115 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-
-from generic import Stack
-from calculus import isNumber, doMath
-
-
-class Expression(object):
-    """An arithmetic expression"""
-
-    priority = {"*" : 3, "/": 3, "+": 2, "-":2, "(": 1}
-
-    def __init__(self, exp, fix = "infix"):
-        """Initiate the expression.
-
-        :param exp: the string representing the expression (infx form by default)
-        :param fix: form of the expression infix (default) - postfix - prefix
-
-        """
-        if fix == "infix":
-            self._exp_infix = exp
-            self._token_infix = exp.split(" ")
-        elif fix == "postfix":
-            self._token_postfix = exp
-        else:
-            print("Pas encore fait!")
-
-    def infixToPostfix(self):
-        """Convert the infix expression into postfix expression.
-        """
-        #@todo importer les exemples
-        opStack = Stack()
-        postfixList = []
-
-        for token in self._token_infix:
-            if token == "(":
-                opStack.push(token)
-            elif token == ")":
-                topToken = opStack.pop()
-                while topToken != "(":
-                    postfixList.append(topToken)
-                    topToken = opStack.pop()
-            elif token in "+-*/":
-                while (not opStack.isEmpty()) and (self.priority[opStack.peek()] >= self.priority[token]):
-                    postfixList.append(opStack.pop())
-                opStack.push(token)
-            else:
-                postfixList.append(token)
-
-        while not opStack.isEmpty():
-            postfixList.append(opStack.pop())
-
-        self._token_postfix = postfixList
-        self._exp_postfix = " ".join(postfixList)
-        
-    def computePostfix(self):
-        """Compute a postfix expression like a good student
-
-        :returns: list of steps to reach the result (postfix form)
-
-        """
-        tokenList = self._token_postfix.copy()
-        tmpTokenList = []
-        # on va chercher les motifs du genre A B + pour les calculer
-        while len(tokenList) > 2: 
-            #print(tokenList[2])
-            if isNumber(tokenList[0]) and isNumber(tokenList[1]) and tokenList[2] in "+-*/":
-                # S'il y a une opération à faire
-                op1 = tokenList[0]
-                op2 = tokenList[1]
-                token = tokenList[2]
-                res = doMath(token, op1, op2)
-
-                tmpTokenList.append(res)
-
-                # Comme on vient de faire le calcul, on peut détruire aussi les deux prochains termes
-                del tokenList[0:3]
-            else:
-                tmpTokenList.append(tokenList[0])
-
-                del tokenList[0]
-        tmpTokenList += tokenList
-
-        if len(tmpTokenList) > 1:
-            next_steps = Expression(tmpTokenList, fix = "postfix").computePostfix()
-        else:
-            next_steps = tmpTokenList
-        print(self._exp_postfix)
-        return [self._exp_postfix] + next_steps
-
-
-def test(exp):
-    """Make various test on an expression
-
-    """
-    print("-------------")
-    print("Expression ",exp)
-    expression = Expression(exp)
-    expression.infixToPostfix()
-    print(expression.computePostfix())
-
-if __name__ == '__main__':
-    exp = "1 + 3 * 5"
-    test(exp)
-
-    exp = "2 * 3 * 3 * 5"
-    test(exp)
-
-    exp = "2 * 3 + 3 * 5"
-    test(exp)
-
-# -----------------------------
-# Reglages pour 'vim'
-# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
-# cursor: 16 del 
diff --git a/expression.py_back b/expression.py_back
deleted file mode 100644
index a4d4ee0..0000000
--- a/expression.py_back
+++ /dev/null
@@ -1,191 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-
-
-class Expression(object):
-    """A calculus expression. Today it can andle only expression with numbers later it will be able to manipulate unknown"""
-
-    priority = {"*" : 3, "/": 3, "+": 2, "-":2, "(": 1}
-
-    def __init__(self, exp):
-        """ Initiate the expression.
-
-        :param exp: the expression. It can be a string or a list of tokens. It can be infix or postfix expression
-        """
-        self._tokens = {}
-        self._strings = {}
-        if type(exp) == list:
-            fix = self.get_fix(exp)
-            self._tokens[fix] = exp
-        elif type(exp) == str:
-            tokens = self.parseExp(exp)
-            fix = self.get_fix(tokens)
-            self._tokens[fix] = tokens
-            self._strings[fix] = exp
-        else:
-            raise ValueError("The expression needs to be a string or a list of token")
-
-    # ---------------------
-    # String parsing
-
-    # @classmethod ????
-    def parseExp(self, exp):
-        """ Parse the expression, ie tranform a string into a list of tokens
-
-        :param exp: The expression (a string)
-        :returns: list of token
-
-        """
-        return exp.split(" ")
-
-    # ---------------------
-    # "fix" recognition
-
-    def get_fix(self, tokens):
-        """ Give the "fix" of an expression
-        infix -> A + B
-        prefix -> + A B
-        postfix -> A B +
-
-        :param exp: the expression (list of token)
-        :returns: the "fix" (infix, postfix, prefix)
-
-        """
-        if tokens[0] in  "+-*/":
-            return "prefix"
-        elif token[0] not in "+-*/" ans token[1] not in "+-*/":
-            return "postfix"
-        else:
-            return "infix"
-
-    # ----------------------
-    # Expressions - tokens getters
-
-    def tokens(self, fix = "infix"):
-        """Get the list of tokens with the wanted fix
-
-        :param fix: the fix wanted (infix default)
-        :returns: list of tokens
-
-        """
-        # Si ce fix n'a pas encore été enregistré
-        if fix not in self._tokens:
-            # Il peut venir de la version string
-            if fix in self._string:
-                self._tokens[fix] = self.parseExp(self._string[fix])
-            # Sinon il faut le calculer à partir d'une autre forme
-            else:
-                fix_transfo = "to" + fix.capitalize()
-                getattr(self,fix_transfo)()
-
-        return self._tokens[fix]
-
-##### On en est là,il faudra faire attention à bien vérifier ce que les "to..." enregistre (string ou tokens)  
-
-    def string(self, fix = "infix"):
-        """Get the string with the wanted fix
-
-        :param fix: the fix wanted (infix default)
-        :returns: the string representing the expression
-
-        """
-        # Si ce fix n'a pas encore été enregistré
-        if fix not in self._string:
-            # Il peut venir de la version string
-            if fix in self._tokens:
-                self._string[fix] = self.parseExp(self._string[fix])
-            # Sinon il faut le calculer à partir d'une autre forme
-            else:
-                fix_transfo = "to" + fix.capitalize()
-                getattr(self,fix_transfo)()
-
-        return self._string[fix]
-    
-    # ----------------------
-    # "fix" tranformations
-
-    def toPostfix(self):
-        """ Transorm the expression into postfix form using the infix form"""
-        pass
-
-    def toInfix(self):
-        """ Tranform the expression into infix form using postfix form"""
-        pass
-
-    # ---------------------
-    # Tools for placing parenthesis in infix notation
-
-    def needPar(operande, operator, posi = "after"):
-        """ Says whether or not the operande needs parenthesis
-
-        :param operande: the operande
-        :param operator: the operator
-        :param posi: "after"(default) if the operande will be after the operator, "before" othewise
-        :returns: bollean
-        """
-        if isNumber(operande) and "-" in operande:
-            return 1
-        elif not isNumber(operande):
-            # Si c'est une grande expression ou un chiffre négatif
-            stand_alone = get_main_op(operande)
-            # Si la priorité de l'operande est plus faible que celle de l'opérateur
-            minor_priority = self.priority[get_main_op(operande)] < self.priority[operator]
-            # Si l'opérateur est -/ pour after ou juste / pour before
-            special = (operator in "-/" and posi == "after") or (operator in "/" and posi == "before")
-
-            return stand_alone and (minor_priority or special)
-        else:
-            return 0
-    
-# J'aime pas bien cette endroit faudrait que ce soit une méthode qui s'applique uniquement à l'expression en question (self) pas à n'importe quel string, ça serait plus propre.
-    def get_main_op(exp):
-        """ Gives the main operation of the expression
-
-        :param exp: the expression
-        :returns: the main operation (+, -, * or /) or 0 if the expression is only one element
-
-        """
-        parStack = Stack()
-        tokenList = exp.split(" ")
-
-        if len(tokenList) == 1:
-        # Si l'expression n'est qu'un élément
-            return 0
-
-        main_op = []
-
-        for token in tokenList:
-            if token == "(":
-                parStack.push(token)
-            elif token == ")":
-                parStack.pop()
-            elif token in "+-*/" and parStack.isEmpty():
-                main_op.append(token)
-
-        return min(main_op, key = lambda s: priority[s])
-
-    # ---------------------
-    # Computing the expression
-
-    def compute(self):
-        """ Recursive method for computing as a student the expression
-        :returns: list of steps needed to reach the result
-
-        """
-        pass
-    
-    def doMath(op, op1, op2):
-        """Compute "op1 op op2"
-
-        :param op: operator
-        :param op1: first operande
-        :param op2: second operande
-        :returns: string representing the result
-
-        """
-        return str(eval(op1 + op + op2))
-
-# -----------------------------
-# Reglages pour 'vim'
-# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
-# cursor: 16 del