This page (revision-9) was last changed on 02-Mar-2009 16:04 by JensKapitza 

This page was created on 01-Mar-2009 19:25 by JensKapitza

Only authorized users are allowed to rename pages.

Only authorized users are allowed to delete pages.

Page revision history

Version Date Modified Size Author Changes ... Change note
9 02-Mar-2009 16:04 16 KB JensKapitza to previous parameter
8 02-Mar-2009 14:41 14 KB JensKapitza to previous | to last typen
7 01-Mar-2009 21:51 12 KB JensKapitza to previous | to last
6 01-Mar-2009 21:36 12 KB JensKapitza to previous | to last Collatz-Reihe
5 01-Mar-2009 21:13 11 KB JensKapitza to previous | to last bnf
4 01-Mar-2009 20:56 10 KB JensKapitza to previous | to last ebnf
3 01-Mar-2009 20:43 7 KB JensKapitza to previous | to last autosave
2 01-Mar-2009 19:36 1 KB JensKapitza to previous | to last structure
1 01-Mar-2009 19:25 619 bytes JensKapitza to last start

Page References

Incoming links Outgoing links
ProgrammierParadigmen...nobody
ProgrammierParadigmen

Version management

Difference between version and

View first change
= Programmierparadigmen =

''aus SPEKTRUM DER WISSENSCHAFT · Juni 2007'' %%quote
Das ist wahr, aber was speziell mich begeistert,
ist die Einheitlichkeit der Notation.
Alles wird auf dieselbe Weise erledigt,
man muss sich also nicht viel merken.
(Was ich lieber verschweige, ist die
Überfülle an Klammern in Lisp (die einige Leute ärgert).
(Was die Welt braucht (meiner Meinung nach) ist nicht
(eine Lisp-Variante (mit weniger Klammern)),
sondern (eine gewöhnliche Schriftsprache (mit mehr)).))
%%

