code: def postorder(self):
          
          nodes_random = self.nodes()
          # for debugging we could make it more random;)
          # from random import shuffle
          # shuffle(nodes_random)
          # 1. sort branches
          nodes_by_branch = sorted(nodes_random, cmp=self.cmp_branch)
          # 1. topological sort
          nodes_topological = []
          for node in nodes_by_branch:
              self.dfs(node, nodes_topological)
          self.clear_nodes()
          # 2. earthworm sort
          nodes_consecutive = []
          for node in nodes_topological:
              Node = self[node]
              outgoing_nodes = Node.nodes()
              if outgoing_nodes:
                  last_index = max([nodes_consecutive.index(on) for on in \
                                     outgoing_nodes])
                  nodes_consecutive.insert(last_index + 1, node)
              else:
                  nodes_consecutive.append(node)
          return nodes_consecutive
docs: Returns a valid postorder of the **node objects** of the ``DictGraph`` 
          *if* the topology is a directed acyclic graph. This postorder is 
          semi-random, because the order of elements in a dictionary is 
          semi-random and so are the starting nodes of the depth-first search 
          traversal, which determines the postorder, consequently some postorders
          will be discovered more frequently.
          
          This postorder enforces some determinism on particular ties:
          
            - toplogically equivalent branches come first are sorted by length
              (shorter branches come first).
            - if the topological Nodes corresponding to the node objects have
              a ``"branch"`` attribute it will be used to sort the graph from 
              left to right.
                
          However the final postorder is still *not* deterministic.