Wrong confirmation ID

Email
Favorite
Favorited ×
Download
Embed
Private Content
Copy and paste this code into your blog or website Copy Customize… Close
We have emailed the verification/download link to "".
Login to your email and click the link to download the file directly.

To request the link at a different email address, update it here. Close
Validation messages. Success message. Fail message.

Check your bulk/spam folders if you can't find our mail.

Loading…

Flash Player 9 (or above) is needed to view presentations.
We have detected that you do not have it on your computer. To install it, go here.

+ Follow

Not Everything Is An Object

by Gary Short on Feb 02, 2010

1,753 views

A presentations highlighting the weaknesses in OO programming and showing how functional languages, in this case Clojure, could be the answer.

More…

A presentations highlighting the weaknesses in OO programming and showing how functional languages, in this case Clojure, could be the answer.

Less

1 Embed 4

http://www.slideshare.net

Statistics

Favorites: 0
Downloads: 15
Comments: 0
Embed Views: 4
Views on SlideShare: 1,749
Total Views: 1,753

Programming languages pre date computers themselves...Starting in 1842 and finishing in 1843 Ada Lovelace translated a memoir of an Italian mathematician on Charles Baggage’s newest proposed machine... the Analytical Engine. The article she wrote contained the entire specification of how to calculate Bernoulli numbers with the Engine. This is believed to be the first ever computer program.Then in the 1940’s along comes the first recognisable computers and we get programming languages to go with them...1943 - Plankalkül (KonradZuse) 1943 - ENIAC coding system1949 - C-10In the 1950s the first three modern programming languages whose descendants are still in widespread use today were designed:FORTRAN (1955), the "FORmulaTRANslator", invented by John Backus et al.; LISP, the "LIStProcessor", invented by John McCarthy et al.; COBOL, the COmmonBusiness Oriented Language, created by the Short Range Committee, heavily influenced by Grace Hopper. 1951 - Regional Assembly Language1952 - Autocode1954 - FORTRAN1954 - IPL (forerunner to LISP) 1955 - FLOW-MATIC (forerunner to COBOL) 1957 - COMTRAN (forerunner to COBOL) 1958 - LISP1958 - ALGOL 581959 - FACT (forerunner to COBOL) 1959 - COBOL1962 - APL1962 - Simula1964 - BASIC1964 - PL/I1970 - Pascal1970 - Forth1972 - C1972 - Smalltalk1972 - Prolog1973 - ML1975 - Scheme1978 - SQL (initially only a query language, later extended with programming constructs) 1983 - Ada1983 - C++1985 - Eiffel1986 - Erlang1987 - Perl1989 - FL (Backus) 1990 - Haskell1991 - Python1991 - Java1993 - Ruby1993 - Lua1994 - ANSI Common Lisp1995 - JavaScript1995 - PHP1997 - Rebol2000 - C#2008 - JavaFX Script
Through the 1990s and up until today, OO languages are in the ascendency due to: the GUI. A GUI lends itself well to the concept of discrete objects due to: having their own knowledge and behaviour messaging each other in an event driven model. Low cost of memory
Modelling object graph where objects are passing messagesModelling state changeModelling problem domains where the actors are hierarchal in natureEvent driven programming
Object graphs or sub graphs mean lots of shared dataShared data bad for concurrencyRequires lockingLocking is bad because it is either coarse grained which is expensive in time or it’s fine grained which is expensive in terms of management.Locking management is hard because there is no compiler or VM support, it’s down to you to work out how to do itExample: lock objects by alphabetical orderYou have to remember to do it that wayErrors are next to impossible to test for, hard to debug
Functional programming
First order functions means that functions can be treated like values and can be return from and passed into other functionsFunction like constructs means that flow control constructs are more like functions in that they may return the last value etcStateless because it’s functional in the sense of a mathematical function. Values are passed in, those values are operated upon and a new value is passed out. The function does not depend on any outside state. If the function is pure it has no side effects.The advantage of this is that a pure function is simple to understand, the whole essence of the function is encapsulated within the function itself. Easy to testEasy to debugConcurrency – if there is no dependency on shared state then work can be easily parallelised.
Pure functional language = no side effects allowedImpure functional language = side effects are not restrictedLockless concurrency does not mean there are no locks, just that the language manages them for you.
Nil is null and is treated as false kinda sucks.Here is a value and it is trueHere is a value and it is falseNil/null should mean there is no value.
Mutable collection you can modify the collection: add, remove etcImmutable collections cannot be modified but instead you get a new copy of the collection with the changes.Key idea is that copies are cheap, both in terms of time and memoryHow does this work?Copies of mutable collections take time and memory, copying 100 items needs 100+ operations but..Because data is immutable, it’s not going to change, so I don’t have to copy the data, just provide a pointer to it.If I want your data with a new member added then I get a collection which shares most of the data but has my deltas
Clojure favours equality but this is not a big problem as data is immutable and so objects and object graphs have a hash, since this can’t change equality simply compares the hash values and not the data in the graphThe only exception to this is string comparisons because Clojure strings are just Java stringsNot a big problem as string comparison is efficient in JavaFirst check identityThen check lengthThen check equality
Vars must be defined before first useThey must be def’d but not necessarily boundWhat is a macro?A macro is a function that modifies reader data
If is a special form as code execution is conditionalIf the condition is true then a will be returnedIf the condition is false then b will be returnedThe ? Denotes that b is optionalI said before that if were function likeFirst example returns the result of hungover if true else the result of happySecond example returns the result of drink else nil
Tail RecursionSpecial form of recursion whereby the last thing a function does is to call itselfFunctions need a stack frameCall a function 1,000 times recursively then you need 1,000 stackframesBut if calling the function is the last thing you are going to doThen you are not coming back to the calling functionSo there’s an optimisation where you can just overwrite the stackframe of the calling funcSo you only ever need one stack frameMost lisp dialects have this tail recursion optimisationClojure doesn’t as there is not tail recursion on the JMV

