Not Everything Is An Object
•Transferir como PPTX, PDF•
0 gostou•1,034 visualizações
A presentations highlighting the weaknesses in OO programming and showing how functional languages, in this case Clojure, could be the answer.
Recomendados
Mais conteúdo relacionado
Mais procurados
Mais procurados (20)
Destaque
Destaque (8)
Semelhante a Not Everything Is An Object
Semelhante a Not Everything Is An Object (20)
Último
Último (20)
Not Everything Is An Object
- 1. Not Everything is an Object By @garyshort
- 2. 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.
- 3. The Road to Here http://www.flickr.com/photos/fyngyrz/
- 4. Where we are Now http://www.flickr.com/photos/gtarded/
- 5. What OOP/D is Good For http://www.flickr.com/photos/gserafini/
- 6. What is it Not Good For? http://www.flickr.com/photos/aloshbennett/
- 7. The Solution
- 8. What Does it Mean to be Functional? First order functions Function like constructs Stateless Immutable data.
- 10. Java Interop
- 11. Fast
- 14. 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.
- 15. 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.
- 16. 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.
- 17. 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...
- 18. 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.
- 19. 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))
- 21. I’m Bored... Show me the Code! http://www.flickr.com/photos/peter_hasselbom/
- 22. Questions? gary@garyshort.org www.garyshort.org @garyshort
Notas do Editor
- 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