CSC302 2006S, Class 24: Beyond Java

Admin:
* No readings for break.
* Insufficient comments on today's readings.
* Have a great break! (But not until after class.)
* A lame excuse: "I skipped class on Wednesday, so I didn't know about the homework for today."
* Late: Alex
* Missing: Dimitar

Overview:
* Dynamic languages
* Some questions
* Tate's criteria

/What does Tate mean by dynamic languages, and why are they so hot?/
* Dynamic typing: Types are determined at runtime, not compile time
  * Programmers have to be more careful
  * Programmers don't have to waste time declaring variables
* Support for metaprogramming, including change the program (including classes) at runtime
  * Metaprogramming permits more concise/abstract programming
  * Supports AOP - Aspect Oriented Programming
    * Aids programmers in the separation of concerns
    * Contrast to Object-oriented model: Group in object
      * In AOP, write parts separately something automatically combines parts
* Code as first-class value - Pass code blocks as parameters
  * If he'd learned LISP, he'd think about returning code blocks
    as values, too
* Interpreted
  * Flexible
  * Faster code/test/debug cycle - Supports agile development
* Continuations?  (Not really dynamic, but hot nontheless)
    
* Likes them because they can handle "any problem"

/Small-picture Questions/

* Why are we safe without compile-time typing
  * VM's and sandboxes?  Crashes are safer.
  * Programmers work around it anyway.
    * And Java does a bad job.
  * New programming model (agile/XP): UNIT TESTING
* What did you think of kayaking parts?

/Big-Picture Questions/

* Why did Sam assign "Beyond Java"?
  * To encourage you to learn Ruby (it's "wicked sweet")
  * To make you read some book, and not just articles, and it's comparatively cheap 
  * A non-academic perspective (we traditionally read academic article)
    * Hard to make comparison?
    * Java includes the standard 'platforms' (Eclipse (IDE), Tomcat (JSP), Hibernate (Persistence), Swing (GUI), Spring, Ant (Make), ...) - Will we see more side-by-side development than sequential development
    * Different perspective on what programming is: Agile and Aspect
  * To encourage you to think more broadly about what OOP is, since Java is your primary OOP model
  * "Critical reading" of a language
  * Design criteria: What makes a language successful?
    * MARKETING and C syntax
    * Convenience
    * "Killer App(s)" 
  * Design criteria for a modern language
  * A historical reading from today

* Should we replace Java in 152?  (With what?)
  * Arguing replace: Alex, Davis, David, Brad
    * Far too complicated for its own good (and therefore for students)
    * Java is on its way out.  Grinnell should avoid crash.
    * Grinnell should teach Ruby because Scarlet is a similar color.
      * Ruby has a lot of features that support newer programming methodologies that our students should learn.
    * We should teach the techniques that make people more productive.
    * If you can learn Ruby, then you can learn Java (particularly since you learn the C syntax in 201)
  * Arguing keep: Michael, Angeline, Peter, Mark
    * It's still the dominant language ; Support folks who stop with 152.  (Grinnell is responsible for teaching you real-world skills)
    * If you can learn Java, then you can learn Ruby or any other object-oriented language.  (We can teach real OOP in Java.)
    * You don't need to teach the more complicated things that the bozos in the other group are complaining about
    * Metaprogramming is too difficult for beginning students.
    * Future successful languages will use JVM

* Should we teach Tomcat, Hibernate, Swing, Spring, Ant, etc.  (Where?)

* Do you agree that Java is on its way out?