• Save
Principles Of Programing Languages
Upcoming SlideShare
Loading in...5
×
 

Principles Of Programing Languages

on

  • 1,438 views

Tom Flaherty at Ignite night at the Denver Open Source Users Group

Tom Flaherty at Ignite night at the Denver Open Source Users Group

Statistics

Views

Total Views
1,438
Slideshare-icon Views on SlideShare
1,435
Embed Views
3

Actions

Likes
2
Downloads
0
Comments
0

3 Embeds 3

http://www.slideshare.net 1
http://www.lmodules.com 1
https://www.linkedin.com 1

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Principles Of Programing Languages Principles Of Programing Languages Presentation Transcript

    • IMPLEMENTATIONS OF PRINCIPLES SMALLTALK Abstraction – Common behaviors factored into base classes. Encapsulation – Implementation details hidden. Manifest – Interface to object is its protocol. Regularity – Everything is an object. Security – Method not found Simplicity – Only messages passed to objects. Orthogonality– Hierarchal sub classing precludes true classification. – Requires multiple inheritance, delegation or AOP 4
    • IMPLEMENTATIONS OF PRINCIPLES LISP Abstraction – Common functions can be mapped to any list. Manifest – Functional inputs & outputs are apparent. Regularity – Everything is a function. Structure – All code & data in a lists with no distinction. Simplicity – Recursive control structures. Syntax – Changing interpretive syntax is trivial. 0 1 Infinity – Lists can have 0 1 or infinite number or elements. 5
    • IMPLEMENTATIONS OF PRINCIPLES WITH DYNAMIC LANGUAGES, STRONG TYPING, DSLS & JVM Automation – Dynamic languages reduce boilerplate. Defense – Strong typing catches errors that get through syntax. Labeling – Associative or property lists. Localized – Defaults in constructors minimize permutations. Portability – JVM & advanced IDEs: IntelliJ, Netbeans & Eclipse. Preservation – DSLs & dynamic languages align to business logic. 6
    • LANGUAGE PARADIGMS Intrinsic Implementation of Design Patterns “All roads lead to NFJS” see: Neal Ford – “Design Patterns in Dynamic Languages” Venkat Subramaniam - “Design Patterns in Java and Groovy” Dynamic Programming Ola’s Language Pyramid Polyglot Approach Neal Ford - http://github.com/nealford/presentations/blob/master/Design Patterns in Dynamic Languages (Neal Ford).pdf Venkat - http://www.agiledeveloper.com/presentations%5Cdesign_patterns_in_java_and_groovy.pdf 7
    • Dynamic Languages • Runtime extension & execution of behavior • Add code, extend objects & modify type system • Closures – functions that retain their creation context. • Duck Typing – freedom to call methods on any object. • JVM support, but not optimized 8
    • POLYGLOT PROGRAMMING • EMacs = C kernel + Lisp scripts. • Web is inherently polyglot: HTML, CSS & Javascript. • Pluses: Targeted productivity & performance. • Minuses: Increased complexity & tests • A full polyglot approach is a lot for in house. • The best approach to Ola’s Pyramid is to start with: Ruby on Rails, Grails or Scala’s Lift Dean Wampler http://polyglotprogramming.com/ 10
    • LANGUAGE INSPIRATIONS Smalltalk – Pure OO with dynamic programming Lisp – State of the art FP. Java – Mainstream OO & the JVM ecosystem Ruby – Brought back dynamic programming Groovy – Dynamic Java with sophisticated DSLs Scala – A Multi Paradigm OO & FP Hybrid Clojure – A concurrent & general purpose JVM Lisp 11
    • LISP • In 1987 & 1991 I wrote symbolic math libraries in Lisp. • FP & recursion were a positive influence on my C++ apps. • Integration with C scientific & OpenGL libs was tough. • Lisp needed a bigger ecosystem with JVM APIs. 12
    • SMALLTALK • In 1993 I wrote a Smalltalk persistence library ~ GORM. • But team wanted a fully transparent ORM. • Smalltalk had great dynamic programming. • But team went to too far seeking instant OO nirvana. • For individuals the GUI was great. The first IDE. • But the GUI had a bubble effect, adverse to SCM. 13
    • JAVA • Implemented Smalltalk’s OO & simulation paradigm. • Brought OO & the JVM to a large group of developers. • But bloated frameworks threaten productivity. • Java 7 closures & dynamic invocation are significant. • We would probably not be meeting if not for Java. JAVA FX • Innovative scene graph approach. • Scene graph API should be have callable by Java. • Would have made a great Groovy / Griffon DSL. • A missed opportunity for revitalizing Java GUI. 14
    • DJUG LANGUAGE PANEL APRIL 14, 2010 Ruby - Frederick Jean Groovy - Scala - Tom Flaherty Clojure - Daniel Glauser Polyglot - Venkat Subramaniam 20