Haskell, eine rein funktionale Programmiersprache
|
|
|
- Johann Kohler
- vor 10 Jahren
- Abrufe
Transkript
1 Grundlegendes Typsystem Weiteres Gemeinschaft Haskell, eine rein funktionale Programmiersprache Ingo Blechschmidt Augsburger Linux-Infotag 27. März 2010
2
3 Grundlegendes Typsystem Weiteres Gemeinschaft 1 Grundlegendes Keine Variablen Keine Nebeneffekte Keine Ein-/Ausgabe Erste Beispiele: Aufsummieren und Quicksort 2 Typsystem Grundtypen Typerschließung Aktionstypen 3 Weitere Fähigkeiten Aktionsarten Parser-Aktionen Bedarfsauswertung QuickCheck 4 Gemeinschaft Hackage Größere Anwendungen Einstiegspunkte
4 Grundlegendes Typsystem Weiteres Gemeinschaft Variablen Nebeneffekte Eingabe/Ausgabe Beispiele Über Haskell Hochsprache, rein funktional, statisch stark typisiert, nicht-strikt Sprachspezifikation durch ein Komitee Veröffentlichung von Haskell 1.0: 1990 Kompiliert und interpretiert
5 Grundlegendes Typsystem Weiteres Gemeinschaft Variablen Nebeneffekte Eingabe/Ausgabe Beispiele Imperative Sprachen Kennzeichen imperativer Sprachen: veränderliche Variablen Nebeneffekte Anweisungen
6 Grundlegendes Typsystem Weiteres Gemeinschaft Variablen Nebeneffekte Eingabe/Ausgabe Beispiele Haskell ist komisch! Haskell ist rein funktional: keine veränderliche Variablen keine Nebeneffekte keine Anweisungen
7
8 Grundlegendes Typsystem Weiteres Gemeinschaft Variablen Nebeneffekte Eingabe/Ausgabe Beispiele Keine veränderliche Variablen # Perl sub main { my $radius = 42; my $quadriert = $radius ** 2; my $flaeche = $quadriert * pi; print $flaeche; }
9 Grundlegendes Typsystem Weiteres Gemeinschaft Variablen Nebeneffekte Eingabe/Ausgabe Beispiele Keine veränderliche Variablen # Perl sub main { my $radius = 42; my $quadriert = $radius ** 2; my $flaeche = $quadriert * pi; print $flaeche; } -- Haskell main = let radius = 42 quadriert = radiusˆ2 flaeche = quadriert * pi in print flaeche
10 Grundlegendes Typsystem Weiteres Gemeinschaft Variablen Nebeneffekte Eingabe/Ausgabe Beispiele Keine veränderliche Variablen # Perl sub main { my $radius = 42; my $quadriert = $radius ** 2; my $flaeche = $quadriert * pi; print $flaeche; } -- Haskell main = let flaeche = quadriert * pi quadriert = radiusˆ2 radius = 42 in print flaeche
11 Grundlegendes Typsystem Weiteres Gemeinschaft Variablen Nebeneffekte Eingabe/Ausgabe Beispiele Keine veränderliche Variablen # Perl sub main { my $radius = 42; my $quadriert = $radius ** 2; my $flaeche = $quadriert * pi; print $flaeche; } -- Haskell main = print flaeche where flaeche = quadriert * pi quadriert = radiusˆ2 radius = 42
12 Grundlegendes Typsystem Weiteres Gemeinschaft Variablen Nebeneffekte Eingabe/Ausgabe Beispiele Keine Nebeneffekte # Perl my $a = f($x); my $b = f($x);...; # Ist $a == $b?
13 Grundlegendes Typsystem Weiteres Gemeinschaft Variablen Nebeneffekte Eingabe/Ausgabe Beispiele Keine Nebeneffekte # Perl my $a = f($x); my $b = f($x);...; # Ist $a == $b? -- Haskell let a = f x b = f x in a == b gilt stets.
14 Grundlegendes Typsystem Weiteres Gemeinschaft Variablen Nebeneffekte Eingabe/Ausgabe Beispiele Keine Nebeneffekte # Perl my $a = f($x); my $b = f($x);...; # Ist $a == $b? -- Haskell let a = f x b = f x in a == b gilt stets. Gleiche Argumente gleiche Rückgaben Keine Ein-/Ausgabe, keine Zustandsveränderungen,... Rein lokales Codeverständnis! Tiefgreifende Optimierungsmöglichkeiten!
15 Grundlegendes Typsystem Weiteres Gemeinschaft Variablen Nebeneffekte Eingabe/Ausgabe Beispiele Keine Eingabe/Ausgabe let x = getline in print (x ++ x) vs. print (getline ++ getline)
16 Grundlegendes Typsystem Weiteres Gemeinschaft Variablen Nebeneffekte Eingabe/Ausgabe Beispiele Keine Eingabe/Ausgabe -- Compile-Zeit-Fehler! let x = getline in print (x ++ x) vs. -- Compile-Zeit-Fehler! print (getline ++ getline)
17 Grundlegendes Typsystem Weiteres Gemeinschaft Variablen Nebeneffekte Eingabe/Ausgabe Beispiele Keine Eingabe/Ausgabe -- Compile-Zeit-Fehler! let x = getline in print (x ++ x) vs. -- Compile-Zeit-Fehler! print (getline ++ getline) Aktionen Werte Explizite Unterscheidung durchs Typsystem (s. gleich)
18 Grundlegendes Typsystem Weiteres Gemeinschaft Variablen Nebeneffekte Eingabe/Ausgabe Beispiele Beispiel: Aufsummieren einer Zahlenliste Deklaration durch Musterabgleich: sum [] = 0 sum (x:xs) = x + sum xs Beispielauswertung: sum [1,2,3] == 1 + sum [2,3] == 1 + (2 + sum [3]) == 1 + (2 + (3 + sum [])) == 1 + (2 + (3 + 0)) == 6
![durch Musterabgleich: sum [] = 0 sum (x:xs) = x + sum xs Beispielauswertung: sum](/docs-images/45/5943351/images/page_18.jpg "[1,2,3] == 1 + sum [2,3] == 1 + (2 + sum [3]) == 1 + (2 + (3 + sum [])) == 1 + (2")
19 Grundlegendes Typsystem Weiteres Gemeinschaft Variablen Nebeneffekte Eingabe/Ausgabe Beispiele Beispiel: Quicksort qsort [] = [] qsort (x:xs) = qsort kleinere ++ [x] ++ qsort groessere where kleinere = [ y y <- xs, y < x ] groessere = [ y y <- xs, y >= x ]
![qsort [] = [] qsort (x:xs) = qsort kleinere ++ [x] ++ qsort](/docs-images/45/5943351/images/page_19.jpg "groessere where kleinere = [ y y <- xs, y < x ] groessere = [ y")
20 Grundlegendes Typsystem Weiteres Gemeinschaft Grundtypen Typerschließung Aktionstypen Werte und Typen Statische starke Typisierung; jeder Wert ist von genau einem Typ. Keine impliziten Typumwandlungen Enorm hilfreich!
21 Enorm hilfreich!
22 Grundlegendes Typsystem Weiteres Gemeinschaft Grundtypen Typerschließung Aktionstypen Werte und Typen Statische starke Typisierung; jeder Wert ist von genau einem Typ. Keine impliziten Typumwandlungen Enorm hilfreich!
23 Grundlegendes Typsystem Weiteres Gemeinschaft Grundtypen Typerschließung Aktionstypen Werte und Typen Statische starke Typisierung; jeder Wert ist von genau einem Typ. Keine impliziten Typumwandlungen Enorm hilfreich! Primitive Typen: "Hallo, Welt!" :: String True :: Bool 37 :: Integer (beliebige Größe) 37 :: Int (mind. 31 Bit) Zusammengesetzte Typen: [ A, B, C ] :: [Char] [[1,2], [3], []] :: [[Integer]]
24 Grundlegendes Typsystem Weiteres Gemeinschaft Grundtypen Typerschließung Aktionstypen Werte und Typen (Forts.) Funktionstypen: head :: [a] -> a -- Bsp.: head [1,2,3] == 1 tail :: [a] -> [a] -- Bsp.: tail [1,2,3] == [2,3] -- Operatoren: (&&) :: Bool -> Bool -> Bool (++) :: [a] -> [a] -> [a]
25 java.io.inputstreamreader. '.
26 Grundlegendes Typsystem Weiteres Gemeinschaft Grundtypen Typerschließung Aktionstypen Automatische Typerschließung Automatische Erschließung nicht angegebener Typen durch den Compiler greet name = "Hallo " ++ name ++ "!"
27 Grundlegendes Typsystem Weiteres Gemeinschaft Grundtypen Typerschließung Aktionstypen Automatische Typerschließung Automatische Erschließung nicht angegebener Typen durch den Compiler greet :: String -> String greet name = "Hallo " ++ name ++ "!"
28 Grundlegendes Typsystem Weiteres Gemeinschaft Grundtypen Typerschließung Aktionstypen Automatische Typerschließung Automatische Erschließung nicht angegebener Typen durch den Compiler greet :: String -> String greet name = "Hallo " ++ name ++ "!" dup xs = xs ++ xs -- Bsp.: dup [1,2,3] == [1,2,3,1,2,3]
29 Grundlegendes Typsystem Weiteres Gemeinschaft Grundtypen Typerschließung Aktionstypen Automatische Typerschließung Automatische Erschließung nicht angegebener Typen durch den Compiler greet :: String -> String greet name = "Hallo " ++ name ++ "!" dup :: [a] -> [a] dup xs = xs ++ xs -- Bsp.: dup [1,2,3] == [1,2,3,1,2,3]
30 Grundlegendes Typsystem Weiteres Gemeinschaft Grundtypen Typerschließung Aktionstypen Typen von Ein-/Ausgabe-Operationen IO Foo meint: Wert vom Typ Foo produzierende IO-Aktion Häufig benutzte Ein-/Ausgabe-Operationen: getline :: IO String putstr :: String -> IO () readfile :: FilePath -> IO String
31 Grundlegendes Typsystem Weiteres Gemeinschaft Grundtypen Typerschließung Aktionstypen Typen von Ein-/Ausgabe-Operationen IO Foo meint: Wert vom Typ Foo produzierende IO-Aktion Häufig benutzte Ein-/Ausgabe-Operationen: getline :: IO String putstr :: String -> IO () readfile :: FilePath -> IO String Zum früheren Beispiel: main :: IO () main = do x <- getline print (x ++ x) main :: IO () main = do x <- getline y <- getline print (x ++ y)
32 Grafik gestohlen von: Simon Peyton Jones
33 Grundlegendes Typsystem Weiteres Gemeinschaft Aktionsarten Parser Laziness QuickCheck Arten von Aktionen IO (Eingabe/Ausgabe) Parser Reader (vererbende Umgebung) State (veränderlicher Zustand) Writer (Logging) Cont (Continuations)...
34 Grundlegendes Typsystem Weiteres Gemeinschaft Aktionsarten Parser Laziness QuickCheck Parser-Aktionen Parser für Perl-Bezeichner (z.b. perlbezeichner :: Parser String perlbezeichner = do sigil <- oneof "$@%&" name <- many alphanum return (sigil : name) Dabei verwendete Funktionen aus Parser-Bibliothek: oneof :: [Char] -> Parser Char alphanum :: Parser Char many :: Parser a -> Parser [a]
35 Grundlegendes Typsystem Weiteres Gemeinschaft Aktionsarten Parser Laziness QuickCheck Bedarfsauswertung Zeile aus Datei ausgeben main = do daten <- readfile "große-datei.txt" print (lines daten!! 99)
36 Grundlegendes Typsystem Weiteres Gemeinschaft Aktionsarten Parser Laziness QuickCheck Bedarfsauswertung Zeile aus Datei ausgeben main = do daten <- readfile "große-datei.txt" print (lines daten!! 99) Auswertung von Ausdrücken erst dann, wenn Ergebnisse wirklich benötigt Wegabstraktion des Speicherkonzepts! Somit Fähigkeit für unendliche Datenstrukturen: Potenzreihen, Zeitreihen, Entscheidungsbäume,...
37 Grundlegendes Typsystem Weiteres Gemeinschaft Aktionsarten Parser Laziness QuickCheck Bedarfsauswertung (Forts.) natürlichezahlen = [1..] -- natürlichezahlen == [1,2,3,4,...]
38 Grundlegendes Typsystem Weiteres Gemeinschaft Aktionsarten Parser Laziness QuickCheck Bedarfsauswertung (Forts.) natürlichezahlen = [1..] -- natürlichezahlen == [1,2,3,4,...] ungeradezahlen = filter odd [1..] -- ungeradezahlen == [1,3,5,7,...]
39 Grundlegendes Typsystem Weiteres Gemeinschaft Aktionsarten Parser Laziness QuickCheck Bedarfsauswertung (Forts.) natürlichezahlen = [1..] -- natürlichezahlen == [1,2,3,4,...] ungeradezahlen = filter odd [1..] -- ungeradezahlen == [1,3,5,7,...] fibs = 0 : 1 : zipwith (+) fibs (tail fibs) -- fibs == [0,1,1,2,3,5,8,13,21,34,...]
40 Grundlegendes Typsystem Weiteres Gemeinschaft Aktionsarten Parser Laziness QuickCheck QuickCheck # Perl is(sqrt(0), 0, "sqrt(0) ist ok"); is(sqrt(1), 1, "sqrt(1) ist ok"); is(sqrt(4), 2, "sqrt(4) ist ok"); is(sqrt(9), 3, "sqrt(9) ist ok"); is(sqrt(16), 4, "sqrt(16) ist ok");...; #??
41 Grundlegendes Typsystem Weiteres Gemeinschaft Aktionsarten Parser Laziness QuickCheck QuickCheck # Perl is(sqrt(0), 0, "sqrt(0) ist ok"); is(sqrt(1), 1, "sqrt(1) ist ok"); is(sqrt(4), 2, "sqrt(4) ist ok"); is(sqrt(9), 3, "sqrt(9) ist ok"); is(sqrt(16), 4, "sqrt(16) ist ok");...; #?? -- Haskell mit QuickCheck propsqrt :: Double -> Bool propsqrt x = sqrt (x * x) == x
42 Grundlegendes Typsystem Weiteres Gemeinschaft Aktionsarten Parser Laziness QuickCheck QuickCheck (Forts.) propsqrt :: Double -> Bool propsqrt x = sqrt (x * x) == x ghci> quickcheck propsqrt Falsifiable, after 6 tests: -4
43 Grundlegendes Typsystem Weiteres Gemeinschaft Aktionsarten Parser Laziness QuickCheck QuickCheck (Forts.) propsqrt :: Double -> Bool propsqrt x = sqrt (x * x) == x ghci> quickcheck propsqrt Falsifiable, after 6 tests: -4 propsqrt :: Double -> Bool propsqrt x = sqrt (x * x) == abs x ghci> quickcheck propsqrt OK, passed 100 tests.
44 Grundlegendes Typsystem Weiteres Gemeinschaft Aktionsarten Parser Laziness QuickCheck QuickCheck (Forts.) Spezifikationsüberprüfung durch zufällig generierte Stichproben Enorm hilfreich!
45 Grundlegendes Typsystem Weiteres Gemeinschaft Aktionsarten Parser Laziness QuickCheck QuickCheck (Forts.) Spezifikationsüberprüfung durch zufällig generierte Stichproben Enorm hilfreich! Implementierung durch Typklasse: class Arbitrary a where arbitrary :: Gen a Instanzen von Arbitrary nicht nur für primitive, sondern automatisch auch für zusammengesetzte Typen
46 Grundlegendes Typsystem Weiteres Gemeinschaft Hackage Größere Anwendungen Einstiegspunkte Paketarchiv Hackage Entstehung 2007, mittlerweile Pakete Installationswerkzeug cabal-install
47 Grundlegendes Typsystem Weiteres Gemeinschaft Hackage Größere Anwendungen Einstiegspunkte Größere Anwendungen Glasgow Haskell Compiler (GHC) darcs, verteiltes Versionskontrollsystem xmonad, tiling Fenstermanager Pugs, Perl-6-Prototyp Cryptol, Sprache für Kryptographie Criterion, Benchmarktoolkit
48 Grundlegendes Typsystem Weiteres Gemeinschaft Hackage Größere Anwendungen Einstiegspunkte zum Herumspielen im Browser: interaktive Haskell-Shell: $ apt-get install ghc6 $ ghci Buch: Real World Haskell, O Reilly Teile dieses Vortrags inspiriert von einem Vortrag von Audrey Tang: audreyt/osdc/ haskell.xul
49 Grundlegendes Typsystem Weiteres Gemeinschaft Hackage Größere Anwendungen Einstiegspunkte Bonusfolien
50 Typsystem FFI Nebenläufigkeit Bildquellen Bonusfolien 5 Details zum Typsystem Typklassen Benutzerdefinierte Datentypen Umgang mit fehlenden Werten 6 Foreign Function Interface 7 Nebenläufigkeit Software Transactional Memory Data Parallel Haskell 8 Bildquellen
51 Typsystem FFI Nebenläufigkeit Bildquellen Typklassen Datentypen Fehlende Werte Typklassen (= Schnittstellen, Rollen) Typklassen für ad-hoc Polymorphismus: add37 x = x Bsp.: add37 5 == 42
52 Typsystem FFI Nebenläufigkeit Bildquellen Typklassen Datentypen Fehlende Werte Typklassen (= Schnittstellen, Rollen) Typklassen für ad-hoc Polymorphismus: add37 :: a -> a add37 x = x Bsp.: add37 5 == 42
53 Typsystem FFI Nebenläufigkeit Bildquellen Typklassen Datentypen Fehlende Werte Typklassen (= Schnittstellen, Rollen) Typklassen für ad-hoc Polymorphismus: add37 :: (Num a) => a -> a add37 x = x Bsp.: add37 5 == 42
54 Typsystem FFI Nebenläufigkeit Bildquellen Typklassen Datentypen Fehlende Werte Typklassen (= Schnittstellen, Rollen) Typklassen für ad-hoc Polymorphismus: add37 :: (Num a) => a -> a add37 x = x Bsp.: add37 5 == 42 min x y = if x <= y then x else y -- Bsp.: min == 17
55 Typsystem FFI Nebenläufigkeit Bildquellen Typklassen Datentypen Fehlende Werte Typklassen (= Schnittstellen, Rollen) Typklassen für ad-hoc Polymorphismus: add37 :: (Num a) => a -> a add37 x = x Bsp.: add37 5 == 42 min :: (Ord a) => a -> a -> a min x y = if x <= y then x else y -- Bsp.: min == 17
56 Typsystem FFI Nebenläufigkeit Bildquellen Typklassen Datentypen Fehlende Werte Typklassen (= Schnittstellen, Rollen) Typklassen für ad-hoc Polymorphismus: add37 :: (Num a) => a -> a add37 x = x Bsp.: add37 5 == 42 min :: (Ord a) => a -> a -> a min x y = if x <= y then x else y -- Bsp.: min == 17 Deklaration: class Num a where (+) :: a -> a -> a (-) :: a -> a -> a (*) :: a -> a -> a...
57 Typsystem FFI Nebenläufigkeit Bildquellen Typklassen Datentypen Fehlende Werte Benutzerdefinierte Datentypen data Tree = Leaf Int Fork Tree Tree Konstruktoren: Leaf :: Int -> Tree und Fork :: Tree -> Tree -> Tree
58 Typsystem FFI Nebenläufigkeit Bildquellen Typklassen Datentypen Fehlende Werte Benutzerdefinierte Datentypen data Tree = Leaf Int Fork Tree Tree Konstruktoren: Leaf :: Int -> Tree und Fork :: Tree -> Tree -> Tree beispielbaum = Fork (Fork (Leaf 17) (Leaf 37)) (Fork (Fork (Leaf 42) (Leaf 0)) (Leaf 41))
59 Typsystem FFI Nebenläufigkeit Bildquellen Typklassen Datentypen Fehlende Werte Benutzerdefinierte Datentypen data Tree = Leaf Int Fork Tree Tree Konstruktoren: Leaf :: Int -> Tree und Fork :: Tree -> Tree -> Tree beispielbaum = Fork (Fork (Leaf 17) (Leaf 37)) (Fork (Fork (Leaf 42) (Leaf 0)) (Leaf 41)) komischerbaum = Fork (Fork (Leaf 23) komischerbaum)
60 Typsystem FFI Nebenläufigkeit Bildquellen Typklassen Datentypen Fehlende Werte Benutzerdefinierte Datentypen (Forts.) data Tree = Leaf Int Fork Tree Tree
61 Typsystem FFI Nebenläufigkeit Bildquellen Typklassen Datentypen Fehlende Werte Benutzerdefinierte Datentypen (Forts.) data Tree = Leaf Int Fork Tree Tree data Tree a = Leaf a Fork (Tree a) (Tree a)
62 Typsystem FFI Nebenläufigkeit Bildquellen Typklassen Datentypen Fehlende Werte Benutzerdefinierte Datentypen (Forts.) data Tree = Leaf Int Fork Tree Tree data Tree a = Leaf a Fork (Tree a) (Tree a) -- Gesamtzahl Blätter zählen size :: Tree a -> Integer size (Leaf _) = 1 size (Fork links rechts) = size links + size rechts
63 Typsystem FFI Nebenläufigkeit Bildquellen Typklassen Datentypen Fehlende Werte Benutzerdefinierte Datentypen (Forts.) data Tree = Leaf Int Fork Tree Tree data Tree a = Leaf a Fork (Tree a) (Tree a) -- Gesamtzahl Blätter zählen size :: Tree a -> Integer size (Leaf _) = 1 size (Fork links rechts) = size links + size rechts -- Blätter inorder als Liste zurückgeben inorder :: Tree a -> [a] inorder (Leaf x) = [x] inorder (Fork links rechts) = inorder links ++ inorder rechts
64 Typsystem FFI Nebenläufigkeit Bildquellen Typklassen Datentypen Fehlende Werte Umgang mit fehlenden Werten Null References: The Billion Dollar Mistake (Tony Hoare) In Haskell: Explizite Kennzeichnung von möglicherweise fehlenden Werten durch Maybe-Typen data Maybe a = Nothing Just a lookupfarbe :: String -> Maybe Color -- Bsp.: lookupfarbe "Simpsons" == Just YELLOW lookupfarbe "Simqsons" == Nothing
65 Typsystem FFI Nebenläufigkeit Bildquellen Typklassen Datentypen Fehlende Werte Maybe-Ketten Anwendbarkeit des syntaktischen Zuckers von Aktionstypen für Maybe: berechnea :: Integer -> Maybe String berechneb :: Integer -> Maybe [Double] berechnec :: [Double] -> Maybe String berechne :: Integer -> Maybe String berechne x = do teil1 <- berechnea x teil2 <- berechneb x teil2 <- berechnec teil2 return (teil1 ++ teil2)
66 Typsystem FFI Nebenläufigkeit Bildquellen Foreign Function Interface {-# INCLUDE <math.h> #-} foreign import ccall unsafe "sin" c sin :: CDouble -> CDouble Einbindung von (C-)Bibliotheken Keine besondere Handhabung der importierten Funktionen Callbacks aus dem C-Code heraus möglich
67 Typsystem FFI Nebenläufigkeit Bildquellen Software Transactional Memory Data Parallel Haskell Nebenläufigkeit Aufgabenparallelismus: Software Transactional Memory Datenparallelismus: Data Parallel Haskell weiter weiter
68 Typsystem FFI Nebenläufigkeit Bildquellen Software Transactional Memory Data Parallel Haskell Traditionelles Locking Schwierigkeiten bei traditionellem Locking: nichtlokales Denken, Deadlocks, Livelocks, Prioritätsinversion lock-based programs do not compose
69 Typsystem FFI Nebenläufigkeit Bildquellen Software Transactional Memory Data Parallel Haskell Traditionelles Locking (Forts.) 1 # Perl $x->withdraw(3); $y->deposit(3); # Race Condition!
70 Typsystem FFI Nebenläufigkeit Bildquellen Software Transactional Memory Data Parallel Haskell Traditionelles Locking (Forts.) 1 # Perl $x->withdraw(3); $y->deposit(3); # Race Condition! 2 $x->lock(); $y->lock(); $x->withdraw(3); $y->deposit(3); $y->unlock(); $x->unlock();
71 Typsystem FFI Nebenläufigkeit Bildquellen Software Transactional Memory Data Parallel Haskell Traditionelles Locking (Forts.) 1 # Perl $x->withdraw(3); $y->deposit(3); # Race Condition! 2 $x->lock(); $y->lock(); $x->withdraw(3); $y->deposit(3); $y->unlock(); $x->unlock(); 3 { $x->lock(); $y->lock();...; } vs. { $y->lock(); $x->lock();...; } # Deadlock!
72 Typsystem FFI Nebenläufigkeit Bildquellen Software Transactional Memory Data Parallel Haskell Software Transactional Memory Transaktionsvorstellung: Unabhängige, einfädige Ausführung jeder Transaktion Implementierung durch Schreiben in temporären Puffer; Commit nur, wenn gelesene Variablen noch unverändert, sonst Neustart Vorteile: keine expliziten Locks, keine Race Conditions, Komponierbarkeit
73 Typsystem FFI Nebenläufigkeit Bildquellen Software Transactional Memory Data Parallel Haskell Software Transactional Memory (Forts.) -- Haskell withdraw :: Account -> Int -> STM () deposit :: Account -> Int -> STM () atomically $ do withdraw x 3 deposit y 3
74 Typsystem FFI Nebenläufigkeit Bildquellen Software Transactional Memory Data Parallel Haskell Flat/Nested Data Parallelism Flat Data Parallelism: for my $i (1..$N) { work($i); } Parallelisierung durch einfaches Aufteilen der Fälle auf die Prozessoren Effizienz verschenkt, wenn work() selbst parallel arbeiten könnte!
75 Typsystem FFI Nebenläufigkeit Bildquellen Software Transactional Memory Data Parallel Haskell Data Parallel Haskell Umsetzung von Nested Data Parallelism Automatische Programmtransformationen: Flattening (global), Fusion (lokal) Wesentliche Abhängigkeit von Haskells reiner Funktionalität
76 Typsystem FFI Nebenläufigkeit Bildquellen Software Transactional Memory Data Parallel Haskell Data Parallel Haskell Umsetzung von Nested Data Parallelism Automatische Programmtransformationen: Flattening (global), Fusion (lokal) Wesentliche Abhängigkeit von Haskells reiner Funktionalität -- Komponentenweise Vektor-Multiplikation mulp :: (Num a) => [:a:] -> [:a:] -> [:a:] mulp xs ys = [: x + y x <- xs y <- ys :] -- Skalarprodukt dotp :: (Num a) => [:a:] -> [:a:] -> a dotp xs ys = sump (mulp xs ys)
77 Typsystem FFI Nebenläufigkeit Bildquellen Bildquellen dons/images/cloud.png http: //
Funktionale Programmierung
Funktionale Programmierung Jörg Kreiker Uni Kassel und SMA Solar Technology AG Wintersemester 2011/2012 2 Teil II Typen mit Werten und Ausdruck, sogar listenweise 3 Haskell Programme Programm Module ein
Typdeklarationen. Es gibt in Haskell bereits primitive Typen:
Typdeklarationen Es gibt in bereits primitive Typen: Integer: ganze Zahlen, z.b. 1289736781236 Int: ganze Zahlen mit Computerarithmetik, z.b. 123 Double: Fließkommazahlen, z.b. 3.14159 String: Zeichenketten,
Grundlagen von Python
Einführung in Python Grundlagen von Python Felix Döring, Felix Wittwer November 17, 2015 Scriptcharakter Programmierparadigmen Imperatives Programmieren Das Scoping Problem Objektorientiertes Programmieren
Adressen. Praktikum Funktionale Programmierung Organisation und Überblick. Termine. Studienleistung
Adressen Adressen, Termine Studienleistung Praktikum Funktionale Programmierung Organisation und Überblick Dr. David Sabel Büro und Email Raum 216, Robert-Mayer-Str. 11-15 [email protected]
Java Einführung Packages
Java Einführung Packages Inhalt dieser Einheit Packages (= Klassenbibliotheken) Packages erstellen Packages importieren Packages verwenden Standard Packages 2 Code-Reuse Einbinden von bereits (selbst-/fremd)
ALP I. Funktionale Programmierung
ALP I Funktionale Programmierung Sortieren und Suchen (Teil 1) WS 2012/2013 Suchen 8 False unsortiert 21 4 16 7 19 11 12 7 1 5 27 3 8 False sortiert 2 4 6 7 9 11 12 18 21 24 27 36 Suchen in unsortierten
Was bisher geschah. deklarative Programmierung. funktionale Programmierung (Haskell):
Was bisher geschah deklarative Programmierung funktional: Programm: Menge von Termgleichungen, Term Auswertung: Pattern matsching, Termumformungen logisch: Programm: Menge von Regeln (Horn-Formeln), Formel
Das Typsystem von Scala. L. Piepmeyer: Funktionale Programmierung - Das Typsystem von Scala
Das Typsystem von Scala 1 Eigenschaften Das Typsystem von Scala ist statisch, implizit und sicher 2 Nichts Primitives Alles ist ein Objekt, es gibt keine primitiven Datentypen scala> 42.hashCode() res0:
Java Einführung VARIABLEN und DATENTYPEN Kapitel 2
Java Einführung VARIABLEN und DATENTYPEN Kapitel 2 Inhalt dieser Einheit Variablen (Sinn und Aufgabe) Bezeichner Datentypen, Deklaration und Operationen Typenumwandlung (implizit/explizit) 2 Variablen
[10] Software Transactional Memory in Haskell, Tortenwurf und Aufgabenblatt 7
![[10] Software Transactional Memory in Haskell, Tortenwurf und Aufgabenblatt 7](/thumbs/27/11687557.jpg "[10] Software Transactional Memory in Haskell, Tortenwurf und Aufgabenblatt 7")
Haskell Live [10 Software Transactional Memory in Haskell, Tortenwurf und Aufgabenblatt 7 Bong Min Kim [email protected] Christoph Spörk [email protected] Bernhard Urban [email protected]
Programmieren in Haskell Einführung
Programmieren in Haskell Einführung Peter Steffen Universität Bielefeld Technische Fakultät 16.10.2009 1 Programmieren in Haskell Veranstalter Dr. Peter Steffen Raum: M3-124 Tel.: 0521/106-2906 Email:
Funktionale Programmierung mit Haskell
Funktionale Programmierung mit Haskell Dr. Michael Savorić Hohenstaufen-Gymnasium (HSG) Kaiserslautern Version 20120622 Überblick Wichtige Eigenschaften Einführungsbeispiele Listenerzeugung und Beispiel
Hochschule Darmstadt Informatik-Praktikum (INF 1) WS 2015/2016 Wirtschaftsingenieur Bachelor 5. Aufgabe Datenstruktur, Dateieingabe und -ausgabe
Aufgabenstellung Für eine Hausverwaltung sollen für maximal 500 Wohnungen Informationen gespeichert werden, die alle nach der gleichen Weise wie folgt strukturiert sind: Art Baujahr Wohnung Whnginfo Nebenkosten
Funktionale Programmierung ALP I. Funktionen höherer Ordnung. Teil 2 SS 2013. Prof. Dr. Margarita Esponda. Prof. Dr.
ALP I Funktionen höherer Ordnung Teil 2 SS 2013 Funktionen höherer Ordnung Nehmen wir an, wir möchten alle Zahlen innerhalb einer Liste miteinander addieren addall:: (Num a) => [a -> a addall [ = 0 addall
Monoide. Funktionale Programmierung. Prof. Dr. Oliver Braun Letzte Änderung: :54. Monoide 1/16
Monoide Funktionale Programmierung Prof. Dr. Oliver Braun Letzte Änderung: 09.10.2018 06:54 Monoide 1/16 Abstraktion gleichartige Strukturen sollten abstrahiert werden Beispiel: Collections in Haskell
Grundlegende Datentypen
Funktionale Programmierung Grundlegende Datentypen Fakultät für Informatik und Mathematik Hochschule München Letzte Änderung: 14.11.2017 15:37 Inhaltsverzeichnis Typen........................................
Funktionale Programmierung Grundlegende Datentypen
Grundlegende Datentypen Prof. Dr. Oliver Braun Fakultät für Informatik und Mathematik Hochschule München Letzte Änderung: 06.11.2017 16:45 Inhaltsverzeichnis Typen........................................
Übersicht. Schleifen. Schleifeninvarianten. Referenztypen, Wrapperklassen und API. 9. November 2009 CoMa I WS 08/09 1/15
Übersicht Schleifen Schleifeninvarianten Referenztypen, Wrapperklassen und API CoMa I WS 08/09 1/15 CoMa I Programmierziele Linux bedienen Code umschreiben strukturierte Datentypen Anweisungen und Kontrollstrukturen
Funktionale Programmierung. Monoide. Prof. Dr. Oliver Braun. Fakultät für Informatik und Mathematik Hochschule München
Funktionale Programmierung Monoide Fakultät für Informatik und Mathematik Hochschule München Letzte Änderung: 03.12.2018 07:53 Inhaltsverzeichnis Abstraktion..................................... 1 Eine
Was bisher geschah Funktionale Programmierung in Haskell: Algebraische Datentypen Pattern Matching Polymorphie Typklassen Rekursive Datentypen:
Was bisher geschah Funktionale Programmierung in Haskell: Algebraische Datentypen Pattern Matching Polymorphie Typklassen Rekursive Datentypen: Peano-Zahlen, Listen, Bäume Rekursive Funktionen strukturelle
Haskell für Mathematiker
Haskell für Mathematiker Joachim Breitner AG Seminar Topology 12. Mai 2016, Karlsruhe LEHRSTUHL PROGRAMMIERPARADIGMEN 1 KIT 19.2.2016 University of the Joachim State ofbreitner Baden-Wuerttemberg - Haskell
Kurze Einführung in die Programmiersprache C++ und in Root
Kurze Einführung in die Programmiersprache C++ und in Root Statistik, Datenanalyse und Simulation; 31.10.2006 Inhalt 1 Einführung in die Programmiersprache C++ Allgemeines Variablen Funktionen 2 1 Einführung
Pragmatik von Programmiersprachen
Pragmatik von Programmiersprachen Im Kontext der Notation von Quelltexten Mike Becker, 11. Dezember 2014 Szenario: IT Dienstleister Unternehmen: Produkte: Kunden: IT Dienstleistung Beratung und Software
Einführung in Java. PING e.v. Weiterbildung Andreas Rossbacher 24. März 2005
Einführung in Java PING e.v. Weiterbildung Andreas Rossbacher 24. März 2005 Gliederung 1. Was ist Java / Geschichte von Java 2. Prinzip der Plattformunabhängigkeit 3. Wie kommt man vom Quellcode zum Programm
Einführung in Haskell
Einführung in Haskell Axel Stronzik 21. April 2008 1 / 43 Inhaltsverzeichnis 1 Allgemeines 2 / 43 Inhaltsverzeichnis 1 Allgemeines 2 Funktions- und Typdefinitionen 2 / 43 Inhaltsverzeichnis 1 Allgemeines
Dr. Monika Meiler. Inhalt
Inhalt 4 Einführung in die Programmiersprache Java (Teil II)... 4-2 4.4 Strukturierte Programmierung... 4-2 4.4.1 Strukturierung im Kleinen... 4-2 4.4.2 Addierer (do-schleife)... 4-3 4.4.3 Ein- Mal- Eins
Fragen. f [ ] = [ ] f (x : y : ys) = x y : f ys f (x : xs) = f (x : x : xs) Wozu evaluiert f [1, 2, 3] (Abkürzung für f (1 : 2 : 3 : [ ]))?
![Fragen. f [ ] = [ ] f (x : y : ys) = x y : f ys f (x : xs) = f (x : x : xs) Wozu evaluiert f [1, 2, 3] (Abkürzung für f (1 : 2 : 3 : [ ]))?](/thumbs/24/4200701.jpg "Fragen. f [ ] = [ ] f (x : y : ys) = x y : f ys f (x : xs) = f (x : x : xs) Wozu evaluiert f [1, 2, 3] (Abkürzung für f (1 : 2 : 3 : [ ]))?")
Fragen f [ ] = [ ] f (x : y : ys) = x y : f ys f (x : xs) = f (x : x : xs) Wozu evaluiert f [1, 2, 3] (Abkürzung für f (1 : 2 : 3 : [ ]))? Wozu evaluiert [f [ ], f [ ]]? Weiteres Beispiel: f [ ] y = [
CGI Programmierung mit Ha. Markus Schwarz
CGI Programmierung mit Ha Markus Schwarz Überblick Was ist funktionale Programmierung Einführung in Haskell CGI-Programmierung mit Haskell Ein etwas größeres Beispiel Was ist funktionale Programm Ein Programm
Programmieren in Haskell
Programmieren in Haskell Wir steigen ein... Programmieren in Haskell 1 Was wir heute machen Umfrage: Wer hat den Hugs ausprobiert? Ausdrücke und Werte Datentypen Funktionen Aufgabe für diese Woche Programmieren
Deklarationen in C. Prof. Dr. Margarita Esponda
Deklarationen in C 1 Deklarationen Deklarationen spielen eine zentrale Rolle in der C-Programmiersprache. Deklarationen Variablen Funktionen Die Deklarationen von Variablen und Funktionen haben viele Gemeinsamkeiten.
Vorkurs C++ Programmierung
Vorkurs C++ Programmierung Klassen Letzte Stunde Speicherverwaltung automatische Speicherverwaltung auf dem Stack dynamische Speicherverwaltung auf dem Heap new/new[] und delete/delete[] Speicherklassen:
II. Grundlagen der Programmierung. 9. Datenstrukturen. Daten zusammenfassen. In Java (Forts.): In Java:
Technische Informatik für Ingenieure (TIfI) WS 2005/2006, Vorlesung 9 II. Grundlagen der Programmierung Ekkart Kindler Funktionen und Prozeduren Datenstrukturen 9. Datenstrukturen Daten zusammenfassen
Das erste Programm soll einen Text zum Bildschirm schicken. Es kann mit jedem beliebigen Texteditor erstellt werden.
Einfache Ein- und Ausgabe mit Java 1. Hallo-Welt! Das erste Programm soll einen Text zum Bildschirm schicken. Es kann mit jedem beliebigen Texteditor erstellt werden. /** Die Klasse hello sendet einen
Datentypen. Agenda für heute, 4. März, 2010. Pascal ist eine streng typisierte Programmiersprache
Agenda für heute, 4. März, 2010 Zusammengesetzte if-then-else-anweisungen Datentypen Pascal ist eine streng typisierte Programmiersprache Für jeden Speicherplatz muss ein Datentyp t (Datenformat) t) definiert
Projektverwaltung Problem Lösung: Modulare Programmierung
Projektverwaltung Problem Der Sourcecode ür ein Programm wird immer länger und unübersichtlicher Eine Funktion, die in einem alten Projekt verwendet wurde, soll auch in einem neuen Projekt verwendet werden
Scala kann auch faul sein
Scala kann auch faul sein Kapitel 19 des Buches 1 Faulheit Faulheit ( lazy evaluation ) ist auch in C oder Java nicht unbekannt int x=0; if(x!=0 && 10/x>3){ System.out.println("In if"); } Nutzen der Faulheit?
Operationalisierbare Qualitätskriterien für die Programmierung mit Erfahrungen aus PRÜ1 und PRÜ2
Operationalisierbare Qualitätskriterien für die Programmierung mit Erfahrungen aus PRÜ1 und PRÜ2 von Christoph Knabe http://public.beuth-hochschule.de/~knabe/ Ch. Knabe: Operationalisierbare Qualitätskriterien
Funktionale Programmierung
Schleifen 1 Funktionale Programmierung Jörg Kreiker Uni Kassel und SMA Solar Technology AG Wintersemester 2011/2012 3 Teil I Jedem Anfang wohnt ein Zauber inne 4 Über mich Diplom in Informatik in Saarbrücken
Hochschule Darmstadt Informatik-Praktikum (INF 1) WS 2014/2015 Wirtschaftsingenieur Bachelor 4. Aufgabe Datenstruktur, Dateieingabe und -ausgabe
Aufgabenstellung Für ein Baumkataster sollen für maximal 500 Bäume Informationen gespeichert werden, die alle nach der gleichen Weise wie folgt strukturiert sind: Nummer Bauminfo Baumart Hoehe Baum Umfang
Die Programmiersprache C99: Zusammenfassung
Die Programmiersprache C99: Zusammenfassung Jörn Loviscach Versionsstand: 7. Dezember 2010, 19:30 Die nummerierten Felder sind absichtlich leer, zum Ausfüllen in der Vorlesung. Videos dazu: http://www.youtube.com/joernloviscach
Einführung in die C++ Programmierung für Ingenieure
Einführung in die C++ Programmierung für Ingenieure MATTHIAS WALTER / JENS KLUNKER Universität Rostock, Lehrstuhl für Modellierung und Simulation 14. November 2012 c 2012 UNIVERSITÄT ROSTOCK FACULTY OF
Zweite Möglichkeit: Ausgabe direkt auf dem Bildschirm durchführen:
Ein- und Ausgabe Zweite Möglichkeit: Ausgabe direkt auf dem Bildschirm durchführen: fun p r i n t T r e e printa t = c a s e t o f Leaf a => ( p r i n t Leaf ; printa a ) Node ( l, a, r ) => ( p r i n
Hello World. Javakurs 2014, 1. Vorlesung. Sebastian Schuck. basierend auf der Vorlage von Arne Kappen. wiki.freitagsrunde.org. 3.
Hello World Javakurs 2014, 1. Vorlesung Sebastian Schuck basierend auf der Vorlage von Arne Kappen wiki.freitagsrunde.org 3. März 2014 This work is licensed under the Creative Commons Attribution-ShareAlike
Modul 122 VBA Scribt.docx
Modul 122 VBA-Scribt 1/5 1 Entwicklungsumgebung - ALT + F11 VBA-Entwicklungsumgebung öffnen 2 Prozeduren (Sub-Prozeduren) Eine Prozedur besteht aus folgenden Bestandteilen: [Private Public] Sub subname([byval
Prinzipien Objektorientierter Programmierung
Prinzipien Objektorientierter Programmierung Valerian Wintner Inhaltsverzeichnis 1 Vorwort 1 2 Kapselung 1 3 Polymorphie 2 3.1 Dynamische Polymorphie...................... 2 3.2 Statische Polymorphie........................
Einführung in die Programmiersprache C
Einführung in die Programmiersprache C Marcel Arndt [email protected] Institut für Numerische Simulation Universität Bonn Der Anfang Ein einfaches Programm, das Hello World! ausgibt: #include
Einführung in die Programmierung
: Inhalt Einführung in die Programmierung Wintersemester 2008/09 Prof. Dr. Günter Rudolph Lehrstuhl für Algorithm Engineering Fakultät für Informatik TU Dortmund - mit / ohne Parameter - mit / ohne Rückgabewerte
Programmierung in C. Grundlagen. Stefan Kallerhoff
Programmierung in C Grundlagen Stefan Kallerhoff Vorstellungsrunde Name Hobby/Beruf Schon mal was programmiert? Erwartungen an den Kurs Lieblingstier Für zu Hause C-Buch online: http://openbook.rheinwerk-verlag.de/c_von_a_bis_z/
Einführung in die Programmierung
Technische Universität München WS 2003/2004 Institut für Informatik Prof. Dr. Christoph Zenger Testklausur Einführung in die Programmierung Probeklausur Java (Lösungsvorschlag) 1 Die Klasse ArrayList In
Objektbasierte Entwicklung
Embedded Software Objektbasierte Entwicklung Objektorientierung in C? Prof. Dr. Nikolaus Wulff Objektbasiert entwickeln Ohne C++ wird meist C im alten Stil programmiert. => Ein endlose while-schleife mit
Javadoc. Programmiermethodik. Eva Zangerle Universität Innsbruck
Javadoc Programmiermethodik Eva Zangerle Universität Innsbruck Überblick Einführung Java Ein erster Überblick Objektorientierung Vererbung und Polymorphismus Ausnahmebehandlung Pakete und Javadoc Spezielle
Objektorientierte Programmierung
Objektorientierte Programmierung 1 Geschichte Dahl, Nygaard: Simula 67 (Algol 60 + Objektorientierung) Kay et al.: Smalltalk (erste rein-objektorientierte Sprache) Object Pascal, Objective C, C++ (wiederum
Alltagsnotizen eines Softwareentwicklers
Alltagsnotizen eines Softwareentwicklers Entkoppeln von Objekten durch Callbacks mit c++-interfaces oder boost.function und boost.bind Tags: c++, entkoppeln, objekt, oop, callback, boost.bind, boost.function,
Kommerzielle Softwareentwicklung mit Haskell
Kommerzielle Softwareentwicklung mit Haskell Ein Erfahrungsbericht Stefan Wehr factis research GmbH, Freiburg im Breisgau 7. Oktober 2011, Hal6 in Leipzig Viele Fragen Wer sind wir? Wer bin ich? Wie setzen
Einführung in die Informatik 2
Technische Universität München Fakultät für Informatik Prof. Tobias Nipkow, Ph.D. Lars Noschinski, Dr. Jasmin Blanchette, Dmitriy Traytel Wintersemester 2012/13 Lösungsblatt Endklausur 9. Februar 2013
Programmieren in Haskell
Programmieren in Haskell Wir steigen ein... Programmieren in Haskell 1 Was wir heute machen Umfrage: Wer hat den Hugs ausprobiert? Ausdrücke und Werte Datentypen Funktionen Aufgabe für s Wochenende Programmieren
Informatik I. Übung 01. Olga Diamanti
Informatik I Übung 01 Olga Diamanti 1 Über mich PhD Studentin in D-INFK Aus Griechenland Habe Elektrotechnik studiert Email: [email protected] http://www.inf.ethz.ch/ personal/dolga/ Mein Büro:
Einfache Ausdrücke Datentypen Rekursive funktionale Sprache Franz Wotawa Institut für Softwaretechnologie [email protected]
Inhalt SWP Funktionale Programme (2. Teil) Einfache Ausdrücke Datentypen Rekursive funktionale Sprache Franz Wotawa Institut für Softwaretechnologie [email protected] Interpreter für funktionale Sprache
Paradigmen der Programmierung
SS 11 Prüfungsklausur 25.07.2011 Aufgabe 5 (6+9 = 15 Punkte) a) Bestimmen Sie jeweils den Typ der folgenden Haskell-Ausdrücke: ( 1, 2 :"3", 4 < 5) :: (Char, String, Bool) [(last, tail), (head, take 5)]
Pass by Value Pass by Reference Defaults, Overloading, variable Parameteranzahl
Funktionen Zusammenfassung von Befehlssequenzen als aufrufbare/wiederverwendbare Funktionen in einem Programmblock mit festgelegter Schnittstelle (Signatur) Derartige prozedurale Programmierung erlaubt
Objektorientierte Programmierung
Universität der Bundeswehr Fakultät für Informatik Institut 2 Priv.-Doz. Dr. Lothar Schmitz FT 2006 Zusatzaufgaben Lösungsvorschlag Objektorientierte Programmierung Lösung 22 (Java und UML-Klassendiagramm)
5. Tutorium zu Programmieren
5. Tutorium zu Programmieren Dennis Ewert Gruppe 6 Universität Karlsruhe Institut für Programmstrukturen und Datenorganisation (IPD) Lehrstuhl Programmierparadigmen WS 2008/2009 c 2008 by IPD Snelting
Anweisungsblöcke (dazu zählen auch Programme) werden in geschweifte Klammern eingeschlossen.
Programmierung in C++ Seite: 1 Beispielprogramm 1: Programmierung in C++ int main() int hoehe = 3; int grundseite = 5; double flaeche = hoehe*grundseite*0.5; cout
Programmiersprachen Einführung in C. Unser erstes C-Programm. Unser erstes C-Programm. Unser erstes C-Programm. Unser erstes C-Programm
Programmiersprachen Einführung in C Teil 2: Prof. Dr. int main (int argc, char *argv[]) int sum = 0; for (i = 0; i
Konfigurationsanleitung Access Control Lists (ACL) Funkwerk. Copyright Stefan Dahler - www.neo-one.de 13. Oktober 2008 Version 1.0.
Konfigurationsanleitung Access Control Lists (ACL) Funkwerk Copyright Stefan Dahler - www.neo-one.de 13. Oktober 2008 Version 1.0 Seite - 1 - 1. Konfiguration der Access Listen 1.1 Einleitung Im Folgenden
Programmierkurs Java
Programmierkurs Java Dr. Dietrich Boles Aufgaben zu UE16-Rekursion (Stand 09.12.2011) Aufgabe 1: Implementieren Sie in Java ein Programm, das solange einzelne Zeichen vom Terminal einliest, bis ein #-Zeichen
Constraint-Algorithmen in Kürze - Mit der Lösung zur Path-Consistency-Aufgabe 9
Constraint-Algorithmen in Kürze - Mit der Lösung zur Path-Consistency-Aufgabe 9 Prof. Dr. W. Conen Version 1.0c Januar 2009 Genereller Ablauf der Suche Gegeben: Variablen X, Domains D, Constraints R (explizit
Algorithmen mit Python
Algorithmen mit Python Vorbesprechung zum Proseminar im Sommersemester 2009 http://www.python.org 1 Sie lernen in DAP Java und C/C++: 80% Syntax, 20% Algorithmen-Design Idee Schon ein einfaches Hello World
188.154 Einführung in die Programmierung für Wirtschaftsinformatik
Beispiel 1 Vererbung (Liste) Gegeben sind die beiden Klassen ListNode und PersonNode. 188.154 Einführung in die Programmierung für Wirtschaftsinformatik Wiederholung, Prüfungsvorbereitung Monika Lanzenberger
Programmtransformationen und Induktion in funktionalen Programmen
Programmtransformationen und Induktion in funktionalen Programmen Prof. Dr. Manfred Schmidt-Schauß Künstliche Intelligenz und Softwaretechnologie 13. Januar 2009 Einschub: Monadisches IO verzögern Implementierung
Praktische Informatik 3: Funktionale Programmierung Vorlesung 11 vom : Monaden als Berechnungsmuster
16:02:16 2017-01-17 1 [30] Praktische Informatik 3: Funktionale Programmierung Vorlesung 11 vom 10.01.2017: Monaden als Berechnungsmuster Christoph Lüth Universität Bremen Wintersemester 2016/17 Frohes
Beispiele: (Funktionen auf Listen) (3) Bemerkungen: Die Datenstrukturen der Paare (2) Die Datenstrukturen der Paare
Beispiele: (Funktionen auf Listen) (3) Bemerkungen: 5. Zusammenhängen der Elemente einer Liste von Listen: concat :: [[a]] -> [a] concat xl = if null xl then [] else append (head xl) ( concat (tail xl))
Grundlagen der Programmierung Prof. H. Mössenböck. 3. Verzweigungen
Grundlagen der Programmierung Prof. H. Mössenböck 3. Verzweigungen If-Anweisung n > 0? j n if (n > 0) x = x / n; ohne else-zweig x x / n j max x x > y? n max y if (x > y) max = x; else max = y; mit else-zweig
Interaktionen zwischen Objekten durch Senden von Nachrichten und Reagieren auf empfangene Nachrichten
Objekt Objekt kapselt Variablen und Routinen Interaktionen zwischen Objekten durch Senden von Nachrichten und Reagieren auf empfangene Nachrichten Eigenschaften jedes Objekts: Identität (identisch = mehrere
1 Vom Problem zum Programm
Hintergrundinformationen zur Vorlesung GRUNDLAGEN DER INFORMATIK I Studiengang Elektrotechnik WS 02/03 AG Betriebssysteme FB3 Kirsten Berkenkötter 1 Vom Problem zum Programm Aufgabenstellung analysieren
Methoden. von Objekten definiert werden, Methoden,, Zugriffsmethoden und Read-Only
Methoden Wie Konstruktoren und Destruktoren zum Auf- und Abbau von Objekten definiert werden, Wie inline-methoden Methoden,, Zugriffsmethoden und Read-Only Only- Methoden einzusetzen sind, Der this-pointer
php Hier soll ein Überblick über das Erstellen von php Programmen gegeben werden. Inhaltsverzeichnis 1.Überblick...2 2.Parameterübergabe...
php Hier soll ein Überblick über das Erstellen von php Programmen gegeben werden. Inhaltsverzeichnis 1.Überblick...2 2.Parameterübergabe...7 3.Zugriff auf mysql Daten...11 Verteilte Systeme: php.sxw Prof.
Programmieren in Haskell Einstieg in Haskell
Programmieren in Haskell Einstieg in Haskell Peter Steffen Universität Bielefeld Technische Fakultät 24.10.2008 1 Programmieren in Haskell Was wir heute machen Umfrage: Wer hat den Hugs ausprobiert? Ausdrücke
Klausur in Programmieren
Studiengang Sensorik/Sensorsystemtechnik Note / normierte Punkte Klausur in Programmieren Wintersemester 2010/11, 17. Februar 2011 Dauer: 1,5h Hilfsmittel: Keine (Wörterbücher sind auf Nachfrage erlaubt)
Formale Spezialisierungstechniken. am Beispiel des binären Baums. Hybride Programmiersprachen Daniel Krompass Berlin, 2009
Formale Spezialisierungstechniken am Beispiel des binären Baums. Hybride Programmiersprachen Daniel Krompass Berlin, 2009 Spezialisierungsarten (Typbeziehungen erster Art) X stellt Methoden und Eigenschaften
Der Aufruf von DM_in_Euro 1.40 sollte die Ausgabe 1.40 DM = 0.51129 Euro ergeben.
Aufgabe 1.30 : Schreibe ein Programm DM_in_Euro.java zur Umrechnung eines DM-Betrags in Euro unter Verwendung einer Konstanten für den Umrechnungsfaktor. Das Programm soll den DM-Betrag als Parameter verarbeiten.
Einführung in PHP. (mit Aufgaben)
Einführung in PHP (mit Aufgaben) Dynamische Inhalte mit PHP? 2 Aus der Wikipedia (verkürzt): PHP wird auf etwa 244 Millionen Websites eingesetzt (Stand: Januar 2013) und wird auf etwa 80 % aller Websites
Objektorientierte Programmierung. Kapitel 12: Interfaces
12. Interfaces 1/14 Objektorientierte Programmierung Kapitel 12: Interfaces Stefan Brass Martin-Luther-Universität Halle-Wittenberg Wintersemester 2012/13 http://www.informatik.uni-halle.de/ brass/oop12/