fixed typos (especially "Pd" vs "pd")

svn path=/trunk/; revision=10052

2 files changed, 82 insertions, 82 deletions

diff --git a/doc/tutorials/externals-howto/HOWTO-externals-de.tex b/doc/tutorials/externals-howto/HOWTO-externals-de.tex
index 468ec09d..73b2eedb 100644
--- a/doc/tutorials/externals-howto/HOWTO-externals-de.tex
+++ b/doc/tutorials/externals-howto/HOWTO-externals-de.tex
@@ -3,7 +3,7 @@
 \documentclass[12pt, a4paper,austrian, titlepage]{article}
 
 
-%% HOWTO write an external for pd
+%% HOWTO write an external for Pd
 %% Copyright (c) 2001-2006 by IOhannes m zmölnig
 %%
 %%  Permission is granted to copy, distribute and/or modify this document
@@ -49,7 +49,7 @@
 \title{
 HOWTO \\
 write an External \\
-for {\em puredata}
+for {\em Pure data}
 }
 
 \author{
@@ -71,17 +71,17 @@ johannes m zmölnig \\
 \hyphenation{Echt-zeit-Computer-musik-pro-gramm}
 
 \begin{abstract}
-pd ist ein graphisches Computermusiksystem in der Tradition von IRCAMs {\em ISPW-max}.
+Pd ist ein graphisches Computermusiksystem in der Tradition von IRCAMs {\em ISPW-max}.
 
-Obwohl eine Fülle von Funktionen von pd selbst zur Verfügung gestellt 
+Obwohl eine Fülle von Funktionen von Pd selbst zur Verfügung gestellt 
 werden, stößt man doch manchmal an die Grenzen dessen,
 das mit diesen Primitiven und ihren Kombinationen möglich ist.
 
-Deswegen bietet pd die Möglichkeit, eigene Primitive (``objects'', Objekte) in komplexen
+Deswegen bietet Pd die Möglichkeit, eigene Primitive (``objects'', Objekte) in komplexen
 Programmiersprachen wie {\tt C/C++} zu erstellen.
 
 In diesem Dokument soll beschrieben werden, wie man solche Primitive mit Hilfe der 
-Sprache {\tt C}, in der auch pd selbst realisiert wurde, schreibt.
+Sprache {\tt C}, in der auch Pd selbst realisiert wurde, schreibt.
 \end{abstract}
 
 
@@ -95,21 +95,21 @@ Sprache {\tt C}, in der auch pd selbst realisiert wurde, schreibt.
 
 \section{Voraussetzungen und Begriffsbestimmungen}
 
-pd bezieht sich auf das graphische Echtzeit-Computermusikprogramm von
+Pd bezieht sich auf das graphische Echtzeit-Computermusikprogramm von
 Miller~S.~Puckette.
-{\em puredata}.
+{\em Pure data}.
 
-Zum Verständnis dieses Dokumentes wird der Umgang mit pd sowie
+Zum Verständnis dieses Dokumentes wird der Umgang mit Pd sowie
 Verständnis von Programmiertechniken, insbesondere {\tt C} vorausgesetzt.
 
 Zum Schreiben von eigenen Primitiven wird weiters ein {\tt C}-Compiler,
 der dem {\tt ANSI-C}-Standard genügt, notwendig sein.
 Solche Compiler sind beispielsweise der {\em Gnu C-Compiler} (gcc) auf linux-Systemen oder
-{\em Visual-C++ 6.0} (vc6) auf Windows-Systemen.
+{\em Visual-C++} auf Windows-Systemen.
 
 \subsection{Klassen, Instanzen und Objekte}
-pd ist in der Programmiersprache {\tt C} geschrieben.
-Allerdings ist pd auf Grund seiner graphischen Natur ein {\em objektorientiertes} System.
+Pd ist in der Programmiersprache {\tt C} geschrieben.
+Allerdings ist Pd auf Grund seiner graphischen Natur ein {\em objektorientiertes} System.
 Da {\tt C} die Verwendung von Klassen nicht sehr gut unterstützt, ist der resultierende
 Quellcode nicht so elegant wie er zum Beispiel unter {\tt C++} wäre.
 
@@ -123,13 +123,13 @@ Um Begriffsverwirrungen von vorneherein auszuschließen, seien hier kurz die Ausd
 {\em Internal}, {\em External} und {\em Library} erklärt.
 
 \paragraph{Internal}
-Ein {\em Internal} ist eine Klasse, die in pd eingebaut ist.
+Ein {\em Internal} ist eine Klasse, die in Pd eingebaut ist.
 Viele Primitive wie ``+'', ``pack'' oder ``sig\~\/`` sind {\em Internals}
 
 \paragraph{External}
-Ein {\em External} ist eine Klasse, die nicht in pd eingebaut ist und erst zur Laufzeit
+Ein {\em External} ist eine Klasse, die nicht in Pd eingebaut ist und erst zur Laufzeit
 nachgeladen wird.
-Sind sie einmal im Speicher von pd, so sind {\em Externals} nicht mehr von {\em Internals} zu
+Sind sie einmal im Speicher von Pd, so sind {\em Externals} nicht mehr von {\em Internals} zu
 unterscheiden.
 
 \paragraph{Library}
@@ -149,18 +149,18 @@ Die einfachste Form einer {\em Library} beinhaltet genau ein {\em External},
 das den selben Name trägt, wie auch die {\em Library}
 
 Im Gegensatz zu Externals können {\em Libraries} mit bestimmten Befehlen
-von pd importiert werden.
+von Pd importiert werden.
 Ist eine {\em Library} importiert worden,
 so sind alle {\em Externals}, die sie beinhaltet,
 in den Speicher geladen und stehen als Objekte zur Verfügung.
 
-pd stellt zwei Methoden zur Verfügung, um {\em Libraries} zu laden:
+Pd stellt zwei Methoden zur Verfügung, um {\em Libraries} zu laden:
 \begin{itemize}
 \item mit der commandline-Option ``{\tt -lib my\_lib}''
 \item durch Kreieren eines Objektes ``{\tt my\_lib}''
 \end{itemize}
 
-Die erste Methode lädt die {\em Library} sofort beim Starten von pd.
+Die erste Methode lädt die {\em Library} sofort beim Starten von Pd.
 Dies ist die zu bevorzugende Methode für {\em Libraries},
 die mehrere {\em Externals} beinhalten.
 
@@ -194,8 +194,8 @@ Ein Objekt soll geschaffen werden, dass jedesmal, wenn es
 mit ``bang'' getriggert wird, die Zeile ``Hello world!!'' auf
 die Standardausgabe schreibt.
 
-\subsection{die Schnittstelle zu pd}
-Um ein pd-External zu schreiben, braucht man eine wohldefinierte Schnittstelle.
+\subsection{die Schnittstelle zu Pd}
+Um ein Pd-External zu schreiben, braucht man eine wohldefinierte Schnittstelle.
 Diese wird in der Datei ``m\_pd.h'' zur Verfügung gestellt.
 
 \begin{verbatim}
@@ -234,7 +234,7 @@ Manipulatoren (Methoden) mit denen diese Daten manipuliert werden können.
 
 Wird eine Message an eine Instanz unserer Klasse geschickt,
 so wird eine Methoden aufgerufen.
-Diese Mehtoden, die die Schnittstelle zum Messagesystem von pd bilden, 
+Diese Mehtoden, die die Schnittstelle zum Messagesystem von Pd bilden, 
 haben grundsätzlich kein Rückgabeargument, sind also vom Typ \verb+void+.
 
 \begin{verbatim}
@@ -258,11 +258,11 @@ Ansonsten funktioniert \verb+post()+ gleich wie der {\tt C}-Befehl \verb+printf(
 \subsection{Generierung einer neuen Klasse}
 Um eine neue Klasse zu generieren, müssen Angaben über
 den Datenraum und den Methodenraum dieser Klasse 
-beim Laden einer Library an pd übergeben werden.
+beim Laden einer Library an Pd übergeben werden.
 
 Wird eine neue Library ``my\_lib'' geladen,
-so versucht pd eine Funktion ``my\_lib\_setup()'' aufzurufen.
-Diese Funktion (oder von ihr aufgerufene Funktionen) teilt pd mit,
+so versucht Pd eine Funktion ``my\_lib\_setup()'' aufzurufen.
+Diese Funktion (oder von ihr aufgerufene Funktionen) teilt Pd mit,
 welche Eigenschaften die neuen Klassen haben.
 Sie wird nur einmal, beim Laden der Library aufgerufen.
 
@@ -286,16 +286,16 @@ Prototyp zurück.
 Das erste Argument ist der symbolische Name der Klasse.
 
 Die nächsten beiden Argumente definieren Konstruktor und Destruktor der Klasse.
-Wenn in einen pd-Patch ein Objekt kreiert wird, 
+Wenn in einen Pd-Patch ein Objekt kreiert wird, 
 instanziiert der Konstruktor \verb+(t_newmethod)helloworld_new+ diesses Objekt
 und initialisiert den Datenraum.
-Wird ein pd-Patch geschlossen oder ein Objekt daraus entfernt,
+Wird ein Pd-Patch geschlossen oder ein Objekt daraus entfernt,
 so gibt der Destruktor, wenn notwendig, dynamisch reservierten Speicher wieder frei.
-Der Speicherplatz für den Datenraum selbst wird von pd automatisch freigegeben.
+Der Speicherplatz für den Datenraum selbst wird von Pd automatisch freigegeben.
 Deshalb kann in diesem Beispiel auf einen Destruktor verzichtet werden,
 folglich wird dieses Argument auf ``0'' gesetzt.
 
-Damit pd genug Speicher für den Datenraum allozieren und wieder freigeben kann,
+Damit Pd genug Speicher für den Datenraum allozieren und wieder freigeben kann,
 wird die Größe dieser Datenstruktur als viertes Argument übergeben.
 
 Das fünfte Argument bestimmt, wie Klasseninstanzen graphisch dargestellt werden und 
@@ -325,7 +325,7 @@ Diese Methode ist das zweite Argument.
 
 
 \subsection{Konstruktor: Instanziierung eines Objektes}
-Jedesmal, wenn in einem pd-Patch ein Objekt einer Klasse kreiert wird,
+Jedesmal, wenn in einem Pd-Patch ein Objekt einer Klasse kreiert wird,
 schafft der mit \verb+class_new+ angegebene Konstruktor eine neue Instanz der Klasse.
 
 Der Konstruktor ist immer vom Typ \verb+void *+
@@ -636,7 +636,7 @@ wird ebenfalls eine Methode zur Klasse hinzugefügt.
   class_sethelpsymbol(counter_class, gensym("help-counter"));
 \end{verbatim}
 
-Clickt man mit der rechten Maustaste auf ein pd-Objekt,
+Clickt man mit der rechten Maustaste auf ein Pd-Objekt,
 so kann man sich einen Hilfe-Patch für die zugehörige Objektklasse anzeigen lasse.
 Standardmäßig wird ist dies ein Patch mit dem symbolischen Klassennamen
 im Verzeichnis ``{\em doc/5.reference/}'' gesucht.
@@ -955,7 +955,7 @@ void pan_tilde_setup(void) {
 \end{verbatim}
 
 Jeder Signalklasse muss eine Methode für die Signalverarbeitung zugeordnet werden.
-Wenn die Audioengine von pd gestartet wird, wird allen Objekten eine
+Wenn die Audioengine von Pd gestartet wird, wird allen Objekten eine
 Message mit dem Selector ``\verb+dsp+'' geschickt.
 Alle Klassen, die eine Methode für die ``dsp''-Message haben, sind Signalklassen.
 
@@ -999,7 +999,7 @@ Selector ``signal'' versehen ist.
 
 
 \subsection{DSP-Methode}
-Wenn die Audio-Engine von pd eingeschalten wird,
+Wenn die Audio-Engine von Pd eingeschalten wird,
 so teilen ihr alle Signal-Objekte mit,
 welche Methode von ihrer Klasse zur digitalen Signalverarbeitung herangezogen werden soll.
 
@@ -1206,18 +1206,18 @@ Zum Beispiel sind also die Messages ``\verb+12.429+'' und ``\verb+float 12.429+'
 Ebenfalls ident sind auch die Listen-Messages
 ``\verb+list 1 kleines Haus+'' und ``\verb+1 kleines Haus+''.
 
-\section{pd-Typen}
-Da pd auf mehreren Plattformen benutzt wird,
+\section{Pd-Typen}
+Da Pd auf mehreren Plattformen benutzt wird,
 werden viele gewöhnliche Variablentypen, wie \verb|int|, neu definiert.
-Um portablen Code zu schreiben ist es daher angebracht, die von pd bereitgestellten
+Um portablen Code zu schreiben ist es daher angebracht, die von Pd bereitgestellten
 Typen zu verwenden.
 
 Weiters gibt es viele vordefinierte Typen,
 die das Leben des Programmierers vereinfachen sollten.
-pd-Typen beginnen im Allgemeinen mit \verb|t_|.
+Pd-Typen beginnen im Allgemeinen mit \verb|t_|.
 
 \begin{tabular}{c|l}
-pd-Type & Beschreibung \\
+Pd-Type & Beschreibung \\
 \hline\hline
 \verb+t_atom+& Atom \\
 \verb+t_float+ & Gleitkomma-Zahl \\
@@ -1231,7 +1231,7 @@ pd-Type & Beschreibung \\
 \verb+t_inlet+ & Inlet eines Objekts \\
 \verb+t_object+ & Objekt-Interna \\
 \hline
-\verb+t_class+ & eine pd-Klasse \\
+\verb+t_class+ & eine Pd-Klasse \\
 \verb+t_method+ & Zeiger auf Klassenmethode \\
 \verb+t_newmethod+ & Zeiger auf Klasseninstanziierungsmethode (new-Routine) \\
 \end{tabular}
@@ -1503,7 +1503,7 @@ Die ``0''-terminierte Typenliste entspricht der von \verb+class_new+.
 void class_sethelpsymbol(t_class *c, t_symbol *s);
 \end{verbatim}
 
-Clickt man mit der rechten Maustaste auf ein pd-Objekt,
+Clickt man mit der rechten Maustaste auf ein Pd-Objekt,
 so kann man sich einen Hilfe-Patch für die zugehörige Objektklasse anzeigen lasse.
 Standardmäßig wird ist dies ein Patch mit dem symbolischen Klassennamen
 im Verzeichnis ``{\em doc/5.reference/}'' gesucht.
@@ -1798,7 +1798,7 @@ void error(char *fmt, ...);
 
 Schreibt einen {\tt C}-String als Fehlermeldung auf den Standarderror (Shell).
 Das Objekt, das die Fehlermeldung ausgegeben hat, wird markiert und
-ist über das pd-Menü {\em Find->Find last error} identifizierbar.
+ist über das Pd-Menü {\em Find->Find last error} identifizierbar.
 
 \end{appendix}
 
diff --git a/doc/tutorials/externals-howto/HOWTO-externals-en.tex b/doc/tutorials/externals-howto/HOWTO-externals-en.tex
index 6ad3328d..26faae2b 100644
--- a/doc/tutorials/externals-howto/HOWTO-externals-en.tex
+++ b/doc/tutorials/externals-howto/HOWTO-externals-en.tex
@@ -1,6 +1,6 @@
 % format latexg -*- latex -*-
 
-\documentclass[12pt, a4paper,austrian, titlepage]{article}  
+\documentclass[12pt, a4paper,english,titlepage]{article}  
 
 %% HOWTO write an external for pd
 %% Copyright (c) 2001-2006 by IOhannes m zmölnig
@@ -18,13 +18,13 @@
 \title{
 HOWTO \\
 write an External \\
-for {\em puredata}
+for {\em Pure Data}
 }
 
 \author{
 johannes m zmölnig \\
 \\
-{\em institut for electronic music and acoustics\footnote{http://iem.at}}
+{\em institute of electronic music and acoustics\footnote{http://iem.at}}
 }
 
 \date{}
@@ -33,18 +33,18 @@ johannes m zmölnig \\
 \maketitle
 
 \begin{abstract}
-pd is a graphical real-time computer-music system that follows the tradition of
+Pd is a graphical real-time computer-music system that follows the tradition of
 IRCAMs {\em ISPW-max}.
 
-Although plenty of functions are built into pd,
+Although plenty of functions are built into Pd,
 it is sometimes a pain or simply impossible to create a patch with a certain
 functionality out of the given primitives and combinations of these.
 
-Therefore, pd can be extended with self made primitives (``objects'')
+Therefore, Pd can be extended with self made primitives (``objects'')
 that are written in complex programming-languages, like {\tt C/C++}. 
 
 This document aims to explain, how to write such primitives in {\tt C},
-the popular language that was used to realize pd.
+the popular language that was used to realize Pd.
 \end{abstract}
 
 
@@ -57,20 +57,20 @@ the popular language that was used to realize pd.
 \newpage
 
 \section{definitions and prerequisites}
-pd refers to the graphical real-time computer-music environment {\em pure data}
+Pd refers to the graphical real-time computer-music environment {\em Pure Data}
 by Miller~S.~Puckette.
 
 To fully understand this document, it is necessary to
-be acquainted with pd and to 
+be acquainted with Pd and to 
 have a general understanding of programming techniques especially in {\tt C}.
 
 To write externals yourself, a {\tt C}-compiler that supports the
 {\tt ANSI-C}-Standard, like the {\em Gnu C-compiler} (gcc) on linux-systems or
-{\em Visual-C++ 6.0} (vc6) on windos-plattforms, will be necessary.
+{\em Visual-C++} on windos-plattforms, will be necessary.
 
 \subsection{classes, instances, objects}
-pd is written in the programming-language {\tt C}.
-Due to its graphical nature, pd is a {\em object-oriented} system.
+Pd is written in the programming-language {\tt C}.
+Due to its graphical nature, Pd is a {\em object-oriented} system.
 Unfortunately {\tt C} does not support very well the use of classes.
 Thus the resulting source-code is not as elegant as {\tt C++}-code would be, for instance.
 
@@ -85,12 +85,12 @@ To avoid confusion of ideas, the expressions {\em internal}, {\em external} and
 {\em library} should be explained here.
 
 \paragraph{Internal}
-An {\em internal} is a class that is built into pd.
+An {\em internal} is a class that is built into Pd.
 Plenty of primitives, such as ``+'', ``pack'' or ``sig\~\/'' are {\em internals}.
 
 \paragraph{External}
-An {\em external} is a class that is not built into pd but is loaded at runtime.
-Once loaded into pd's memory, {\em externals} cannot be distinguished from
+An {\em external} is a class that is not built into Pd but is loaded at runtime.
+Once loaded into Pd's memory, {\em externals} cannot be distinguished from
 {\em internals} any more.
 
 \paragraph{Library}
@@ -109,23 +109,23 @@ library & linux&irix&Win32 \\
 The simplest form of a {\em library} includes exactly one {\em external}
 bearing the same name as the {\em library}.
 
-Unlike {\em externals}, {\em libraries} can be imported by pd with special operations.
+Unlike {\em externals}, {\em libraries} can be imported by Pd with special operations.
 After a {\em library} has been imported,
 all included {\em externals} have been loaded into memory and are available as objects.
 
-pd supports to modes to import {\em libraries}:
+Pd supports to modes to import {\em libraries}:
 
 \begin{itemize}
 \item via the command line-option ``{\tt -lib my\_lib}''
 \item by creating an object ``{\tt my\_lib}''
 \end{itemize}
 
-The first method loads a {\em library} when pd is started.
+The first method loads a {\em library} when Pd is started.
 This method is preferably used for {\em libraries} that contain several {\em externals}.
 
 The other method should be used for {\em libraries} that contain exactly
 one {\em external} bearing the same name.
-pd checks first, whether a class named ``my\_lib'' is already loaded.
+Pd checks first, whether a class named ``my\_lib'' is already loaded.
 If this is not the case\footnote{
 If a class ``my\_lib'' is already existent, an object ``my\_lib'' will be instantiated
 and the procedure is done. 
@@ -149,8 +149,8 @@ the standard error every time it is triggered with a ``bang''-message.
 
 
 
-\subsection{the interface to pd}
-To write a pd-external a well-defined interface is needed.
+\subsection{the interface to Pd}
+To write a Pd-external a well-defined interface is needed.
 This is provided in the header-file ``m\_pd.h''.
 
 \begin{verbatim}
@@ -188,7 +188,7 @@ Apart from the data space, a class needs a set of manipulators (methods) to
 manipulate the data with.
 
 If a message is sent to an instance of our class, a method is called.
-These methods are the interfaces to the message system of pd.
+These methods are the interfaces to the message system of Pd.
 On principal they have no return argument and are therefore are of the
 type \verb+void+.
 
@@ -213,10 +213,10 @@ Apart from this, the \verb+post+-command works like the {\tt C}-command \verb+pr
 
 \subsection{generation of a new class}
 To generate a new class, information of the data space and the method space of this class,
-have to be passed to pd when a library is loaded.
+have to be passed to Pd when a library is loaded.
 
 On loading a new library ``my\_lib'',
-pd tries to call a function ``my\_lib\_setup()''.
+Pd tries to call a function ``my\_lib\_setup()''.
 This function (or functions called by it) 
 declares the new classes and their properties.
 It is only called once, when the library is loaded.
@@ -243,7 +243,7 @@ The first argument is the symbolic name of the class.
 
 The next two arguments define the constructor and destructor of the class.
 
-Whenever a class object is created in a pd-patch,
+Whenever a class object is created in a Pd-patch,
 the class-constructor \verb+(t_newmethod)helloworld_new+ instantiates the object
 and initialises the data space.
 
@@ -255,7 +255,7 @@ The allocated memory for the static data space is automatically reserved and fre
 Therefore we do not have to provide a destructor in this example, the argument
 is set to ``0''.
 
-To enable pd to reserve and free enough memory for the static data space,
+To enable Pd to reserve and free enough memory for the static data space,
 the size of the data structure has to be passed as the fourth argument.
 
 The fifth argument has influence on the graphical representation of the class objects.
@@ -281,7 +281,7 @@ The added method is defined in the second argument.
 
 
 \subsection{constructor: instantiation of an object}
-Each time, an object is created in a pd-patch, the
+Each time, an object is created in a Pd-patch, the
 constructor that is defined with the \verb+class_new+-command,
 generates a new instance of the class.
 
@@ -398,7 +398,7 @@ void counter_setup(void) {
 \end{verbatim}
 
 So we have an additional argument in the function \verb+class_new+:
-\verb+A_DEFFLOAT+ tells pd, that the object needs one argument of the 
+\verb+A_DEFFLOAT+ tells Pd, that the object needs one argument of the 
 type \verb+t_floatarg+.
 If no argument is passed, this will default to ``0''.
 
@@ -583,7 +583,7 @@ as well as a method for the selector ``bound'' followed by two numerical values.
   class_sethelpsymbol(counter_class, gensym("help-counter"));
 \end{verbatim}
 
-If a pd-object is right-clicked, a help-patch describing the object-class can be opened.
+If a Pd-object is right-clicked, a help-patch describing the object-class can be opened.
 By default, this patch is located in the directory ``{\em doc/5.reference/}'' and
 is named like the symbolic class name.
 
@@ -854,7 +854,7 @@ void counter_setup(void) {
 
 
 \section{a signal-external: {\tt pan\~\/}}
-Signal classes are normal pd-classes, that offer additional methods for signals.
+Signal classes are normal Pd-classes, that offer additional methods for signals.
 
 
 All methods and concepts that can be realized with normal object classes can
@@ -905,7 +905,7 @@ void pan_tilde_setup(void) {
 
 A method for signal-processing has to be provided by each signal class.
 
-Whenever pd's audio engine is started, a message with the selector ``dsp''
+Whenever Pd's audio engine is started, a message with the selector ``dsp''
 is sent to each object.
 Each class that has a method for the ``dsp''-message is recognised as signal class.
 
@@ -950,7 +950,7 @@ Signal-outlets are also created like normal (message-)outlets,
 by setting the outlet-selector to ``signal''.
 
 \subsection{DSP-methods}
-Whenever pd's audio engine is turned on,
+Whenever Pd's audio engine is turned on,
 all signal-objects declare their perform-routines that are to be added to the DSP-tree.
 
 The ``dsp''-method has two arguments, the pointer to the class-data space, and 
@@ -1090,7 +1090,7 @@ void pan_tilde_setup(void) {
 \newpage
 \begin{appendix}
 
-\section{pd's message-system}
+\section{Pd's message-system}
 Non-audio-data are distributed via a message-system.
 Each message consists of a ``selector'' and a list of atoms.
 
@@ -1157,18 +1157,18 @@ are recognised automatically either as ``float''-message (only one atom) or as
 For example, messages ``\verb+12.429+'' and ``\verb+float 12.429+'' are identical.
 Likewise, the messages ``\verb+list 1 for you+'' is identical to ``\verb+1 for you+''.
 
-\section{pd-types}
-Since pd is used on several platforms,
+\section{Pd-types}
+Since Pd is used on several platforms,
 many ordinary types of variables, like \verb|int|, are re-defined.
-To write portable code, it is reasonable to use types provided by pd.
+To write portable code, it is reasonable to use types provided by Pd.
 
 Apart from this there are many predefined types,
 that should make the life of the programmer simpler.
 
-Generally, pd-types start with \verb|t_|.
+Generally, Pd-types start with \verb|t_|.
 
 \begin{tabular}{c|l}
-pd-type & description \\
+Pd-type & description \\
 \hline\hline
 \verb+t_atom+& atom \\
 \verb+t_float+ & floating point value\\
@@ -1182,7 +1182,7 @@ pd-type & description \\
 \verb+t_inlet+ & inlet of an object \\
 \verb+t_object+ & object-interna \\
 \hline
-\verb+t_class+ & a pd-class \\
+\verb+t_class+ & a Pd-class \\
 \verb+t_method+ & class-method \\
 \verb+t_newmethod+ & pointer to a constructor (new-routine) \\
 \end{tabular}
@@ -1433,7 +1433,7 @@ The ``0''-terminated list of types corresponds to that of \verb+class_new+.
 void class_sethelpsymbol(t_class *c, t_symbol *s);
 \end{verbatim}
 
-If a pd-object is right-clicked, a help-patch for the corresponding object class
+If a Pd-object is right-clicked, a help-patch for the corresponding object class
 can be opened.
 By default this is a patch with the symbolic class name in the
 directory ``{\em doc/5.reference/}''.
@@ -1608,7 +1608,7 @@ If a class should provide methods for digital signal-processing,
 a method for the selector ``dsp'' (followed by no atoms)
 has to be added to this class
 
-Whenever pd's audio engine is started,
+Whenever Pd's audio engine is started,
 all objects that provide a ``dsp''-method are identified as instances of signal classes.
 
 \paragraph{DSP-method}
@@ -1739,7 +1739,7 @@ void error(char *fmt, ...);
 Writes a {\tt C}-string as an error-message to the standard error (shell).
 
 The object that has output the error-message is marked and
-can be identified via the pd-menu {\em Find->Find last error}.
+can be identified via the Pd-menu {\em Find->Find last error}.
 
 \end{appendix}