Not Everything Is An Object — Presentation Transcript

Not Everything is an Object
By @garyshort
Agenda
The road to here
Where we are now
What OOD/P is good for
What it’s not good for
The solution
Demo
Questions.
The Road to Here
http://www.flickr.com/photos/fyngyrz/
Where we are Now
http://www.flickr.com/photos/gtarded/
What OOP/D is Good For
http://www.flickr.com/photos/gserafini/
What is it Not Good For?
http://www.flickr.com/photos/aloshbennett/
The Solution
What Does it Mean to be Functional?
First order functions
Function like constructs
Stateless
Immutable data.
Clojure
A Lisp
Dynamic
Functional
Impure
“Lockless” Concurrency
Macros
- JVM
- Java Interop
- Fast
- Persistent collections
- Easy to learn.
Introduction to Clojure
Java.Lang.Object
Arbitrary sized numbers
Ratios: 18/20
Nil is null and is treated as false.
Persistent Collections
Immutable
Cheap to copy
Examples
(1 2 3)
List – sequential lookup time
[1 2 3]
Vector – logarithmic lookup time
{“key” 1, 3 7, “foo” “bar”}
Hashmap – unordered, key value pairs.
Equality Vs Identity
Equality
Two objects are equal
Two cylinders maybe equal if their volumes are equal
Identity
Two pointers to the same object
Clojure favours equality :-O.
Clojure is Impure so has Mutability
Var
Mutable pointer to immutable data
You can’t change the data
But you can change what data the var points to
But vars hold global data, function defs etc .
This data won’t change
So why are vars mutable?
So we can patch running software. 
The Reader
Other programming languages
Compiler
Text -> lexing and parsing -> AST
Clojure
The Reader
Text -> lexing and parsing -> Literals (Data)
As soon as it reads a complete literal it’s passed to...
The Evaluator
Compile Phase
Traverses the data
Symbol evaluation
Symbols evaluate into Vars
Symbol Dog evaluates to a var in the current namespace
Symbol MyPets/Dog evaluates to var in namespace MyPets
List evaluation
Lists evaluate into function calls
(+ 1 2 3)
Process macros
Execute phase
Effects the special forms
Calls functions.
Special Forms
Reserved symbol
Denotes special list evaluation
Not a function call – it’s “something else”
Def, if, do, let, quote, var, fn, loop, recur, throw, try, ., new, set!
If a list starts with any of those it’s evaluated in a special way particular to that form
(if condition a b?)
(if (been_drinking) (hungover) (happy))
(if (have_beers) (drink))
Tail Recursion
http://www.flickr.com/photos/43911015@N05
I’m Bored... Show me the Code!
http://www.flickr.com/photos/peter_hasselbom/
Questions?
gary@garyshort.org
www.garyshort.org
@garyshort

Not Everything Is An Object

by Gary Short on Feb 02, 2010

Accessibility

Categories

Upload Details

Usage Rights

1 Embed 4

Statistics

Not Everything Is An Object — Presentation Transcript