diff --git a/2-4.org b/2-4.org
new file mode 100644
index 0000000..446a122
--- /dev/null
+++ b/2-4.org
@@ -0,0 +1,453 @@
+#+BEGIN_HTML
+---
+title: 2.4 - Multiple Representations for Abstract Data
+layout: org
+---
+#+END_HTML
+
+* Representations for Complex Numbers
+* Tagged Data
+  #+begin_src scheme :tangle yes
+    ;; ===================================================================
+    ;; 2.4.2: Tagged Data
+    ;; ===================================================================
+
+    (define (attach-tag type-tag contents)
+      (cons type-tag contents))
+
+    (define (type-tag datum)
+      (if (pair? datum)
+          (car datum)
+          (error "Bad tagged datum -- TYPE-TAG" datum)))
+
+    (define (contents datum)
+      (if (pair? datum)
+          (cdr datum)
+          (error "Bad tagged datum -- CONTENTS" datum)))
+
+    (define (rectangular? z)
+      (eq? (type-tag z) 'rectangular))
+
+    (define (polar? z)
+      (eq? (type-tag z) 'polar))
+
+    (define (real-part-rectangular z) (car z))
+
+    (define (imag-part-rectangular z) (cdr z))
+
+    (define (magnitude-rectangular z)
+      (sqrt (+ (square (real-part-rectangular z))
+               (square (imag-part-rectangular z)))))
+
+    (define (angle-rectangular z)
+      (atan (imag-part-rectangular z)
+            (real-part-rectangular z)))
+
+    (define (make-from-real-imag-rectangular x y)
+      (attach-tag 'rectangular (cons x y)))
+
+    (define (make-from-mag-ang-rectangular r a)
+      (attach-tag 'rectangular
+                  (cons (* r (cos a)) (* r (sin a)))))
+
+    (define (real-part-polar z)
+      (* (magnitude-polar z) (cos (angle-polar z))))
+
+    (define (imag-part-polar z)
+      (* (magnitude-polar z) (sin (angle-polar z))))
+
+    (define (magnitude-polar z) (car z))
+
+    (define (angle-polar z) (cdr z))
+
+    (define (make-from-real-imag-polar x y)
+      (attach-tag 'polar
+                  (cons (sqrt (+ (square x) (square y)))
+                        (atan y x))))
+
+    (define (make-from-mag-ang-polar r a)
+      (attach-tag 'polar (cons r a)))
+
+    (define (real-part z)
+      (cond ((rectangular? z)
+             (real-part-rectangular (contents z)))
+            ((polar? z)
+             (real-part-polar (contents z)))
+            (else (error "Unknown type -- REAL-PART" z))))
+
+    (define (imag-part z)
+      (cond ((rectangular? z)
+             (imag-part-rectangular (contents z)))
+            ((polar? z)
+             (imag-part-polar (contents z)))
+            (else (error "Unknown type -- IMAG-PART" z))))
+
+    (define (magnitude z)
+      (cond ((rectangular? z)
+             (magnitude-rectangular (contents z)))
+            ((polar? z)
+             (magnitude-polar (contents z)))
+            (else (error "Unknown type -- MAGNITUDE" z))))
+
+    (define (angle z)
+      (cond ((rectangular? z)
+             (angle-rectangular (contents z)))
+            ((polar? z)
+             (angle-polar (contents z)))
+            (else (error "Unknown type -- ANGLE" z))))
+
+    (define (add-complex z1 z2)
+      (make-from-real-imag (+ (real-part z1) (real-part z2))
+                           (+ (imag-part z1) (imag-part z2))))
+
+    (define (make-from-real-imag x y)
+      (make-from-real-imag-rectangular x y))
+
+    (define (make-from-mag-ang r a)
+      (make-from-mag-ang-polar r a))
+  #+end_src
+* Data-Directed Programming and Additivity
+  #+begin_src scheme :tangle yes
+    ;; ===================================================================
+    ;; 2.4.3: Data-Directed Programming and Additivity
+    ;; ===================================================================
+
+    (define (install-rectangular-package)
+      ;; internal procedures
+      (define (real-part z) (car z))
+      (define (imag-part z) (cdr z))
+      (define (make-from-real-imag x y) (cons x y))
+      (define (magnitude z)
+        (sqrt (+ (square (real-part z))
+                 (square (imag-part z)))))
+      (define (angle z)
+        (atan (imag-part z) (real-part z)))
+      (define (make-from-mag-ang r a)
+        (cons (* r (cos a)) (* r (sin a))))
+
+      ;; interface to the rest of the system
+      (define (tag x) (attach-tag 'rectangular x))
+      (put 'real-part '(rectangular) real-part)
+      (put 'imag-part '(rectangular) imag-part)
+      (put 'magnitude '(rectangular) magnitude)
+      (put 'angle '(rectangular) angle)
+      (put 'make-from-real-imag 'rectangular
+           (lambda (x y) (tag (make-from-real-imag x y))))
+      (put 'make-from-mag-ang 'rectangular
+           (lambda (r a) (tag (make-from-mag-ang r a))))
+      'done)
+
+    (define (install-polar-package)
+      ;; internal procedures
+      (define (magnitude z) (car z))
+      (define (angle z) (cdr z))
+      (define (make-from-mag-ang r a) (cons r a))
+      (define (real-part z)
+        (* (magnitude z) (cos (angle z))))
+      (define (imag-part z)
+        (* (magnitude z) (sin (angle z))))
+      (define (make-from-real-imag x y)
+        (cons (sqrt (+ (square x) (square y)))
+              (atan y x)))
+
+      ;; interface to the rest of the system
+      (define (tag x) (attach-tag 'polar x))
+      (put 'real-part '(polar) real-part)
+      (put 'imag-part '(polar) imag-part)
+      (put 'magnitude '(polar) magnitude)
+      (put 'angle '(polar) angle)
+      (put 'make-from-real-imag 'polar
+           (lambda (x y) (tag (make-from-real-imag x y))))
+      (put 'make-from-mag-ang 'polar
+           (lambda (r a) (tag (make-from-mag-ang r a))))
+      'done)
+
+    (define (apply-generic op . args)
+      (let ((type-tags (map type-tag args)))
+        (let ((proc (get op type-tags)))
+          (if proc
+              (apply proc (map contents args))
+              (error
+               "No method for these types -- APPLY-GENERIC"
+               (list op type-tags))))))
+
+    (define (real-part z) (apply-generic 'real-part z))
+    (define (imag-part z) (apply-generic 'imag-part z))
+    (define (magnitude z) (apply-generic 'magnitude z))
+    (define (angle z) (apply-generic 'angle z))
+
+    (define (make-from-real-imag x y)
+      ((get 'make-from-real-imag 'rectangular) x y))
+
+    (define (make-from-mag-ang r a)
+      ((get 'make-from-mag-ang 'polar) r a))
+  #+end_src
+** Exercise 2.73
+   Section *Note 2-3-2:: described a program that performs symbolic
+   differentiation:
+
+   #+begin_src scheme
+     (define (deriv exp var)
+       (cond ((number? exp) 0)
+             ((variable? exp) (if (same-variable? exp var) 1 0))
+             ((sum? exp)
+              (make-sum (deriv (addend exp) var)
+                        (deriv (augend exp) var)))
+             ((product? exp)
+              (make-sum
+                (make-product (multiplier exp)
+                              (deriv (multiplicand exp) var))
+                (make-product (deriv (multiplier exp) var)
+                              (multiplicand exp))))
+             <MORE RULES CAN BE ADDED HERE>
+             (else (error "unknown expression type -- DERIV" exp))))
+   #+end_src
+
+   We can regard this program as performing a dispatch on the type of
+   the expression to be differentiated.  In this situation the "type
+   tag" of the datum is the algebraic operator symbol (such as `+')
+   and the operation being performed is `deriv'.  We can transform
+   this program into data-directed style by rewriting the basic
+   derivative procedure as
+
+   #+begin_src scheme
+     (define (deriv exp var)
+        (cond ((number? exp) 0)
+              ((variable? exp) (if (same-variable? exp var) 1 0))
+              (else ((get 'deriv (operator exp)) (operands exp)
+                                                 var))))
+
+     (define (operator exp) (car exp))
+
+     (define (operands exp) (cdr exp))
+   #+end_src
+   
+   a. Explain what was done above.  Why can't we assimilate the
+      predicates `number?' and `same-variable?' into the
+      data-directed dispatch?
+
+      ----------------------------------------------------------------------
+      
+      Rather than embed the logic for each operator we want to support
+      in the ~deriv~ function, we'll dispatch them based on the
+      operator in the expression.
+
+      ~number?~ and ~same-variable~ cannot be dispatched this way
+      because they're scalar values, not compound expressions tagged
+      with an operator to dispatch on.
+
+   b. Write the procedures for derivatives of sums and products,
+      and the auxiliary code required to install them in the table
+      used by the program above.
+
+      ----------------------------------------------------------------------
+
+      #+begin_src scheme
+        (define (install-deriv-code)
+          (define (deriv-sum exp var)
+            (make-sum (deriv (addend exp) var)
+                      (deriv (augend exp) var)))
+          (define (deriv-product expr var)
+            (make-sum
+             (make-product (multiplier exp)
+                           (deriv (multiplicand exp) var))
+             (make-product (deriv (multiplier exp) var)
+                           (multiplicand exp))))
+          (put 'deriv '+ deriv-sum)
+          (put 'deriv '* deriv-product))
+      #+end_src
+
+   c. Choose any additional differentiation rule that you like,
+      such as the one for exponents (*Note Exercise 2-56::), and
+      install it in this data-directed system.
+
+   d. In this simple algebraic manipulator the type of an
+      expression is the algebraic operator that binds it together.
+      Suppose, however, we indexed the procedures in the opposite
+      way, so that the dispatch line in `deriv' looked like
+
+      #+begin_src scheme
+        ((get (operator exp) 'deriv) (operands exp) var)
+      #+end_src
+
+      What corresponding changes to the derivative system are
+      required?
+
+      ----------------------------------------------------------------------
+
+      Nothing, only the implementations of the dispatch table storage
+      / lookup methods ( ~put~ / ~get~ ) would change.
+
+** Exercise 2.74:
+   Insatiable Enterprises, Inc., is a highly decentralized
+   conglomerate company consisting of a large number of independent
+   divisions located all over the world.  The company's computer
+   facilities have just been interconnected by means of a clever
+   network-interfacing scheme that makes the entire network appear to
+   any user to be a single computer.  Insatiable's president, in her
+   first attempt to exploit the ability of the network to extract
+   administrative information from division files, is dismayed to
+   discover that, although all the division files have been
+   implemented as data structures in Scheme, the particular data
+   structure used varies from division to division.  A meeting of
+   division managers is hastily called to search for a strategy to
+   integrate the files that will satisfy headquarters' needs while
+   preserving the existing autonomy of the divisions.
+
+   Show how such a strategy can be implemented with data-directed
+   programming.  As an example, suppose that each division's personnel
+   records consist of a single file, which contains a set of records
+   keyed on employees' names.  The structure of the set varies from
+   division to division.  Furthermore, each employee's record is
+   itself a set (structured differently from division to division)
+   that contains information keyed under identifiers such as `address'
+   and `salary'.  In particular:
+
+   a. Implement for headquarters a `get-record' procedure that
+      retrieves a specified employee's record from a specified
+      personnel file.  The procedure should be applicable to any
+      division's file.  Explain how the individual divisions' files
+      should be structured.  In particular, what type information
+      must be supplied?
+
+      ----------------------------------------------------------------------
+
+      #+begin_src scheme
+        (define division-identifier car)
+        (define division-data cdr)
+        (define tag-division cons)
+
+        (define (get-record name tagged-file)
+          (let ((division (division-identifier tagged-file))
+                (file (division-data tagged-file)))
+            (tag-division division (apply-generic 'get-record
+                                                  (division-identifier file)
+                                                  name
+                                                  (division-data file)))))
+      #+end_src
+
+      Division files must be tagged with a unique identifier for the
+      division.
+
+   b. Implement for headquarters a `get-salary' procedure that
+      returns the salary information from a given employee's record
+      from any division's personnel file.  How should the record be
+      structured in order to make this operation work?
+
+      ----------------------------------------------------------------------
+
+      #+begin_src scheme
+        (define (get-record-field tagged-record field)
+          (let ((division (division-identifier tagged-record))
+                (record (division-data tagged-record)))
+            (apply-generic 'get-record-field
+                           division
+                           record
+                           field)))
+      #+end_src
+      
+   c. Implement for headquarters a `find-employee-record'
+      procedure.  This should search all the divisions' files for
+      the record of a given employee and return the record.  Assume
+      that this procedure takes as arguments an employee's name and
+      a list of all the divisions' files.
+
+      ----------------------------------------------------------------------
+
+      #+begin_src scheme
+        (define (find-employee-record name division-files)
+          (let* ((division-file (car division-files))
+                 (rest (cdr division-files))
+                 (found-file (get-record name division-file)))
+            (if (nil? found-file)
+                (find-employee-record name rest)
+                found-file)))
+      #+end_src
+   d. When Insatiable takes over a new company, what changes must
+      be made in order to incorporate the new personnel information
+      into the central system?
+
+      ----------------------------------------------------------------------
+
+      The new company's personnel information must be representable in
+      scheme, and will have to be tagged with a new unique
+      identifier. New implementations for ~get-record~ and
+      ~get-record-field~ will have to be implemented for the new data
+      format.
+* Message Passing
+  #+begin_src scheme
+    ;; ===================================================================
+    ;; 2.4.4: Message Passing
+    ;; ===================================================================
+
+    (define (make-from-real-imag x y)
+      (define (dispatch op)
+        (cond ((eq? op 'real-part) x)
+              ((eq? op 'imag-part) y)
+              ((eq? op 'magnitude)
+               (sqrt (+ (square x) (square y))))
+              ((eq? op 'angle) (atan y x))
+              (else
+               (error "Unknown op -- MAKE-FROM-REAL-IMAG" op))))
+      dispatch)
+
+    (define (apply-generic op arg) (arg op))
+  #+end_src
+** Exercise 2.75
+   Implement the constructor `make-from-mag-ang' in message-passing
+   style.  This procedure should be analogous to the
+   `make-from-real-imag' procedure given above.
+
+   ----------------------------------------------------------------------
+
+   #+begin_src scheme
+     (define (make-from-mag-ang r a)
+       (define (dispatch op)
+         (cond ((eq? op 'real-part)
+                (* r (cos a)))
+               ((eq? op 'imag-part)
+                (* r (sin a)))
+               ((eq? op 'magnitude) r)
+               ((eq? op 'angle) a)
+               (else
+                (error "Unknown op -- MAKE-FROM-MAG-ANG" op))))
+       dispatch)
+   #+end_src
+** Exercise 2.76
+   As a large system with generic operations evolves, new types of data
+   objects or new operations may be needed.  For each of the three
+   strategies--generic operations with explicit dispatch, data-directed
+   style, and message-passing-style--describe the changes that must be
+   made to a system in order to add new types or new operations.  Which
+   organization would be most appropriate for a system in which new
+   types must often be added?  Which would be most appropriate for a
+   system in which new operations must often be added?
+
+   ----------------------------------------------------------------------
+
+   * Generic operations with explicit dispatch
+     * A new constructor must be built to represent a new data format
+       and uniquely tag it
+     * Each generic accessor method must be updated to support a new
+       tagged data format
+     * New generics must be written to support all possible data formats
+     (Not additive)
+   * Data-directed style
+     * To add a new format, operations must be registered with a
+       global lookup table using a unique tag
+     * To add a new operation, each type implementation must be
+       updated to support the new operation, and a new generic
+       function must be made to dispatch it
+   * Message-passing style
+     * To add a new type, a new constructor must be built that handles
+       the supported operations
+     * To add a new operation, all constructors must be updated to
+       support it
+
+   When new types must often be added, data-directed is more
+   appropriate, as people creating new types don't have to worry about
+   the operations contract changing frequently.
+
+   When new operations must often be added, message-passing is more
+   appropriate, as operations can be added independently from the type
+   implementations (which can be caught up later).