[svn] r5943: nemerle/trunk/doc/presentation/ksi-kamil-2005: .
content.tex main.tex
nazgul
svnadmin at nemerle.org
Thu Nov 17 00:40:49 CET 2005
Log:
Ksi presentation
Author: nazgul
Date: Thu Nov 17 00:40:47 2005
New Revision: 5943
Added:
nemerle/trunk/doc/presentation/ksi-kamil-2005/
- copied from rev 5942, nemerle/trunk/doc/presentation/ksi-michal-2005/
Modified:
nemerle/trunk/doc/presentation/ksi-kamil-2005/content.tex
nemerle/trunk/doc/presentation/ksi-kamil-2005/main.tex
Modified: nemerle/trunk/doc/presentation/ksi-kamil-2005/content.tex
==============================================================================
--- nemerle/trunk/doc/presentation/ksi-michal-2005/content.tex (original)
+++ nemerle/trunk/doc/presentation/ksi-kamil-2005/content.tex Thu Nov 17 00:40:47 2005
@@ -6,483 +6,312 @@
\definecolor{lgray}{rgb}{0.8,0.8,0.8}
\title{Nemerle}
-\author{Micha{\l} Moskal}
-\institute{Instytut Informatyki Uniwersytetu Wrocławskiego \\
-Spotkanie Koła Studentów Informatyki}
+\author{Kamil Skalski}
+\institute{Instytut Informatyki Uniwersytetu Wrocławskiego \\
+Spotkanie Koła Studentów Informatyki}
\date{17 listopada 2005}
\begin{document}
-\section{Wstęp}
+\section{Abstrakcja i uogĂłlnianie w programowaniu}
\frame{\titlepage}
\frame{
-\frametitle{Cechy Nemerle}
+\frametitle{Abstrakcja}
\begin{itemize}
- \item język programowania wysokiego poziomu
- \item statycznie typowany
- \item ogólnego przeznaczenia
- \item od początku projektowany z myślą o \net
- \item funkcjonalny i obiektowy
- \item potężny system metaprogramowania
+ \item najlepsze sÄ
proste i bezpoĹ›rednie rozwiÄ
zania
+ \item jednak wtedy niskopoziomowe detale wchodzÄ
wszędzie gdzie tylko się da
+ \item potrzeba podzielić problem na warstwy
+ \item kaĹźda warstwa realizowana jest niezaleĹźnie
+ \item kolejna warstwa jest abstrakcjÄ
poprzedniej
+ \item ostatnia zawsze sprowadza się do hasła ``chcę mieć program, który działa''
+ \footnote {tudzieş, który uda mi się sprzedać}
\end{itemize}
}
+\frame[containsverbatim]{
+\frametitle{Prosta pętla}
+Załóşmy, şe chcemy zrealizować jakieś proste zadanie programistyczne.
+Na przykład wykonać pewien kod w pętli.
-\frame{
-\frametitle{A co to język funkcjonalny?}
-\begin{itemize}
- \item funkcje jako wartości
- \begin{itemize}
- \item wskaźniki na funkcje
- \item \textit{functional object}
- \item delegaty
- \end{itemize}
- \item rekonstrukcja typów
- \item trwałość wartości (brak efektów ubocznych)
-\end{itemize}
-}
-
-
-\frame{
-\frametitle{Czemu \net\ ?}
-
-\begin{itemize}
- \item szeroki dostęp do bibliotek
- \item środowisko uruchomieniowe (odśmiecanie, JIT)
- \item ``wielojęzykowość''
- \item przenośne pliki wykonywalne (Microsoft \net, Mono, DotGNU, Rotor)
- \item dynamiczne ładowanie klas
- \item dynamiczna generacja kodu
-\end{itemize}
-}
-
-\frame{
-\frametitle{Po co to to?}
-
-\begin{itemize}
- \item chcieliśmy połączyć programowanie obiektowe (w sensie C\#) z programowaniem
- funkcjonalnym
-\begin{itemize}
- \item znajoma, obiektowa podstawowa struktura programu
- \item metody w środku zaimplementowane funkcjonalnie
- \item łatwy dostęp do cech imperatywnych
-\end{itemize}
- \item od ML-owej składni, podzbioru funkcjonalności C\# oraz aspektów funkcjonalnych
- \item do języka który wygląda jak C\#, zawiera C\# oraz aspekty funkcjonalne
- \item makra!
-
-\end{itemize}
-}
-
+Bierzemy nasz ulubiony asembler i kodujemy...
-\section{Wszyscy lubimy przykłady}
+\begin{verbatim}
+ mov bx, 10
+ mov cx, 0
+l1:
+ cmp cx, bx
+ br_eq l2
+ mov ax, cx
+ inc
+ mov cx, ax
-\frame[containsverbatim]{
-\frametitle{Cześć}
+ ...
-\begin{verbatim}
-// typy po prawej i po :
-class Hello {
- public static Main () : void
- {
- System.Console.Write ("Hello world!\n");
- }
-}
+ br l1
+l2:
\end{verbatim}
}
-
\frame[containsverbatim]{
-\frametitle{Cześć 2.0}
+\frametitle{Implementacja bardziej na czasie}
+Ok, w asemblerze pisało się w moich czasach, teraz uşywamy C / C++ / C\#.
\begin{verbatim}
-System.Console.Write ("Hello world!\n");
+ int n = 10;
+ int i = 0;
+l1:
+ if (i == n)
+ goto l2;
+ i++;
+ ...
+ goto l1;
+l2:
\end{verbatim}
-}
+Cały czas coś nie gra?
+}
\frame[containsverbatim]{
-\frametitle{Silnia}
+\frametitle{Pierwszy ``design pattern'' w akcji}
+Teraz lepiej.
\begin{verbatim}
-class Factorial {
- public static factorial (x : int) : int {
- def loop (acc : int, x : int) : int {
- if (x <= 1) acc
- else loop (acc * x, x - 1)
- }
-
- loop (1, x)
- }
-
- public static Main () : void
- {
- System.Console.WriteLine (factorial (10));
- }
-}
+for (int i = 0; i < n; i++)
+ // ...
\end{verbatim}
+
+Wczujmy się w panów Kernighan i Ritchie'iego. Co zrobiliśmy?
+WĹ‚aĹ›nie wbudowaliĹ›my w nasz jÄ™zyk pewnÄ
konstrukcjÄ™, ktĂłra
+zawiera w sobie dość często stosowany schemat uşywany przez programistów -
+pÄ™tlÄ™ z inicjalizacjÄ
.
}
-\frame[containsverbatim]{
-\frametitle{Silnia 2.0}
-\begin{verbatim}
-class Factorial {
- public static factorial (x : int) : int {
- def loop (acc, x) {
- if (x <= 1) acc
- else loop (acc * x, x - 1)
- }
+\frame{
+\frametitle{Design pattern - co to?}
+\emph{Design pattern} to ogĂłlne rozwiÄ
zanie do pewnego
+ często spotykanego problemu w projektach programistycznych.
- loop (1, x)
- }
+\begin{itemize}
+ \item wykonanie czegoś wiele razy (pętla)
+ \item modelowanie danych i relacji między nimi (struktury, klasy)
+ \item schematy rozwiÄ
zań w projektowaniu obiektowym (to je powszechnie nazywa
+ siÄ™ \emph{design pattern})
+ \item konwencje nazywania zmiennych, metod, klas i ich występowanie w
+ określonych sytuacjach (getX(), setX() w Javie, właściwości w C\#)
+ \item setki innych, o ktĂłrych ludzie piszÄ
ksiÄ
Ĺźki i zarabiajÄ
pieniÄ
dze
+\end{itemize}
- public static Main () : void
- {
- System.Console.WriteLine (factorial (10));
- }
-}
-\end{verbatim}
+Jednym słowem - abstrakcja, uogólnianie i powszechne korzystanie ze sprawdzonych
+pomysłów \footnote{ok, to juş więcej niş jedno słowo}.
}
+\section {Rozwój języków programowania}
-\frame[containsverbatim]{
-\frametitle{Brak rekonstrukcji}
+\frame[containsverbatim] {
+\frametitle{Iteratory w Javie}
\begin{verbatim}
-// C#
-void SendMessage (byte[] addr, int port, string data)
-{
- IPEndPoint ip = new IPEndPoint (new IPAddress (addr), port);
- TcpClient client = new TcpClient (ip);
- NetworkStream str = client.GetStream ();
- byte[] data = Encoding.UTF8.GetBytes (data);
- str.Write (data, 0, data.Length);
- client.Close ();
-}
+ Iterator iter = coll.iterator ();
+ while (iter.hasNext()) {
+ Order ord = (Order) iter.next ();
+ // ..
+ }
\end{verbatim}
+
+Pisze siÄ™ je naprawdÄ™ dziesiÄ
tki, a nawet setki razy.
}
\frame[containsverbatim]{
-\frametitle{Rekonstrukcja}
+\frametitle{foreach}
+Trzeba byĹ‚o 8-miu lat, aby Sun wprowadziĹ‚ do jÄ™zyka skrĂłconÄ
formÄ™ skĹ‚adniowÄ
+lub jak kto woli, nowego jÄ™zyka (C\#), ktĂłry wprowadziĹ‚ jÄ
od samego poczÄ
tku, a
+poza tym niewiele się od Javy róşnił.
+
\begin{verbatim}
-// Nemerle
-def SendMessage (addr, port, data)
+for (Widget w: box)
{
- def ip = IPEndPoint (IPAddress (addr), port);
- def client = TcpClient (ip);
- def str = client.GetStream ();
- def data = Encoding.UTF8.GetBytes (data);
- str.Write (data, 0, data.Length);
- client.Close ();
+ System.out.println(w);
}
\end{verbatim}
}
+\frame[containsverbatim] {
+\frametitle{Nemerle - język oparty o rozszerzalność}
+ Z ideami zawartymi w Nemerle skracamy ten wieloletni okres oczekiwania na
+innowację do kilkunastu minut potrzebnych programiście, aby zaimplementował
+nastÄ™pujÄ
ce makro:
-\frame[containsverbatim]{
-\frametitle{Brak rekonstrukcji II}
\begin{verbatim}
-Dictionary<string, int> CountEach (string[] args)
+macro Foreach (n, coll, body)
+syntax (``foreach'', ``(``, i, ``in'', coll, ``)'', body)
{
- Dictionary<string, int> d = new Dictionary<string, int>();
- foreach (string s in args) {
- if (d.ContainsKey (s))
- d[s] += 1;
- else
- d[s] = 1;
+ <[ def iter = $coll.iterator ();
+ while (iter.hasNext ()) {
+ def $i = iter.next ();
+ $body
}
- return d;
+ ]>
}
-\end{verbatim}
+\end{verbatim} % $
}
-\frame[containsverbatim]{
-\frametitle{Rekonstrukcja II}
-\begin{verbatim}
-def CountEach (args : array [string])
-{
- def d = Dictionary ();
- foreach (s in args) {
- if (d.ContainsKey (s))
- d[s] += 1;
- else
- d[s] = 1;
- }
- d
-}
-\end{verbatim}
-}
+\section {Przykładowe schematy z programowania obiektowego}
\frame[containsverbatim]{
-\frametitle{Trudna rekonstrukcja}
-\begin{verbatim}
-[Record]
-class Foo {
- my_value : int;
- public Barize () : void
- { System.Console.Write ($ "Foo ($my_value), "
- "times 42 = $(my_value * 42)\n");
- }
-}
-class Qux { public Barize () : void { } }
+\frametitle{Adapter pattern}
+Przystosowanie pewnego interfejsu do jakiegoĹ› nieco innego, lecz
+udostÄ™pniajÄ
cego podobnÄ
funkcjonalność.
+Mapuje pewien zestaw metod na inny zestaw metod.
-// Main starts here
-def call_barize (x) { x.Barize () }
-def our_list = [Foo (1), Foo (2), Foo (3)];
-foreach (e in our_list)
- call_barize (e);
-\end{verbatim}
-}
+$$Stack + ListImpl = StackListImpl$$
+Tu moĹźemy wykorzystać makra generujÄ
ce metody, jak
-\frame[containsverbatim]{
-\frametitle{Jeszcze trudniejsza}
\begin{verbatim}
-[Record]
-class Foo {
- my_value : int;
- public Barize () : void
- { System.Console.Write ($ "Foo ($my_value), "
- "times 42 = $(my_value * 42)\n");
+<[ decl:
+ public Push (x : string) : int
+ {
+ // mapped into
+ list.AddLast (x)
}
-}
-class Qux { public Barize () : void { } }
-
-// Main starts here
-def call_barize (x) { x.Barize () }
-def our_list = [Foo (1), Foo (2), Foo (3)];
-// foreach (e in our_list)
-// call_barize (e);
+]>
\end{verbatim}
}
-
-\section{Makra}
\frame{
-\frametitle{Makra}
-\begin{itemize}
- \item ładowane dynamicznie wtyczki (DLL-e) do kompilatora
- \begin{itemize}
- \item preprocesorowi C mówimy \textbf{Nie!}
- \end{itemize}
- \item przekształcają, generują lub analizują programy
- \item pisane w Nemerle
- \item pracują w środku kompilatora na jego strukturach danych
- \item mogą czytać pliki, patrzeć do bazy danych etc.
-\end{itemize}
-}
+\frametitle{Composite pattern}
+Kontener na obiekty, ktĂłre majÄ
podobny zestaw metod.
+Udostępnia te metody i wywołuje je dla zawarych w nim obiektach.
-\frame{
-\frametitle{Użycia makr}
-\begin{itemize}
- \item wyspecjalizowane podjęzyki
- \begin{itemize}
- \item SQL
- \item {\tt printf}, {\tt scanf}
- \item wyrażenia regularne
- \item XML
- \end{itemize}
- \item tworzenie programów z programów (serializacja, specjalizacja kodu)
- \item optymalizacje specyficzne dla domeny
- \item automatyzacja wzorców projektowych
- \item system asercji
- \item \textit{Aspect Oriented Programming}
-\end{itemize}
+$$Window + ListView + TreeView = Control$$
}
-\section{Warianty}
+\section {Z şycia wzięte}
\frame{
-\frametitle{Warianty}
+\frametitle{Jak wykorzystałbym to w firmie?}
\begin{itemize}
-\item rozszerzone typy wyliczeniowe (ang. \textit{enum})
-\item albo, albo, albo
-\item lista
- \begin{itemize}
- \item lista pusta, albo
- \item komórka listy -- głowa (element) i ogon (wskaźnik na resztę listy)
- \end{itemize}
-\item drzewo
- \begin{itemize}
- \item element wewnętrzny (para dzieci i element), albo
- \item liść (element)
- \end{itemize}
-\item dobre też dla menu czy VRML-a
-\end{itemize}
-}
-
-\frame{
-\frametitle{VRML}
-\begin{itemize}
-\item \textit{Virtual Reality Modeling Language}
-\item oparty na OpenGL
-\item węzły
- \begin{itemize}
- \item przekształcenia geometryczne
- \item ustawianie materiałów
- \item bryły
- \item separatory
- \item inne (tekst, linki)
- \end{itemize}
+ \item generacja kodu
+ \item generacja klas
+ \item generacja pĂłl w klasach
+ \item generacja metod
+ \item generacja kodu
\end{itemize}
}
\frame[containsverbatim]{
-\frametitle{Tak napisałbym w C\#...}
+\frametitle{Przykład 1. - propagacja danych}
\begin{verbatim}
-abstract class Node { }
-class Separator : Node {
- public Node[] children;
-}
-class Translation : Node {
- public double x;
- public double y;
- public double z;
-}
-class Material : Node {
- public double x;
- public double y;
- public double z;
-}
-class Cube : Node { }
+if (ord1.getReceiver() != null)
+ ord2.setReceiver (ord1.getReceiver());
+if (ord1.getProducer() != null)
+ ord2.setProducer (ord1.getProducer());
+if (ord1.getSpeditor() != null)
+ ord2.setSpeditor (ord1.getReceiver());
+if (ord1.getAddress() != null)
+ ord2.setAddress (ord1.getAddress());
+if (ord1.getIncoterms() != null)
+ ord2.setIncoterms (ord1.getIncoterms());
\end{verbatim}
}
\frame[containsverbatim]{
-\frametitle{...a tak w Nemerle (porównamy potem)}
+\frametitle{A makro potrafi generować...}
+Moşemy przecieş pisać
+
\begin{verbatim}
-variant Node {
- | Separator {
- children : list [Node];
- }
- | Translation {
- x : double;
- y : double;
- z : double;
- }
- | Material {
- r : double;
- g : double;
- b : double;
- }
- | Cube
-}
+propagateNotNull (ord1, ord2,
+ Receiver, Producer, Speditor,
+ Address, Incoterms);
\end{verbatim}
-}
+przy uĹźyciu makra podobnego do
-\frame[containsverbatim]{
-\frametitle{Wyświetlenie sceny}
\begin{verbatim}
-DisplayNode (n : Node) : void
-{
- match (n) {
- | Node.Separator (nodes) =>
- glPushMatrix ();
- glPushAttrib (GL_CURRENT_BIT);
- foreach (n in nodes)
- DisplayNode (n);
- glPopAttrib ();
- glPopMatrix ();
-
- | Node.Translation (x, y, z) => glTranslated (x, y, z);
- | Node.Material (r, g, b) => glColor3d (r, g, b);
- | Node.Cube => DrawCube ();
- }
+macro propagateNotNull (o1, o2, names : list [PExpr]) {
+ names.Map (fun (name) {
+ <[ if ($o1.$name() != null) $o2.$name ($o1.$name ()) ]>
+ })
}
\end{verbatim}
}
-
\frame[containsverbatim]{
-\frametitle{Optymalizacja sceny}
+\frametitle{Przykład 2. - propercje aplikacji}
\begin{verbatim}
-Optimize (n : Node) : Node
-{
- match (n) {
- | Node.Separator ([(Node.Cube) as c]) => c
- | Node.Separator (children) =>
- Node.Separator (List.Map (children, Optimize))
- | x => x
- }
+class PropertyNames {
+public static String PAGE_ORDER_RECEIVER_VISIBLE =
+ ``page.order.receiver.visible'';
+ ...
}
-\end{verbatim}
+class PropertyDefaults {
+public static boolean PAGE_ORDER_RECEIVER_VISIBLE_DEFAULT =
+ false;
+ ...
}
+\end{verbatim}
-\frame{
-\frametitle{Warianty a dziedziczenie}
-\begin{itemize}
-\item wzajemnie uzupełniają się
-\item w dziedziczeniu zamiast dopasowania wzorca metody abstrakcyjne
-\item zalety wariantów
-\begin{itemize}
-\item są zamknięte -- ostrzeżenia o ominiętych przypadkach
-\item obsługa przez dopasowanie wzorca -- kod dla danej funkcjonalności w jednym miejscu
-\item metody binarne
-\end{itemize}
-\end{itemize}
-}
+a obok tego w bazie danych struktura drzewiasta
+\begin{verbatim}
+ ID PARENTID KEY TYPE VALUE
+ 22 1 'order' 6 null
+\end{verbatim}
+}
-\section{Podsumowanie}
+\frame[containsverbatim]{
+\frametitle{A jakbym chciał?}
-\frame{
-\frametitle{Kompilator}
+\begin{verbatim}
+[assembly: Properties (ReadFrom = DataBase,
+ Source = 'woadm.companyptype')]
+\end{verbatim}
-\begin{itemize}
- \item kompiluje sam siebie
- \item produkuje i pożera genericsy
- \item wydana wersja 0.9.1, dla mono 1.1.9+ i MS .NET 2.0
-\end{itemize}
+\emph{Properties} jest makrem, ktĂłre podczas kompilacji programu wczytuje drzewo
+propercji z bazy danych (pliku XML, czegokolwiek) i wygenerujeć klasy
+\emph{PropertyNames} i \emph{PropertyDefaults} wypeĹ‚niajÄ
c je polami jak wyĹźej,
+lub moşe zagnieşdşonymi klasami, şeby dopełnianie lepiej działało:
+\emph{Page.Order.Receiver.Visible}.
}
+\frame[containsverbatim]{
+\frametitle{PrzykĹ‚ad 3. Klasy odpowiadajÄ
ce tabelom z bazy}
+\begin{verbatim}
+ class OrderPosition {
+ Long id;
+ Integer state;
+ // ...
-\frame{
-\frametitle{Projekty używające Nemerle}
+ public Long getId () { return id; }
-\begin{itemize}
- \item Sioux -- serwer HTTP/aplikacji
- \item cs2n -- konwerter C\# do Nemerle
- \item nemish -- Nemerle Interactive Shell
- \item Asper IDE/edytor
- \item RiDL narzędzia do generowania parserów i lekserów
- \item wtyczki do NAnt'a i MS.Builda
- \item generator CodeDom (wsparcie dla ASP.NET)
- \item Code Completion Engine
- \item integracja z IDE (VS.NET, \#D, MD)
-\end{itemize}
-}
+ public OrderPositionData GetData () {
+ OrderPositionData pd = new OrderPositionData ();
+ pd.id = id;
+ // ...
+ return pd;
+ }
+ }
+\end{verbatim}
+i dodatkowo definicja \emph{OrderPositionData}...
+}
\frame{
-\frametitle{Społeczność}
-
+\frametitle{Po co klepać głupi kod?}
\begin{itemize}
- \item .NET runtime issues
- \item Subversion
- \item licencja BSD
- \item lista mailingowa (70 subscribers)
- \item forum www
- \item issue tracker -- 500 raportów ogólnie, 50 otwartych
- \item strona na silniku wikipedii -- zewnętrzni pisarze dokumentacji
- \item kurs online (niedawno się skończył)
- \item kurs w II
-\end{itemize}
-}
+\item Oczywiście cały ten kod, którego wklepanie, przetestowanie
+i utrzymanie kosztuje firmÄ™ cenne mendejsy, powinien zniknÄ
ć
+i zostać wygenerowany automatycznie.
-\frame{
-\frametitle{TODO}
+\item To samo tyczy siÄ™ bardzo duĹźej części kodu nad ktĂłrym pracujÄ
+firmy zajmujÄ
ce siÄ™ szarym biznesem.
-\begin{itemize}
- \item zbliża się stabilna wersja 1.0
- \item więcej integracji z IDE
- \item więcej budowania społeczności
- \item więcej analizy statycznej
+\item Przyszłość leşy w automatyzacji programowania, generacji kodu...
+na szczęście ciÄ
gle ktoĹ› musi pisać kod generujÄ
cy kod.
\end{itemize}
}
-
\end{document}
% vim: language=polish
Modified: nemerle/trunk/doc/presentation/ksi-kamil-2005/main.tex
==============================================================================
--- nemerle/trunk/doc/presentation/ksi-michal-2005/main.tex (original)
+++ nemerle/trunk/doc/presentation/ksi-kamil-2005/main.tex Thu Nov 17 00:40:47 2005
@@ -3,6 +3,6 @@
%\usepackage{beamerthemesidebar}
\usepackage{graphicx}
\usepackage{polski}
-\usepackage[latin2]{inputenc}
+\usepackage[utf8]{inputenc}
\input{content.tex}
More information about the svn
mailing list