Auch diese Seite ist an eine Vorlesung der [Universität|http://www.uni-due.de/] angelehnt. In dieser Vorlesung geht es um die Verschiedenen Konzepte der Programmiersprachen. Die Programmiersprachen die in der Vorlesung besprochen wurden, sind [Prolog|http://www.swi-prolog.org/], [Ruby|http://www.ruby-lang.org/] und [Haskell|http://www.haskell.org/]. Zu den einzelnen Programmiersprachen wird im laufe der Näher eingegangen. Weitere Thema der Veranstalltung sind Grammatiken und [EBNF|Wikipedia:EBNF].

Der Wikipediaartikel über [Programmiersprachen|Wikipedia:Programmiersprache] enthält eine Auflistung von verschiedenen Sprachen. Die Programmiersprachen können in verschiedene Gruppen unterteilt werden.

| imperative Sprachen | Frotran \\ Cobol \\ C \\ Pascal \\ Ada | Wort-für-Wort Verarbeitung auf einem in kleine Einheiten gegliederten Speicher. \\ Programmieren durch Veränderung des Speicherzustandes mit Hilfe von Wertzuweisungen. \\ maschienenorientierte Daten- und Programmstrukturen, relativ dicht an den Möglichkeiten der von [Neumann-Maschine| Wikipedia:Von-Neumann-Maschine]
| objektorientierte Sprachen | Simula \\ Smalltak \\ C++ \\ Java |
| logische Sprachen | Prolog
| funktionale Sprachen | Lisp \\ Miranda \\ Haskell | Funktionen sind Objekte ''erster Klasse'', sie können als Parameter übergeben und als Resultat zurückgegeben werden. \\ Baukastenprinzip zur Konstruktion von Funktionen ''höheren Typs'', Funktionale konstruieren Funktionen auf der Basis andere Funktionen. \\ Referentielle Transparenz ist ein ''geschlossener'' Ausdruck der immer den gleichen Wert, unabhängig von Ort im Programm und Zeit in der Ausführung, hat. \\ Polymorphie in funktionalen Sprachen besagt, dass eine Funktion keinen festen Typ haben muss und dennnoch wohlgetypt sein kann. \\ Innerhalb einer Klasse von Typen lässt sich ein allgemeinster Typ inferieren. \\ Funktionale sind praktisch immer polymorph.
| Skriptsprachen | Perl \\ Javascript \\ Python \\ Ruby |
| Auszeichnungssprachen | SGML \\ HTML-1 \\XML \\ HTML-4 |

Die verschiedenen [Paradigmen|Wikipedia:Programmiersprache#Programmierparadigmen] können dem Link entnommen werden. Weiter ist zur [deklarativen Programmierung|Wikipedia:Deklarative_Programmiersprache] folgendes zu sagen, dass der Programmierer spezifiert, welche Fragen er gelöst sehen möchte, aber nicht, wie sie gelöst werden sollen. Es gibt keine ausgezeichnete Richtung in der Berechnung, gebundene Parameter stellen Eingaben dar, ungebundene die Ausgaben. Die Programmausführung wird als Ableitungs- bzw. Beweisprozeß gesehen. Der Programmierer gibt Behauptungen ein, diese werden vom System verifiziert oder falsifiziert. Es werden die Bedingungen angegeben, unter denen die Behauptung wahr ist. __Fazit__: Im Gegensatz zu dem imperativen Paradigma, bei dem das __WIE__ im Vordergrund steht, fragt man in der deklarativen Programmierung nach dem __WAS__, das berechnet werden soll. Es wird also nicht mehr der Lösungsweg programmiert, sondern nur noch angegeben, welches Ergebnis gewünscht ist.




= Syntax und Semantik =

== Grammatiken ==
=== BNF ===
=== EBNF ===
<<
{{{

POSTANSCHRIFT = ANREDE NAME ANSCHRIFT [LAND].
NAME = [TITEL] VORNAME ZUNAME.
ANSCHRIFT = (STRAßE | POSTFACH) PLZ ORT.
STRAßE = STRAßENNAME HAUSNUMMER.
POSTFACH = INSTITUTION "Postfach" POSTFACHNUMMER.
ANREDE = "Herrn" | "Frau".
TITEL = "Dr." | "Prof." | "Dipl.-Ing.".
VORNAME = "Hans" | "Fritz" | "Erna" | "Anneliese".
ZUNAME = "Müller" | "Schmidt" | "Meier" | "Wollenbrink".
STRAßENNAME = "Heideweg" | "Straußenstr." | "Blumenstraße" | "Jahnstr.".
HAUSNUMMER = "1" | "2" | "3" | "4" | "5".
INSTITUTION = "Universität" | "Anwaltskammer" | "Ministerium" | "Polizei".
PLZ = "12345" | "17437" | "23412" | "43523".
ORT = "Duisburg" | "Essen" | "München" | "Berlin" | "Hamburg".
POSTFACHNUMMER = "90 42 35" | "43 63 21" | "54 65 91" | "12 64 75".
LAND = "DEUTSCHLAND" | "ÖSTERREICH" | "SCHWEIZ" | "POLEN" | "FRANKREICH".

}}}
{{{
Quadrupel-Notation:

G= (N,E,P,S)
N = (POSTANSCHRIFT,NAME,ANSCHRIFT,STRAßE,POSTFACH,
ANREDE,TITEL,VORNAME,ZUNAME,SRAßENNAME,HAUSNUMMER,
INSTITUTION,PLZ,ORT,POSTFACHNUMMER,LAND)

E= ('Herrn','Frau','Dr.','Prof.','Dipl.-Ing.','Hans',
'Fritz','Erna','Anneliese','Müller','Schmidt',
'Meier','Wollenbrink','Heideweg','Straußenstr.'
,'Blumenstraße','Jahnstr.','1','2','3','4','5',
'Universität','Anwaltskammer','Ministerium','Polizei',
'12345','17437','23412','43523','Duisburg','Essen',
'München','Berlin','Hamburg','90 42 35','43 63 21',
'54 65 91','12 64 75','DEUTSCHLAND','ÖSTERREICH',
'SCHWEIZ','POLEN','FRANKREICH')

S=POSTANSCHRIFT

P= (
POSTANSCHRIFT = ANREDE NAME ANSCHRIFT [LAND];
NAME = [TITEL] VORNAME ZUNAME;
ANSCHRIFT = (STRAßE | POSTFACH) PLZ ORT;
STRAßE = STRAßENNAME HAUSNUMMER;
POSTFACH = INSTITUTION "Postfach" POSTFACHNUMMER;
ANREDE = "Herrn" | "Frau";
TITEL = "Dr." | "Prof." | "Dipl.-Ing.";
VORNAME = "Hans" | "Fritz" | "Erna" | "Anneliese";
ZUNAME = "Müller" | "Schmidt" | "Meier" | "Wollenbrink";
STRAßENNAME = "Heideweg" | "Straußenstr." | "Blumenstraße" | "Jahnstr.";
HAUSNUMMER = "1" | "2" | "3" | "4" | "5";
INSTITUTION = "Universität" | "Anwaltskammer" | "Ministerium" | "Polizei";
PLZ = "12345" | "17437" | "23412" | "43523";
ORT = "Duisburg" | "Essen" | "München" | "Berlin" | "Hamburg";
POSTFACHNUMMER = "90 42 35" | "43 63 21" | "54 65 91" | "12 64 75";
LAND = "DEUTSCHLAND" | "ÖSTERREICH" | "SCHWEIZ" | "POLEN" | "FRANKREICH";
)
}}}
{{{
Herr  <<-- nicht in EBNF Herrn | Frau wäre OK
Hans Schmidt
Heideweg 3
12345 Hamburg
SCHWEIZ
}}}
=== Syntaxdiagramme ===
== Axiomatische Semantik ==

= Variablen, Bindung, Typisierung =
== Variablen und Parameter ==
== Sichtbarkeit ==
== Typsysteme: einfache und zusammengesetzte Datentypen ==
== statische und dynamische Typbindung ==

= Ausdrücke, Befehle, Kontrollstrukturen =
== Ausdrücke (expressions) ==

 x + y

== Befehle (statements) ==

 x := x + y  # Zuweisung (assignment-statement)

== Sequenzen und Kontrollstrukturen ==
== Prozeduren und Parameterübergabe ==

= Funktionale Abstraktion =
== Einführung in Haskell ==

{{{
-- Type-Definition
data Point = Pt { pontx, pointy :: Float}

pointx :: Point -> Float
pointy :: Point -> Float

--          Signatur
absPoint :: Point -> Float
absPoint p = sqrt (pointx p * pointx p + pointy p * pointy p)
}}}

{{{
-- Muster
sum_list [] = 0
sum_list (x:xs) = x + sum_list xs

--     x für das gilt; wenn y:= 5 dann gilt: sum_list [1,4,9,16,25]
sum_squares y = sum_list [x * x | x <- [1..y] ]
}}}

== Typinferenz: flexible Typisierung ==
== Rekursion und Listen ==

= Objektorientierung =
== Kapselung ==
== Polymorphismus ==
== Vererbung ==
== Objektorientierung im Vergleich (Überblick) ==
== Einführung in Ruby ==
=== Funktionen und Closures in Ruby ===

= Logisch-relationale Programmierung =
== Grundlagen ==
== Einführung in Prolog ==

{{{
% permutation sort --> n!
% 1 2 3
% 1 3 2
% 2 1 3
% 2 3 1
% 3 1 2
% 3 2 1
permutiere([],[]).
permutiere(List,[E|PList]) :-
   loesche(E,List,RList),permutiere(RList,PList).
   
% loesche erstes element
loesche(X,[X|Xs],Xs).
% suche element Y und lösche es
loesche(Y,[X|Xs],[X|NewXs]) :-
   loesche(Y,Xs,NewXs)
   
% leer ist sortiert    
sortiert([]).
% 1 element ist sortiert    
sortiert([X]).
% wenn X1 < X2 dann ist es sortiert, wenn es für den rest auch gilt.
sortiert([X1,X2|Xs]) :-
   X1 =< X2, sortiert([X2|Xs]).    

perm_sort(List,SortList) :-
   permutiere(List,SortList),sortiert(SortList).
}}}

=== Perfekte Zahl ===
Eine natürliche Zahl wird vollkommene Zahl (auch perfekte Zahl) gennant, wenn sie genauso groß ist wie die Summe ihrer positiven echten Teiler (d.h. aller Teiler außer sich selbst)
{{{
% prolog ist eine logische programmiersprache
% in diesem programm wird ein mathematosches
% problem gelöst, welches die perfekte zahl
% sucht. eine zahl ist perfekt, wenn gilt:
% -------------------------------------------
% 1: X ist eine Zahl
% 2: X hat natürliche Teiler
% 3: Die Summe aller Teiler ohne die Zahl selbst
%  ist die zahl X

% dieser ausdruck prüft die obrigen bedingungen, d.h
% ein , ist einem logischem UND ähnlich
perfekt(X) :-
 zahl(X),
 teiler(X,TL),
 sum_list(TL,N),
 % um aretmetische funktionen auszuwerten
 % wird =:= verwendet. weil:
 % = eine unifizierung bewirgt.
 % ! F(X,6) = F(9,Z) --> X=9 , Z=6
 N =:= X.

% in dieser sprache wird rekursion verwendet!
% die liste [X|Xs] ist wie bei haskel
% X ist der listenkopf und Xs ist der rest der
% liste.
sum_list([],0).
sum_list([X|Xs],Sum) :-
 sum_list(Xs,Sum_Xs),
 % will man eine zuweisung machen nutzt man das
 % wort is, da = schon vergeben ist und eine unifizirung
 % macht.
 Sum is X + Sum_Xs.


teiler(X,P) :-
 % ein set der folgende bedingungenn prüft.
 % T ist eine Variable für die gilt:
 % 1: T ist eine zahl
 % 2: T ist kleiner als das argument X
 setof(T, (zahl(T),T < X, teilt(T,X)), P).

% Y|X
teilt(Y,X) :-
 % hier wir der teiler geprüft,
 % Y ist nur dann teiler wenn eine
 % Division ohne rest möglich ist
 0 =:= X mod Y.

zahl(Z) :-
 % um nich all zu viel und zu lange
 % zu warten werden nur zahlen
 % in dem bereich 1 .. 1000 geprüft
 zahl_von_bis(1,1000,Z).

% pattern matching
% wenn dieses muster vorkommt ...
zahl_von_bis(M,N,M) :-
M<N.
zahl_von_bis(N,N,N).
zahl_von_bis(M,N,Z) :-
 M<N,
 M1 is M+1,
 zahl_von_bis(M1,N,Z).

% weitere anmerkungen zu prolog
% in prolog werden argumente (vgl. parameter in
% Funktionalen oder Objektorientierten sprachen)
% verwendet. da funktoren keine werte zurück geben
% muss ein rückgabe parameter benutzt werden.
% andere sprachen kennen dafür schlüsselworte wie out
}}}

== Mustervergleich / Unifikation ==
== Listen und Rekursion ==
== Nichtdeterminismus ==

 
This page (revision-9) was last changed on 02-Mar-2009 16:04 by JensKapitza  Top