This is a preliminary outline by topics.  Just the topic name and (sometimes) a brief mention of content is given.   I usually figure a couple of minutes per topic slide (with 0-1 continuation slides) (and thats often too fast) so for a 45min-1hr talk I should have  20  narrow topics, with a couple over (usually optional) for slop.   A couple of the slides are transitional and they tend to go faster, so 20-25 slides is a good goal.   I seem to have 32, so some of these may be elided. 

1. Introduction - what the talk is about
2. Why should anyone care about types, in particular working programmers
3. Dante analogy  (cute pic)
4. Limbo (transition)
   
5. Fortran, Cobol, Lisp  - languages more or less outside the "typed programming language" model
6. Fortran - variables typed with initial character ("God is real..."), common blocks
   
7. Lisp - dynamic typing and scoping - so there is no way to assign a type to a value
8. Inferno (transition)
   
9. C  (other languages too, but focus on C)
   
10. lexically typed (and kind of strongly typed), but types are programmer assigned, not always checked (depends on compiler) and easily hidden/changed
11. Purgatorio (transition)
    
12. strong typing in object oriented systems (kittens and tigers)
    
13. Dynamic vs static typing
    
14. Java, C++ etc.
15. Object type systems and their problems without generics
16. interfaces vs inheritance
17. co/contra variance
18. Casting away types  (inheritance security/maintainability problems)
19. Rational numbers with singleton zero.
    
20. generics (ML functors)
    
21. c++ generics are turing complete
    
22. is ArrayList<Integer> a subtype (it is not a subclass) of ArrayList<Object>
    
23. type erasure
    
24. Paradiso (transition)
    
25. Lambda calculus (computability)
    
26. Typed lambda calculus
    
27. very strong typing
    
28. type inference
29. Categories (just mention)
    
30. New Languages (scala in particular) 
31. Wrap up