Awk: Weiterführende Themen

<mediawiki xmlns="http://www.mediawiki.org/xml/export-0.11/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.mediawiki.org/xml/export-0.11/ http://www.mediawiki.org/xml/export-0.11.xsd" version="0.11" xml:lang="de">
  <siteinfo>
    <sitename>Wikibooks</sitename>
    <dbname>dewikibooks</dbname>
    <base>https://de.wikibooks.org/wiki/Hauptseite</base>
    <generator>MediaWiki 1.47.0-wmf.9</generator>
    <case>first-letter</case>
    <namespaces>
      <namespace key="-2" case="first-letter">Medium</namespace>
      <namespace key="-1" case="first-letter">Spezial</namespace>
      <namespace key="0" case="first-letter" />
      <namespace key="1" case="first-letter">Diskussion</namespace>
      <namespace key="2" case="first-letter">Benutzer</namespace>
      <namespace key="3" case="first-letter">Benutzer Diskussion</namespace>
      <namespace key="4" case="first-letter">Wikibooks</namespace>
      <namespace key="5" case="first-letter">Wikibooks Diskussion</namespace>
      <namespace key="6" case="first-letter">Datei</namespace>
      <namespace key="7" case="first-letter">Datei Diskussion</namespace>
      <namespace key="8" case="first-letter">MediaWiki</namespace>
      <namespace key="9" case="first-letter">MediaWiki Diskussion</namespace>
      <namespace key="10" case="first-letter">Vorlage</namespace>
      <namespace key="11" case="first-letter">Vorlage Diskussion</namespace>
      <namespace key="12" case="first-letter">Hilfe</namespace>
      <namespace key="13" case="first-letter">Hilfe Diskussion</namespace>
      <namespace key="14" case="first-letter">Kategorie</namespace>
      <namespace key="15" case="first-letter">Kategorie Diskussion</namespace>
      <namespace key="102" case="first-letter">Regal</namespace>
      <namespace key="103" case="first-letter">Regal Diskussion</namespace>
      <namespace key="710" case="first-letter">TimedText</namespace>
      <namespace key="711" case="first-letter">TimedText talk</namespace>
      <namespace key="828" case="first-letter">Modul</namespace>
      <namespace key="829" case="first-letter">Modul Diskussion</namespace>
      <namespace key="1728" case="first-letter">Veranstaltung</namespace>
      <namespace key="1729" case="first-letter">Veranstaltung Diskussion</namespace>
    </namespaces>
  </siteinfo>
  <page>
    <title>Awk: Weiterführende Themen</title>
    <ns>0</ns>
    <id>13348</id>
    <revision>
      <id>1088590</id>
      <parentid>862943</parentid>
      <timestamp>2026-07-03T15:11:36Z</timestamp>
      <contributor>
        <username>Intruder</username>
        <id>1513</id>
      </contributor>
      <minor />
      <comment>/* Debugging */ Tippf. korr.</comment>
      <origin>1088590</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="4420" sha1="42krp5b4t16xs7exxl9vhqvmd0e45cp" xml:space="preserve">{{Navigation_zurückhochvor_buch|
zurücktext=Grundlagen|
zurücklink=Awk:_Grundlagen|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Awk|
vortext=Anwendungsbeispiele|
vorlink=Awk:_Anwendungsbeispiele}}


==Debugging==

Mit '''dgawk''' gibt es für AWK einen mächtigen Debugger. Weitergehende Informationen sind in der [http://www.gnu.org/software/gawk/manual/gawk.html#Debugger gawk-Doku] zu finden. In den meisten Linux-Distributionen ist '''dgawk''' nicht in den Repositories enthalten. Deshalb muss man ggf. das Paket selber neu bauen.

==Profiling==
''pgawk'' ist eine spezielle Variante von ''gawk'' extra für Profilingzwecke.

Beispiel: Gegeben sei die Eingabedatei ''prof.txt'' mit dem Inhalt

 1 Freddy
 2 Maxi
 3 Mimi
 4 Zenzi
 5 Susi
 6 Franzi
 7 Resi
 8 Hilda

''awk''-Skript:

 #!/usr/bin/pgawk -f
 BEGIN {print &quot;ANFANG&quot;}
 $2~/^[A-M]/ {print $1 &quot;: &quot; $2}
 END {print &quot;ENDE&quot;}

Inhalt der Profilingdatei ''awkprof.out'':

 # gawk-Profil, erzeugt Wed Nov 16 10:12:41 2005
 # BEGIN block(s)
 BEGIN { 1 print &quot;ANFANG&quot; }
 # Rule(s)
 8 $2 ~ /^[A-M]/ { # 5 5 print (($1 &quot;: &quot;) $2) }
 # END block(s)
 END { 1 print &quot;ENDE&quot; }

Beschreibung von ''awkprof.out'': Die ''awkprof.out''-Datei enthält den von uns erstellten ''awk''-Code, ergänzt um Kommentare und Zahlen. Die Zahlen vor den Bedingungen und Aktionen zeigen die Häufigkeit des Aufrufes der entsprechenden Anweisungen. Die BEGIN- und END-Aktion wurden logischerweise nur 1x aufgerufen, die Suchbedingung 8x und die dazugehörige Aktion bzw. print-Anweisung 5x.

==Funktionsbibliotheken==
Wenn ein Skript zu umfangreich und unübersichtlich wird oder einzelne Funktionen zwecks Wiederverwendung an zentraler Stelle gesammelt werden sollen, so können einzelne Funktionen in sogenannte Funktionsbibliotheken ausgelagert werden. Eine solche Funktionsbibliothek ist nichts anderes als ein normales ''awk''-Skript.

Beispiel: 

''funktionsbibliothek.awk'':
 
 function schreibe(a,b) { print a &quot;: &quot; b }

''skript.awk'':

 #!/usr/bin/awk -f 
 BEGIN {print &quot;ANFANG&quot;} 
 $2~/^[A-M]/ {schreibe($1, $2)} 
 END {print &quot;ENDE&quot;}

Aufruf:

 awk -f funktionsbibliothek.awk -f skript.awk eingabedatei.txt

Siehe auch die Möglichkeit mit igawk in Abschnitt ''[[Awk:_Grundlagen:_Objektorientierte_Programmierung#Pakete.2FBiblotheken|Objektorientierte Programmierung]]''.

==gawk im Netzwerk==
(ab ''gawk''-Release 3.1)

===Bidirektionale Pipeline===
Mit dem  |&amp;-Operator kann eine bidirektionale Pipeline eingerichtet werden.

Bsp: 

 print var |&amp; kommando

===Netzwerkadressierung===
Die Netzwerkadressierung erfolgt über einen Dateinamen in der Form
 
 /inet/protocol/localport/hostname/remoteport

mit
*''protocol'': ''tcp'', ''udp'' oder ''raw''
*''localport'': Port auf dem lokalen Host (siehe auch /etc/services)
*''hostname'': symbolischer Name oder IP-Nummer des entfernten Hosts
*''remoteport'': Port auf dem entfernten Host (siehe auch /etc/services)

===Beispiel: Lokalen FTP-Server abfragen===

 #!/usr/bin/awk -f
 
 BEGIN {
   inetService = &quot;/inet/tcp/0/localhost/ftp&quot;   # Variable für Netzwerkadressierung setzen
   inetService |&amp; getline                      # bidirektionale Pipeline etablieren
   print $0                                    # Meldung ausgeben
   close(inetService)                          # Pipeline komplett schliessen
 }
 
Ausgabe (natürlich nur wenn ein FTP-Server auf der lokalen Machine eingerichtet ist):

  220 meinrechner.local FTP server (Version 6.5/OpenBSD, linux port 0.3.3) ready

===Beispiel: Einlesen einer Webseite (HTTP)===

 #!/usr/bin/awk -f
 
 BEGIN {
   RS = ORS = &quot;\r\n&quot;
   inetService = &quot;/inet/tcp/0/www.yahoo.de/80&quot;        # Variable für Netzwerkadressierung setzen
   &lt;nowiki&gt;print &quot;GET / HTTP/1.0\r\n&quot; |&amp; inetService          # bidirektionale Pipeline etablieren&lt;/nowiki&gt;
                                                      # (zwei \r\n nötig)
   while ((inetService |&amp; getline) &gt; 0)               # Lies in $0 ein, solange nicht EOF oder Error 
     print $0                                         # Gib $0 aus
   close(inetService)                                 # bidiektionale Pipeline komplett schließen
 }

Ausgabe:

 &lt;nowiki&gt;The document has moved &lt;A HREF=&quot;http://de.yahoo.com/&quot;&gt;here&lt;/A&gt;.&lt;P&gt;&lt;/nowiki&gt;


{{Navigation_zurückhochvor_buch|
zurücktext=Grundlagen|
zurücklink=Awk:_Grundlagen|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Awk|
vortext=Anwendungsbeispiele|
vorlink=Awk:_Anwendungsbeispiele}}</text>
      <sha1>42krp5b4t16xs7exxl9vhqvmd0e45cp</sha1>
    </revision>
  </page>
  <page>
    <title>Gitarre: der Cis-Moll und Gis-Akkord</title>
    <ns>0</ns>
    <id>41133</id>
    <revision>
      <id>1088595</id>
      <parentid>1038878</parentid>
      <timestamp>2026-07-04T05:57:15Z</timestamp>
      <contributor>
        <username>Mjchael</username>
        <id>2222</id>
      </contributor>
      <comment>/* In welcher Tonart kommt C#m oder G#m vor */</comment>
      <origin>1088595</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="4816" sha1="ai0f2wjsrljdhauap1tt7azc99oo3ni" xml:space="preserve">{{:Gitarre/ Navi|Rockdiplom|
{{:Gitarre:_Rockdiplom/ Navi}}|
{{:Gitarre:_Rockdiplom/ Navi_Barree_1}}|
img=Rockdiplom.gif |bg=LightCyan|border=indigo|color=indigo}}


&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;G#m&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 black )
   (place-fret 2 4 1 darkgrey )
   (place-fret 3 4 1 darkgrey )
   (place-fret 4 6 3 black )
   (place-fret 5 6 3 darkgrey ) 
   (place-fret 6 4 1 black )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;G#&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 black )
   (place-fret 2 4 1 darkgrey )
   (place-fret 3 5 2 darkgrey )
   (place-fret 4 6 3 black )
   (place-fret 5 6 3 darkgrey ) 
   (place-fret 6 4 1 black )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
{{clear}}

== In welcher Tonart kommt C#m oder G#m vor ==

Cis-Moll (kurz C#m) ist die Moll-Parallele von E-Dur. Das heißt, dass C#m meistens in der Tonart auftaucht, wo auch ein E-Dur-Akkord auftaucht. 

Gis-Moll (kurz G#m) ist die Moll-Parallele von H-Dur. Das heißt, dass G#m meistens in der Tonart auftaucht, wo auch ein H-Dur-Akkord auftaucht. 

{| class=&quot;wikitable zebra&quot;
!Tonart
!Subdom.
!Tonika
!Dom.
!Subdom.&lt;br /&gt;parall.
!Tonika.&lt;br /&gt;parall.
!Dom.&lt;br /&gt;parall.
|-
| &lt;b&gt;A&lt;/b&gt; ||D||A||E7||Bm||F#m||&lt;b&gt;C#m&lt;/b&gt; (C#)
|-
| &lt;b&gt;E&lt;/b&gt; ||A||E||H7||F#m||&lt;b&gt;C#m&lt;/b&gt;||&lt;b&gt;G#m&lt;/b&gt; (G#)
|-
| &lt;b&gt;H&lt;/b&gt; ||E||H||F#7||&lt;b&gt;C#m&lt;/b&gt;||&lt;b&gt;G#m&lt;/b&gt;||D#m (D#)
|}

Du erinnerst dich doch noch daran, dass die Dominante einer Molltonarten  auch als Dur-Akkord auftauchen kann und dass es Zwischendominanten gibt. Von daher sollte es dich nicht wundern, wenn G#m und F#m auch mal als G#-Dur und F#-Dur auftauchen.

== Sprung in den vierten Bund ==
Grifftechnisch machen die Akkorde nicht mehr Probleme, als die vorhergehenden. Du musst nur wissen, wo sie hin gehören.

Der Grundton vom G ist &quot; &quot;'''g'''anz oben und '''g'''anz unten&quot;. Ebenso sind die Grundtöne der Barré-Akkorde der E-Form ganz oben und ganz unten. Wenn du weißt, dass der Grundton vom G auf der E-Saite im 3. Bund ist, dann muss der Grundton vom  G# genau einen Bund weiter sein, also im 4. Bund. 

Orientiere dich auch an der Markierung im 5. Der Zeigefinger kommt beim G#m also einen Bund vor dem 5. Bund.
{|
|[[Image:Crd G.svg]]
|&lt;big&gt;'''G#m'''&lt;/big&gt; - '''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg]]
|}

Der Grundton vom C ist auf der A-Saite im dritten Bund. Demnach ist der Grundton  vom C#m im 4. Bund. 

{|
|[[Image:Crd C.svg]]
|&lt;big&gt;'''C#m'''&lt;/big&gt;  - '''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Am-Typ.svg]]
|}

== Vier Positionen zum merken ==
{|class=&quot;wikitable zebra&quot;
!Form ||&amp;nbsp; 2.Bund &amp;nbsp; || &amp;nbsp; 4.Bund &amp;nbsp; || &amp;nbsp; Position
|-
|Am-Form || Hm || C#m || (unten)
|-
|Em-Form || F#m || G#m || (oben)
|}

; Beispiel 
:G#m = 4.oben
:Hm = 2. unten


{|
|&lt;big&gt;'''F#m'''&lt;/big&gt;&lt;br /&gt;'''2.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg|150px]]
|&lt;big&gt;'''F#'''&lt;/big&gt;&lt;br /&gt;'''2.Bund'''&lt;br /&gt;[[Image:Crd Barré F-Typ.svg|150px]]
|&lt;big&gt;'''G#m'''&lt;/big&gt;&lt;br /&gt;'''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg|150px]]
|&lt;big&gt;'''G#'''&lt;/big&gt;&lt;br /&gt;'''4.Bund'''&lt;br /&gt;[[Image:Crd Barré F-Typ.svg|150px]]
|}

Suche dir Lieder in E- und A-Dur heraus, wo auch die neuen Akkorde vorkommen. Spiele wenigstens einmal pro Tag ein Lied mit C#m und mit G#m. Erweitere dein Repertoire mit Barré-Liedern.

{{:Gitarre:_Liedervorschlag|
{{:Gitarre: Liedervorschläge/ Lieder mit Cis-_und_Gis-Moll}}
{{Navigation hoch}}
|img=Rockdiplom.gif |bg=LightCyan|border=indigo|color=indigo}}</text>
      <sha1>ai0f2wjsrljdhauap1tt7azc99oo3ni</sha1>
    </revision>
    <revision>
      <id>1088596</id>
      <parentid>1088595</parentid>
      <timestamp>2026-07-04T06:57:27Z</timestamp>
      <contributor>
        <username>Mjchael</username>
        <id>2222</id>
      </contributor>
      <origin>1088596</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="6588" sha1="d4fmhze8qpamk2yowm5mkkesf1n6ogq" xml:space="preserve">{{:Gitarre/ Navi|Rockdiplom|
{{:Gitarre:_Rockdiplom/ Navi}}|
{{:Gitarre:_Rockdiplom/ Navi_Barree_1}}|
img=Rockdiplom.gif |bg=LightCyan|border=indigo|color=indigo}}


&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;G#m&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 black )
   (place-fret 2 4 1 darkgrey )
   (place-fret 3 4 1 darkgrey )
   (place-fret 4 6 3 black )
   (place-fret 5 6 3 darkgrey ) 
   (place-fret 6 4 1 black )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;G#&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 black )
   (place-fret 2 4 1 darkgrey )
   (place-fret 3 5 2 darkgrey )
   (place-fret 4 6 3 black )
   (place-fret 5 6 3 darkgrey ) 
   (place-fret 6 4 1 black )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;C#m&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 darkgrey )
   (place-fret 2 5 2 darkgrey )
   (place-fret 3 6 3 black )
   (place-fret 4 6 3 darkgrey ) 
   (place-fret 5 4 1 black )
   (place-fret 6 4 1 darkgrey )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
{{clear}}
{{Todo|Feststellen, warum es zu Darstellungsfehlern kommt. Der Syntax stimmt.|Mjchael|Gitarre}}
&lt;score&gt;
&lt;&lt;
  \new ChordNames { \chordmode {
    fis1:m fis b:m gis:m gis cis:m
  }}

  \new FretBoards {
    \override FretBoards.FretBoard.size = #'1.5
    \override FretBoard.fret-diagram-details.finger-code = #'in-dot
    \override FretBoard.fret-diagram-details.dot-color = #'white
    \override FretBoard.fret-diagram-details.orientation =
        #'landscape
    &lt;  fis,-1 cis-3 fis-4 a-1 cis'-1  fis'-1  &gt; % F#m
    &lt;  fis,-1 cis-3 fis-4 ais-2 cis'-1  fis'-1  &gt; % F#
    &lt;  fis,-1 b,-3 fis-4 b-1 d'-2  fis'-1  &gt; % Bm
    &lt;  gis,-1 dis-3 gis-4 b-1 dis'-1  gis'-1  &gt; % G#m
    &lt;  gis,-1 dis-3 gis-4 bis-2 dis'-1  gis'-1  &gt; % G#
    &lt;  gis,-1 cis-3 gis-4 cis'-1 e'-2  gis'-1  &gt; % C#m
  }
&gt;&gt; 
&lt;/score&gt;

== In welcher Tonart kommt C#m oder G#m vor ==

Cis-Moll (kurz C#m) ist die Moll-Parallele von E-Dur. Das heißt, dass C#m meistens in der Tonart auftaucht, wo auch ein E-Dur-Akkord auftaucht. 

Gis-Moll (kurz G#m) ist die Moll-Parallele von H-Dur. Das heißt, dass G#m meistens in der Tonart auftaucht, wo auch ein H-Dur-Akkord auftaucht. 

{| class=&quot;wikitable zebra&quot;
!Tonart
!Subdom.
!Tonika
!Dom.
!Subdom.&lt;br /&gt;parall.
!Tonika.&lt;br /&gt;parall.
!Dom.&lt;br /&gt;parall.
|-
| &lt;b&gt;A&lt;/b&gt; ||D||A||E7||Bm||F#m||&lt;b&gt;C#m&lt;/b&gt; (C#)
|-
| &lt;b&gt;E&lt;/b&gt; ||A||E||H7||F#m||&lt;b&gt;C#m&lt;/b&gt;||&lt;b&gt;G#m&lt;/b&gt; (G#)
|-
| &lt;b&gt;H&lt;/b&gt; ||E||H||F#7||&lt;b&gt;C#m&lt;/b&gt;||&lt;b&gt;G#m&lt;/b&gt;||D#m (D#)
|}

Du erinnerst dich doch noch daran, dass die Dominante einer Molltonarten  auch als Dur-Akkord auftauchen kann und dass es Zwischendominanten gibt. Von daher sollte es dich nicht wundern, wenn G#m und F#m auch mal als G#-Dur und F#-Dur auftauchen.

== Sprung in den vierten Bund ==
Grifftechnisch machen die Akkorde nicht mehr Probleme, als die vorhergehenden. Du musst nur wissen, wo sie hin gehören.

Der Grundton vom G ist &quot; &quot;'''g'''anz oben und '''g'''anz unten&quot;. Ebenso sind die Grundtöne der Barré-Akkorde der E-Form ganz oben und ganz unten. Wenn du weißt, dass der Grundton vom G auf der E-Saite im 3. Bund ist, dann muss der Grundton vom  G# genau einen Bund weiter sein, also im 4. Bund. 

Orientiere dich auch an der Markierung im 5. Der Zeigefinger kommt beim G#m also einen Bund vor dem 5. Bund.
{|
|[[Image:Crd G.svg]]
|&lt;big&gt;'''G#m'''&lt;/big&gt; - '''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg]]
|}

Der Grundton vom C ist auf der A-Saite im dritten Bund. Demnach ist der Grundton  vom C#m im 4. Bund. 

{|
|[[Image:Crd C.svg]]
|&lt;big&gt;'''C#m'''&lt;/big&gt;  - '''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Am-Typ.svg]]
|}

== Vier Positionen zum merken ==
{|class=&quot;wikitable zebra&quot;
!Form ||&amp;nbsp; 2.Bund &amp;nbsp; || &amp;nbsp; 4.Bund &amp;nbsp; || &amp;nbsp; Position
|-
|Am-Form || Hm || C#m || (unten)
|-
|Em-Form || F#m || G#m || (oben)
|}

; Beispiel 
:G#m = 4.oben
:Hm = 2. unten


{|
|&lt;big&gt;'''F#m'''&lt;/big&gt;&lt;br /&gt;'''2.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg|150px]]
|&lt;big&gt;'''F#'''&lt;/big&gt;&lt;br /&gt;'''2.Bund'''&lt;br /&gt;[[Image:Crd Barré F-Typ.svg|150px]]
|&lt;big&gt;'''G#m'''&lt;/big&gt;&lt;br /&gt;'''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg|150px]]
|&lt;big&gt;'''G#'''&lt;/big&gt;&lt;br /&gt;'''4.Bund'''&lt;br /&gt;[[Image:Crd Barré F-Typ.svg|150px]]
|}

Suche dir Lieder in E- und A-Dur heraus, wo auch die neuen Akkorde vorkommen. Spiele wenigstens einmal pro Tag ein Lied mit C#m und mit G#m. Erweitere dein Repertoire mit Barré-Liedern.

{{:Gitarre:_Liedervorschlag|
{{:Gitarre: Liedervorschläge/ Lieder mit Cis-_und_Gis-Moll}}
{{Navigation hoch}}
|img=Rockdiplom.gif |bg=LightCyan|border=indigo|color=indigo}}</text>
      <sha1>d4fmhze8qpamk2yowm5mkkesf1n6ogq</sha1>
    </revision>
    <revision>
      <id>1088601</id>
      <parentid>1088596</parentid>
      <timestamp>2026-07-04T10:21:28Z</timestamp>
      <contributor>
        <username>Mjchael</username>
        <id>2222</id>
      </contributor>
      <origin>1088601</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="6588" sha1="otz60d93c5ks3palgiv53tn0bkuhhyy" xml:space="preserve">{{:Gitarre/ Navi|Rockdiplom|
{{:Gitarre:_Rockdiplom/ Navi}}|
{{:Gitarre:_Rockdiplom/ Navi_Barree_1}}|
img=Rockdiplom.gif |bg=LightCyan|border=indigo|color=indigo}}


&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;G#m&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 black )
   (place-fret 2 4 1 darkgrey )
   (place-fret 3 4 1 darkgrey )
   (place-fret 4 6 3 black )
   (place-fret 5 6 3 darkgrey ) 
   (place-fret 6 4 1 black )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;G#&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 black )
   (place-fret 2 4 1 darkgrey )
   (place-fret 3 5 2 darkgrey )
   (place-fret 4 6 3 black )
   (place-fret 5 6 3 darkgrey ) 
   (place-fret 6 4 1 black )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;C#m&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 darkgrey )
   (place-fret 2 5 2 darkgrey )
   (place-fret 3 6 3 black )
   (place-fret 4 6 3 darkgrey ) 
   (place-fret 5 4 1 black )
   (place-fret 6 4 1 darkgrey )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
{{clear}}
{{Todo|Feststellen, warum es zu Darstellungsfehlern kommt. Der Syntax stimmt.|Mjchael|Gitarre}}
&lt;score&gt;
&lt;&lt;
  \new ChordNames { \chordmode {
    fis1:m fis b:m gis:m gis cis:m
  }}

  \new FretBoards {
    \override FretBoards.FretBoard.size = #'1.5
    \override FretBoard.fret-diagram-details.finger-code = #'in-dot
    \override FretBoard.fret-diagram-details.dot-color = #'white
    \override FretBoard.fret-diagram-details.orientation =
        #'landscape
    &lt;  fis,-1 cis-3 fis-4 a-1 cis'-1  fis'-1  &gt; % F#m
    &lt;  fis,-1 cis-3 fis-4 ais-2 cis'-1  fis'-1  &gt; % F#
    &lt;  fis,-1 b,-3 fis-4 b-1 d'-2  fis'-1  &gt; % Bm
    &lt;  gis,-1 dis-3 gis-4 b-1 dis'-1  gis'-1  &gt; % G#m
    &lt;  gis,-1 dis-3 gis-4 bis-2 dis'-1  gis'-1  &gt; % G#
    &lt;  gis,-1 cis-3 gis-4 cis'-1 e'-2  gis'-1  &gt; % C#m
  }
&gt;&gt; 
&lt;/score&gt;

== In welcher Tonart kommt C#m oder G#m vor ==

Cis-Moll (kurz C#m) ist die Moll-Parallele von E-Dur. Das heißt, dass C#m meistens in der Tonart auftaucht, wo auch ein E-Dur-Akkord auftaucht. 

Gis-Moll (kurz G#m) ist die Moll-Parallele von H-Dur. Das heißt, dass G#m meistens in der Tonart auftaucht, wo auch ein H-Dur-Akkord auftaucht. 

{| class=&quot;wikitable zebra&quot;
!Tonart
!Subdom.
!Tonika
!Dom.
!Subdom.&lt;br /&gt;parall.
!Tonika.&lt;br /&gt;parall.
!Dom.&lt;br /&gt;parall.
|-
| &lt;b&gt;A&lt;/b&gt; ||D||A||E7||Bm||F#m||&lt;b&gt;C#m&lt;/b&gt; (C#)
|-
| &lt;b&gt;E&lt;/b&gt; ||A||E||H7||F#m||&lt;b&gt;C#m&lt;/b&gt;||&lt;b&gt;G#m&lt;/b&gt; (G#)
|-
| &lt;b&gt;H&lt;/b&gt; ||E||H||F#7||&lt;b&gt;C#m&lt;/b&gt;||&lt;b&gt;G#m&lt;/b&gt;||D#m (D#)
|}

Du erinnerst dich doch noch daran, dass die Dominante einer Molltonarten  auch als Dur-Akkord auftauchen kann und dass es Zwischendominanten gibt. Von daher sollte es dich nicht wundern, wenn G#m und F#m auch mal als G#-Dur und F#-Dur auftauchen.

== Sprung in den vierten Bund ==
Grifftechnisch machen die Akkorde nicht mehr Probleme, als die vorhergehenden. Du musst nur wissen, wo sie hin gehören.

Der Grundton vom G ist &quot; &quot;'''g'''anz oben und '''g'''anz unten&quot;. Ebenso sind die Grundtöne der Barré-Akkorde der E-Form ganz oben und ganz unten. Wenn du weißt, dass der Grundton vom G auf der E-Saite im 3. Bund ist, dann muss der Grundton vom  G# genau einen Bund weiter sein, also im 4. Bund. 

Orientiere dich auch an der Markierung im 5. Der Zeigefinger kommt beim G#m also einen Bund vor dem 5. Bund.
{|
|[[Image:Crd G.svg]]
|&lt;big&gt;'''G#m'''&lt;/big&gt; - '''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg]]
|}

Der Grundton vom C ist auf der A-Saite im dritten Bund. Demnach ist der Grundton  vom C#m im 4. Bund. 

{|
|[[Image:Crd C.svg]]
|&lt;big&gt;'''C#m'''&lt;/big&gt;  - '''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Am-Typ.svg]]
|}

== Vier Positionen zum merken ==
{|class=&quot;wikitable zebra&quot;
!Form ||&amp;nbsp; 2.Bund &amp;nbsp; || &amp;nbsp; 4.Bund &amp;nbsp; || &amp;nbsp; Position
|-
|Am-Form || Bm || C#m || (unten)
|-
|Em-Form || F#m || G#m || (oben)
|}

; Beispiel 
:G#m = 4.oben
:Bm = 2. unten


{|
|&lt;big&gt;'''F#m'''&lt;/big&gt;&lt;br /&gt;'''2.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg|150px]]
|&lt;big&gt;'''F#'''&lt;/big&gt;&lt;br /&gt;'''2.Bund'''&lt;br /&gt;[[Image:Crd Barré F-Typ.svg|150px]]
|&lt;big&gt;'''G#m'''&lt;/big&gt;&lt;br /&gt;'''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg|150px]]
|&lt;big&gt;'''G#'''&lt;/big&gt;&lt;br /&gt;'''4.Bund'''&lt;br /&gt;[[Image:Crd Barré F-Typ.svg|150px]]
|}

Suche dir Lieder in E- und A-Dur heraus, wo auch die neuen Akkorde vorkommen. Spiele wenigstens einmal pro Tag ein Lied mit C#m und mit G#m. Erweitere dein Repertoire mit Barré-Liedern.

{{:Gitarre:_Liedervorschlag|
{{:Gitarre: Liedervorschläge/ Lieder mit Cis-_und_Gis-Moll}}
{{Navigation hoch}}
|img=Rockdiplom.gif |bg=LightCyan|border=indigo|color=indigo}}</text>
      <sha1>otz60d93c5ks3palgiv53tn0bkuhhyy</sha1>
    </revision>
    <revision>
      <id>1088603</id>
      <parentid>1088601</parentid>
      <timestamp>2026-07-04T10:51:44Z</timestamp>
      <contributor>
        <username>Mjchael</username>
        <id>2222</id>
      </contributor>
      <origin>1088603</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="6416" sha1="jgxtcj64tyupv92iqg4abbrw428jxpf" xml:space="preserve">{{:Gitarre/ Navi|Rockdiplom|
{{:Gitarre:_Rockdiplom/ Navi}}|
{{:Gitarre:_Rockdiplom/ Navi_Barree_1}}|
img=Rockdiplom.gif |bg=LightCyan|border=indigo|color=indigo}}


&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;G#m&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 black )
   (place-fret 2 4 1 darkgrey )
   (place-fret 3 4 1 darkgrey )
   (place-fret 4 6 3 black )
   (place-fret 5 6 3 darkgrey ) 
   (place-fret 6 4 1 black )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;G#&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 black )
   (place-fret 2 4 1 darkgrey )
   (place-fret 3 5 2 darkgrey )
   (place-fret 4 6 3 black )
   (place-fret 5 6 3 darkgrey ) 
   (place-fret 6 4 1 black )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;C#m&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 darkgrey )
   (place-fret 2 5 2 darkgrey )
   (place-fret 3 6 3 black )
   (place-fret 4 6 3 darkgrey ) 
   (place-fret 5 4 1 black )
   (place-fret 6 4 1 darkgrey )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
{{clear}}
{{Todo|Feststellen, warum es zu Darstellungsfehlern kommt. Der Syntax stimmt.|Mjchael|Gitarre}}
&lt;score&gt;
&lt;&lt;
  \new ChordNames { \chordmode {
     gis:m gis cis:m
  }}

  \new FretBoards {
    \override FretBoards.FretBoard.size = #'1.5
    \override FretBoard.fret-diagram-details.finger-code = #'in-dot
    \override FretBoard.fret-diagram-details.dot-color = #'white
    \override FretBoard.fret-diagram-details.orientation =
        #'landscape

    &lt;  gis,-1 dis-3 gis-4 b-1 dis'-1  gis'-1  &gt; % G#m
    &lt;  gis,-1 dis-3 gis-4 bis-2 dis'-1  gis'-1  &gt; % G#
    &lt;  gis,-1 cis-3 gis-4 cis'-1 e'-2  gis'-1  &gt; % C#m
  }
&gt;&gt; 
&lt;/score&gt;

== In welcher Tonart kommt C#m oder G#m vor ==

Cis-Moll (kurz C#m) ist die Moll-Parallele von E-Dur. Das heißt, dass C#m meistens in der Tonart auftaucht, wo auch ein E-Dur-Akkord auftaucht. 

Gis-Moll (kurz G#m) ist die Moll-Parallele von H-Dur. Das heißt, dass G#m meistens in der Tonart auftaucht, wo auch ein H-Dur-Akkord auftaucht. 

{| class=&quot;wikitable zebra&quot;
!Tonart
!Subdom.
!Tonika
!Dom.
!Subdom.&lt;br /&gt;parall.
!Tonika.&lt;br /&gt;parall.
!Dom.&lt;br /&gt;parall.
|-
| &lt;b&gt;A&lt;/b&gt; ||D||A||E7||Bm||F#m||&lt;b&gt;C#m&lt;/b&gt; (C#)
|-
| &lt;b&gt;E&lt;/b&gt; ||A||E||H7||F#m||&lt;b&gt;C#m&lt;/b&gt;||&lt;b&gt;G#m&lt;/b&gt; (G#)
|-
| &lt;b&gt;H&lt;/b&gt; ||E||H||F#7||&lt;b&gt;C#m&lt;/b&gt;||&lt;b&gt;G#m&lt;/b&gt;||D#m (D#)
|}

Du erinnerst dich doch noch daran, dass die Dominante einer Molltonarten  auch als Dur-Akkord auftauchen kann und dass es Zwischendominanten gibt. Von daher sollte es dich nicht wundern, wenn G#m und F#m auch mal als G#-Dur und F#-Dur auftauchen.

== Sprung in den vierten Bund ==
Grifftechnisch machen die Akkorde nicht mehr Probleme, als die vorhergehenden. Du musst nur wissen, wo sie hin gehören.

Der Grundton vom G ist &quot; &quot;'''g'''anz oben und '''g'''anz unten&quot;. Ebenso sind die Grundtöne der Barré-Akkorde der E-Form ganz oben und ganz unten. Wenn du weißt, dass der Grundton vom G auf der E-Saite im 3. Bund ist, dann muss der Grundton vom  G# genau einen Bund weiter sein, also im 4. Bund. 

Orientiere dich auch an der Markierung im 5. Der Zeigefinger kommt beim G#m also einen Bund vor dem 5. Bund.
{|
|[[Image:Crd G.svg]]
|&lt;big&gt;'''G#m'''&lt;/big&gt; - '''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg]]
|}

Der Grundton vom C ist auf der A-Saite im dritten Bund. Demnach ist der Grundton  vom C#m im 4. Bund. 

{|
|[[Image:Crd C.svg]]
|&lt;big&gt;'''C#m'''&lt;/big&gt;  - '''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Am-Typ.svg]]
|}

== Vier Positionen zum merken ==
{|class=&quot;wikitable zebra&quot;
!Form ||&amp;nbsp; 2.Bund &amp;nbsp; || &amp;nbsp; 4.Bund &amp;nbsp; || &amp;nbsp; Position
|-
|Am-Form || Bm || C#m || (unten)
|-
|Em-Form || F#m || G#m || (oben)
|}

; Beispiel 
:G#m = 4.oben
:Bm = 2. unten


{|
|&lt;big&gt;'''F#m'''&lt;/big&gt;&lt;br /&gt;'''2.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg|150px]]
|&lt;big&gt;'''F#'''&lt;/big&gt;&lt;br /&gt;'''2.Bund'''&lt;br /&gt;[[Image:Crd Barré F-Typ.svg|150px]]
|&lt;big&gt;'''G#m'''&lt;/big&gt;&lt;br /&gt;'''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg|150px]]
|&lt;big&gt;'''G#'''&lt;/big&gt;&lt;br /&gt;'''4.Bund'''&lt;br /&gt;[[Image:Crd Barré F-Typ.svg|150px]]
|}

Suche dir Lieder in E- und A-Dur heraus, wo auch die neuen Akkorde vorkommen. Spiele wenigstens einmal pro Tag ein Lied mit C#m und mit G#m. Erweitere dein Repertoire mit Barré-Liedern.

{{:Gitarre:_Liedervorschlag|
{{:Gitarre: Liedervorschläge/ Lieder mit Cis-_und_Gis-Moll}}
{{Navigation hoch}}
|img=Rockdiplom.gif |bg=LightCyan|border=indigo|color=indigo}}</text>
      <sha1>jgxtcj64tyupv92iqg4abbrw428jxpf</sha1>
    </revision>
    <revision>
      <id>1088604</id>
      <parentid>1088603</parentid>
      <timestamp>2026-07-04T11:07:00Z</timestamp>
      <contributor>
        <username>Mjchael</username>
        <id>2222</id>
      </contributor>
      <comment>/* In welcher Tonart kommt C#m oder G#m vor */ rotstift</comment>
      <origin>1088604</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="6221" sha1="jex8czj69g8ubrargwwa9mlc36hb731" xml:space="preserve">{{:Gitarre/ Navi|Rockdiplom|
{{:Gitarre:_Rockdiplom/ Navi}}|
{{:Gitarre:_Rockdiplom/ Navi_Barree_1}}|
img=Rockdiplom.gif |bg=LightCyan|border=indigo|color=indigo}}


&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;G#m&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 black )
   (place-fret 2 4 1 darkgrey )
   (place-fret 3 4 1 darkgrey )
   (place-fret 4 6 3 black )
   (place-fret 5 6 3 darkgrey ) 
   (place-fret 6 4 1 black )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;G#&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 black )
   (place-fret 2 4 1 darkgrey )
   (place-fret 3 5 2 darkgrey )
   (place-fret 4 6 3 black )
   (place-fret 5 6 3 darkgrey ) 
   (place-fret 6 4 1 black )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;C#m&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 darkgrey )
   (place-fret 2 5 2 darkgrey )
   (place-fret 3 6 3 black )
   (place-fret 4 6 3 darkgrey ) 
   (place-fret 5 4 1 black )
   (place-fret 6 4 1 darkgrey )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
{{clear}}
{{Todo|Feststellen, warum es zu Darstellungsfehlern kommt. Der Syntax stimmt.|Mjchael|Gitarre}}
&lt;score&gt;
&lt;&lt;
  \new ChordNames { \chordmode {
     gis:m gis cis:m
  }}

  \new FretBoards {
    \override FretBoards.FretBoard.size = #'1.5
    \override FretBoard.fret-diagram-details.finger-code = #'in-dot
    \override FretBoard.fret-diagram-details.dot-color = #'white
    \override FretBoard.fret-diagram-details.orientation =
        #'landscape

    &lt;  gis,-1 dis-3 gis-4 b-1 dis'-1  gis'-1  &gt; % G#m
    &lt;  gis,-1 dis-3 gis-4 bis-2 dis'-1  gis'-1  &gt; % G#
    &lt;  gis,-1 cis-3 gis-4 cis'-1 e'-2  gis'-1  &gt; % C#m
  }
&gt;&gt; 
&lt;/score&gt;

== In welcher Tonart kommen C#m oder G#m vor? ==

C#m ist die Mollparallele von E-Dur und tritt daher in Tonarten auf, wo auch ein E vorkommt.

G#m ist die Mollparallele von H-Dur (engl. B)  und erscheint in Tonarten, wo auch ein B vorkommt.

{| class=&quot;wikitable zebra&quot;
!Tonart
!Subdom.
!Tonika
!Dom.
!Subdom.&lt;br /&gt;parall.
!Tonika.&lt;br /&gt;parall.
!Dom.&lt;br /&gt;parall.
|-
| &lt;b&gt;A&lt;/b&gt; ||D||A||E7||Bm||F#m||&lt;b&gt;C#m&lt;/b&gt; (C#)
|-
| &lt;b&gt;E&lt;/b&gt; ||A||E||H7||F#m||&lt;b&gt;C#m&lt;/b&gt;||&lt;b&gt;G#m&lt;/b&gt; (G#)
|-
| &lt;b&gt;H&lt;/b&gt; ||E||H||F#7||&lt;b&gt;C#m&lt;/b&gt;||&lt;b&gt;G#m&lt;/b&gt;||D#m (D#)
|}

Beachte: Dominanten einer Moll-Tonarten erscheinen ift als Dur-Akkord. Deshalb können G#m und F#m gelegentlich auch als G#-Dur bzw. F#-Dur auftreten.

== Sprung in den vierten Bund ==
Grifftechnisch machen die Akkorde nicht mehr Probleme, als die vorhergehenden. Du musst nur wissen, wo sie hin gehören.

Der Grundton vom G ist &quot; &quot;'''g'''anz oben und '''g'''anz unten&quot;. Ebenso sind die Grundtöne der Barré-Akkorde der E-Form ganz oben und ganz unten. Wenn du weißt, dass der Grundton vom G auf der E-Saite im 3. Bund ist, dann muss der Grundton vom  G# genau einen Bund weiter sein, also im 4. Bund. 

Orientiere dich auch an der Markierung im 5. Der Zeigefinger kommt beim G#m also einen Bund vor dem 5. Bund.
{|
|[[Image:Crd G.svg]]
|&lt;big&gt;'''G#m'''&lt;/big&gt; - '''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg]]
|}

Der Grundton vom C ist auf der A-Saite im dritten Bund. Demnach ist der Grundton  vom C#m im 4. Bund. 

{|
|[[Image:Crd C.svg]]
|&lt;big&gt;'''C#m'''&lt;/big&gt;  - '''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Am-Typ.svg]]
|}

== Vier Positionen zum merken ==
{|class=&quot;wikitable zebra&quot;
!Form ||&amp;nbsp; 2.Bund &amp;nbsp; || &amp;nbsp; 4.Bund &amp;nbsp; || &amp;nbsp; Position
|-
|Am-Form || Bm || C#m || (unten)
|-
|Em-Form || F#m || G#m || (oben)
|}

; Beispiel 
:G#m = 4.oben
:Bm = 2. unten


{|
|&lt;big&gt;'''F#m'''&lt;/big&gt;&lt;br /&gt;'''2.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg|150px]]
|&lt;big&gt;'''F#'''&lt;/big&gt;&lt;br /&gt;'''2.Bund'''&lt;br /&gt;[[Image:Crd Barré F-Typ.svg|150px]]
|&lt;big&gt;'''G#m'''&lt;/big&gt;&lt;br /&gt;'''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg|150px]]
|&lt;big&gt;'''G#'''&lt;/big&gt;&lt;br /&gt;'''4.Bund'''&lt;br /&gt;[[Image:Crd Barré F-Typ.svg|150px]]
|}

Suche dir Lieder in E- und A-Dur heraus, wo auch die neuen Akkorde vorkommen. Spiele wenigstens einmal pro Tag ein Lied mit C#m und mit G#m. Erweitere dein Repertoire mit Barré-Liedern.

{{:Gitarre:_Liedervorschlag|
{{:Gitarre: Liedervorschläge/ Lieder mit Cis-_und_Gis-Moll}}
{{Navigation hoch}}
|img=Rockdiplom.gif |bg=LightCyan|border=indigo|color=indigo}}</text>
      <sha1>jex8czj69g8ubrargwwa9mlc36hb731</sha1>
    </revision>
    <revision>
      <id>1088607</id>
      <parentid>1088604</parentid>
      <timestamp>2026-07-04T11:18:46Z</timestamp>
      <contributor>
        <username>Mjchael</username>
        <id>2222</id>
      </contributor>
      <comment>/* In welcher Tonart kommen C#m oder G#m vor? */</comment>
      <origin>1088607</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="6355" sha1="0rkpekm0v7tbant1lwu292aqjipkvry" xml:space="preserve">{{:Gitarre/ Navi|Rockdiplom|
{{:Gitarre:_Rockdiplom/ Navi}}|
{{:Gitarre:_Rockdiplom/ Navi_Barree_1}}|
img=Rockdiplom.gif |bg=LightCyan|border=indigo|color=indigo}}


&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;G#m&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 black )
   (place-fret 2 4 1 darkgrey )
   (place-fret 3 4 1 darkgrey )
   (place-fret 4 6 3 black )
   (place-fret 5 6 3 darkgrey ) 
   (place-fret 6 4 1 black )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;G#&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 black )
   (place-fret 2 4 1 darkgrey )
   (place-fret 3 5 2 darkgrey )
   (place-fret 4 6 3 black )
   (place-fret 5 6 3 darkgrey ) 
   (place-fret 6 4 1 black )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;C#m&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 darkgrey )
   (place-fret 2 5 2 darkgrey )
   (place-fret 3 6 3 black )
   (place-fret 4 6 3 darkgrey ) 
   (place-fret 5 4 1 black )
   (place-fret 6 4 1 darkgrey )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
{{clear}}
{{Todo|Feststellen, warum es zu Darstellungsfehlern kommt. Der Syntax stimmt.|Mjchael|Gitarre}}
&lt;score&gt;
&lt;&lt;
  \new ChordNames { \chordmode {
     gis:m gis cis:m
  }}

  \new FretBoards {
    \override FretBoards.FretBoard.size = #'1.5
    \override FretBoard.fret-diagram-details.finger-code = #'in-dot
    \override FretBoard.fret-diagram-details.dot-color = #'white
    \override FretBoard.fret-diagram-details.orientation =
        #'landscape

    &lt;  gis,-1 dis-3 gis-4 b-1 dis'-1  gis'-1  &gt; % G#m
    &lt;  gis,-1 dis-3 gis-4 bis-2 dis'-1  gis'-1  &gt; % G#
    &lt;  gis,-1 cis-3 gis-4 cis'-1 e'-2  gis'-1  &gt; % C#m
  }
&gt;&gt; 
&lt;/score&gt;

== In welcher Tonart kommen C#m oder G#m vor? ==

C#m ist die Mollparallele von E-Dur und tritt daher in Tonarten auf, wo auch ein E vorkommt.

G#m ist die Mollparallele von H-Dur (engl. B)  und erscheint in Tonarten, wo auch ein B vorkommt.

{| class=&quot;wikitable zebra&quot;
!Tonart
!Subdom.
!Tonika
!Dom.
!Subdom.&lt;br /&gt;parall.
!Tonika.&lt;br /&gt;parall.
!Dom.&lt;br /&gt;parall.
|-
| &lt;b&gt;A&lt;/b&gt; ||D||A||E7||{{rot|Bm|orange}}||{{rot|F#m}}||&lt;b&gt;{{blau|C#m}}&lt;/b&gt; ({{blau|C#}})
|-
| &lt;b&gt;E&lt;/b&gt; ||A||E||{{rot|B7|orange}}||{{rot|F#m}}||&lt;b&gt;{{blau|C#m}}&lt;/b&gt;||&lt;b&gt;{{grün|G#m}}&lt;/b&gt; ({{grün|G#}})
|-
| &lt;b&gt;H&lt;/b&gt; ||E||{{rot|B|orange}}||{{rot|F#7}}||&lt;b&gt;{{blau|C#m}}&lt;/b&gt;||&lt;b&gt;{{grün|G#}}&lt;/b&gt;||D#m (D#)
|}

Beachte: Dominanten einer Moll-Tonarten erscheinen ift als Dur-Akkord. Deshalb können G#m und F#m gelegentlich auch als G#-Dur bzw. F#-Dur auftreten.

== Sprung in den vierten Bund ==
Grifftechnisch machen die Akkorde nicht mehr Probleme, als die vorhergehenden. Du musst nur wissen, wo sie hin gehören.

Der Grundton vom G ist &quot; &quot;'''g'''anz oben und '''g'''anz unten&quot;. Ebenso sind die Grundtöne der Barré-Akkorde der E-Form ganz oben und ganz unten. Wenn du weißt, dass der Grundton vom G auf der E-Saite im 3. Bund ist, dann muss der Grundton vom  G# genau einen Bund weiter sein, also im 4. Bund. 

Orientiere dich auch an der Markierung im 5. Der Zeigefinger kommt beim G#m also einen Bund vor dem 5. Bund.
{|
|[[Image:Crd G.svg]]
|&lt;big&gt;'''G#m'''&lt;/big&gt; - '''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg]]
|}

Der Grundton vom C ist auf der A-Saite im dritten Bund. Demnach ist der Grundton  vom C#m im 4. Bund. 

{|
|[[Image:Crd C.svg]]
|&lt;big&gt;'''C#m'''&lt;/big&gt;  - '''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Am-Typ.svg]]
|}

== Vier Positionen zum merken ==
{|class=&quot;wikitable zebra&quot;
!Form ||&amp;nbsp; 2.Bund &amp;nbsp; || &amp;nbsp; 4.Bund &amp;nbsp; || &amp;nbsp; Position
|-
|Am-Form || Bm || C#m || (unten)
|-
|Em-Form || F#m || G#m || (oben)
|}

; Beispiel 
:G#m = 4.oben
:Bm = 2. unten


{|
|&lt;big&gt;'''F#m'''&lt;/big&gt;&lt;br /&gt;'''2.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg|150px]]
|&lt;big&gt;'''F#'''&lt;/big&gt;&lt;br /&gt;'''2.Bund'''&lt;br /&gt;[[Image:Crd Barré F-Typ.svg|150px]]
|&lt;big&gt;'''G#m'''&lt;/big&gt;&lt;br /&gt;'''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg|150px]]
|&lt;big&gt;'''G#'''&lt;/big&gt;&lt;br /&gt;'''4.Bund'''&lt;br /&gt;[[Image:Crd Barré F-Typ.svg|150px]]
|}

Suche dir Lieder in E- und A-Dur heraus, wo auch die neuen Akkorde vorkommen. Spiele wenigstens einmal pro Tag ein Lied mit C#m und mit G#m. Erweitere dein Repertoire mit Barré-Liedern.

{{:Gitarre:_Liedervorschlag|
{{:Gitarre: Liedervorschläge/ Lieder mit Cis-_und_Gis-Moll}}
{{Navigation hoch}}
|img=Rockdiplom.gif |bg=LightCyan|border=indigo|color=indigo}}</text>
      <sha1>0rkpekm0v7tbant1lwu292aqjipkvry</sha1>
    </revision>
    <revision>
      <id>1088609</id>
      <parentid>1088607</parentid>
      <timestamp>2026-07-04T11:27:42Z</timestamp>
      <contributor>
        <username>Mjchael</username>
        <id>2222</id>
      </contributor>
      <comment>/* In welcher Tonart kommen C#m oder G#m vor? */</comment>
      <origin>1088609</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="6355" sha1="kwsje12w53i7z8t1x6a4gsqy5iblzd9" xml:space="preserve">{{:Gitarre/ Navi|Rockdiplom|
{{:Gitarre:_Rockdiplom/ Navi}}|
{{:Gitarre:_Rockdiplom/ Navi_Barree_1}}|
img=Rockdiplom.gif |bg=LightCyan|border=indigo|color=indigo}}


&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;G#m&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 black )
   (place-fret 2 4 1 darkgrey )
   (place-fret 3 4 1 darkgrey )
   (place-fret 4 6 3 black )
   (place-fret 5 6 3 darkgrey ) 
   (place-fret 6 4 1 black )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;G#&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 black )
   (place-fret 2 4 1 darkgrey )
   (place-fret 3 5 2 darkgrey )
   (place-fret 4 6 3 black )
   (place-fret 5 6 3 darkgrey ) 
   (place-fret 6 4 1 black )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
&lt;div style=&quot;float:left; padding:5px;margin:5px; border:black solid 1px; &quot;&gt;
&lt;score raw=&quot;1&quot;&gt;
\version &quot;2.14.2&quot;
\markup \column {
 %% Überschrift / Headline 
 \halign #CENTER { 
  \bold &quot;C#m&quot;
 }
 %% Aussehen / Look
  \override #'(size . 2.0) {
  \override #'(fret-diagram-details . (
   (orientation . #'landscape )
   (finger-code . #'in-dot )
   (dot-color . #'black)
   (dot-radius . 0.4)
   (dot-position . 0.5)
   (top-fret-thickness . 6)
   (fret-count . 3)
   (number-type . roman-upper)
  ))
  %% Finger
  %% Saite Bund &quot;Intervall&quot; Farbe
  %% string fret &quot;interval&quot; color
  \fret-diagram-verbose #'(
   (place-fret 1 4 1 darkgrey )
   (place-fret 2 5 2 darkgrey )
   (place-fret 3 6 3 black )
   (place-fret 4 6 3 darkgrey ) 
   (place-fret 5 4 1 black )
   (place-fret 6 4 1 darkgrey )
  ) 
}}

\paper{
     indent=0\mm
     line-width=80\mm
     oddFooterMarkup=##f
     oddHeaderMarkup=##f
     bookTitleMarkup = ##f
     scoreTitleMarkup = ##f}
&lt;/score&gt;
&lt;/div&gt;
{{clear}}
{{Todo|Feststellen, warum es zu Darstellungsfehlern kommt. Der Syntax stimmt.|Mjchael|Gitarre}}
&lt;score&gt;
&lt;&lt;
  \new ChordNames { \chordmode {
     gis:m gis cis:m
  }}

  \new FretBoards {
    \override FretBoards.FretBoard.size = #'1.5
    \override FretBoard.fret-diagram-details.finger-code = #'in-dot
    \override FretBoard.fret-diagram-details.dot-color = #'white
    \override FretBoard.fret-diagram-details.orientation =
        #'landscape

    &lt;  gis,-1 dis-3 gis-4 b-1 dis'-1  gis'-1  &gt; % G#m
    &lt;  gis,-1 dis-3 gis-4 bis-2 dis'-1  gis'-1  &gt; % G#
    &lt;  gis,-1 cis-3 gis-4 cis'-1 e'-2  gis'-1  &gt; % C#m
  }
&gt;&gt; 
&lt;/score&gt;

== In welcher Tonart kommen C#m oder G#m vor? ==

C#m ist die Mollparallele von E-Dur und tritt daher in Tonarten auf, wo auch ein E vorkommt.

G#m ist die Mollparallele von H-Dur (engl. B)  und erscheint in Tonarten, wo auch ein B vorkommt.

{| class=&quot;wikitable zebra&quot;
!Tonart
!Subdom.
!Tonika
!Dom.
!Subdom.&lt;br /&gt;parall.
!Tonika.&lt;br /&gt;parall.
!Dom.&lt;br /&gt;parall.
|-
| &lt;b&gt;A&lt;/b&gt; ||D||A||E7||{{rot|Bm|orange}}||{{rot|F#m}}||&lt;b&gt;{{blau|C#m}}&lt;/b&gt; ({{blau|C#}})
|-
| &lt;b&gt;E&lt;/b&gt; ||A||E||{{rot|B7|orange}}||{{rot|F#m}}||&lt;b&gt;{{blau|C#m}}&lt;/b&gt;||&lt;b&gt;{{grün|G#m}}&lt;/b&gt; ({{grün|G#}})
|-
| &lt;b&gt;H&lt;/b&gt; ||E||{{rot|B|orange}}||{{rot|F#7}}||&lt;b&gt;{{blau|C#m}}&lt;/b&gt;||&lt;b&gt;{{grün|G#}}&lt;/b&gt;||D#m (D#)
|}

Beachte: Dominanten einer Moll-Tonarten erscheinen oft als Dur-Akkord. Deshalb können G#m und F#m gelegentlich auch als G#-Dur bzw. F#-Dur auftreten.

== Sprung in den vierten Bund ==
Grifftechnisch machen die Akkorde nicht mehr Probleme, als die vorhergehenden. Du musst nur wissen, wo sie hin gehören.

Der Grundton vom G ist &quot; &quot;'''g'''anz oben und '''g'''anz unten&quot;. Ebenso sind die Grundtöne der Barré-Akkorde der E-Form ganz oben und ganz unten. Wenn du weißt, dass der Grundton vom G auf der E-Saite im 3. Bund ist, dann muss der Grundton vom  G# genau einen Bund weiter sein, also im 4. Bund. 

Orientiere dich auch an der Markierung im 5. Der Zeigefinger kommt beim G#m also einen Bund vor dem 5. Bund.
{|
|[[Image:Crd G.svg]]
|&lt;big&gt;'''G#m'''&lt;/big&gt; - '''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg]]
|}

Der Grundton vom C ist auf der A-Saite im dritten Bund. Demnach ist der Grundton  vom C#m im 4. Bund. 

{|
|[[Image:Crd C.svg]]
|&lt;big&gt;'''C#m'''&lt;/big&gt;  - '''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Am-Typ.svg]]
|}

== Vier Positionen zum merken ==
{|class=&quot;wikitable zebra&quot;
!Form ||&amp;nbsp; 2.Bund &amp;nbsp; || &amp;nbsp; 4.Bund &amp;nbsp; || &amp;nbsp; Position
|-
|Am-Form || Bm || C#m || (unten)
|-
|Em-Form || F#m || G#m || (oben)
|}

; Beispiel 
:G#m = 4.oben
:Bm = 2. unten


{|
|&lt;big&gt;'''F#m'''&lt;/big&gt;&lt;br /&gt;'''2.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg|150px]]
|&lt;big&gt;'''F#'''&lt;/big&gt;&lt;br /&gt;'''2.Bund'''&lt;br /&gt;[[Image:Crd Barré F-Typ.svg|150px]]
|&lt;big&gt;'''G#m'''&lt;/big&gt;&lt;br /&gt;'''4.Bund'''&lt;br /&gt;[[Image:Crd Barré Em-Typ.svg|150px]]
|&lt;big&gt;'''G#'''&lt;/big&gt;&lt;br /&gt;'''4.Bund'''&lt;br /&gt;[[Image:Crd Barré F-Typ.svg|150px]]
|}

Suche dir Lieder in E- und A-Dur heraus, wo auch die neuen Akkorde vorkommen. Spiele wenigstens einmal pro Tag ein Lied mit C#m und mit G#m. Erweitere dein Repertoire mit Barré-Liedern.

{{:Gitarre:_Liedervorschlag|
{{:Gitarre: Liedervorschläge/ Lieder mit Cis-_und_Gis-Moll}}
{{Navigation hoch}}
|img=Rockdiplom.gif |bg=LightCyan|border=indigo|color=indigo}}</text>
      <sha1>kwsje12w53i7z8t1x6a4gsqy5iblzd9</sha1>
    </revision>
  </page>
  <page>
    <title>Entropie: Biologie</title>
    <ns>0</ns>
    <id>54552</id>
    <revision>
      <id>1088591</id>
      <parentid>812360</parentid>
      <timestamp>2026-07-03T17:23:09Z</timestamp>
      <contributor>
        <username>~2026-38044-54</username>
        <id>116480</id>
      </contributor>
      <comment>/* Entropie und Lebensentstehung */</comment>
      <origin>1088591</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="8684" sha1="0ttf6mmjk9rv7bifd9lr4f6piwd24nq" xml:space="preserve">Zurück zur '''[[Entropie|Übersicht]]'''

[[Image:Human evolution.svg|thumb|300px|'''Widerspricht die biologische Evolution dem 2.Hauptsatz ?''']]
==Biologische Lebewesen sind Entropieerzeugende Systeme==
Jedes Tier nimmt entropiearme (und energiereiche) Nahrung zu sich und gibt entropiereiche Abfallstoffe wieder ab.

Interessant ist beispielsweise die Entropiebilanz eines Menschen.

Bei Pflanzen wird entropiearmes Licht von der Sonne aufgenommen und entropiereiche Wärmestrahlung wieder abgegeben.  


==Entropie und Lebensentstehung==
Nach Ansicht vieler religiöser Menschen und ''intelligenter Designer'' widerspricht die Entstehung des Lebens auf der Erde dem 2. Hauptsatz der Wärmelehre.
Nur eine höhere Macht, die ausserhalb der Physik steht, kann für die Lebensentstehung verantwortlich sein.

Wenn dem so wäre, würde auch die Sternbildung, die Kristallbildung und jede Goldmine dem 2. Hauptsatz widersprechen. Wichtig ist es zu verstehen, dass zwei Prozesse gekoppelt werden können, von denen ein Prozess entropieerzeugend ist und der andere entropievermindernd. Das Ergebnis ist dann die Entstehung von entropiearmen geordneten Strukturen, die man entgegen der allgemeinen Tendenz der Entropievermehrung nicht erwartet hätte.

==Entropie und Evolution==

===Zitate===
====Keine Entropie in der Evolution ?====
In dem Buch ''Ketten für Prometheus: Gegen die Natur oder mit ihr? Von Reinhard Demoll'' 
wird auf Seite 239 die Ansicht geäußert:
 Im Reich der Organismen gibt es keine Entropie 
 sondern nur ein Sich-Hinaufentwickeln, 
 den Drang zur Vervollkommnung des Typus; 
 und dies äußert sich im Geistigen ebenso wie im Körperlichen. 

Von Reinhard Demoll Veröffentlicht 1954 F. Bruckmann 248 Seiten 

Diese Ansicht ist aus heutiger Sicht falsch. 
Einmal ist bei der Rekombination und der Variation des Erbgutes der Zufall und damit auch die Entropie im Spiel. 
Außerdem kann die Evolution nur deswegen ablaufen, da durch den steten Energiestrom der Sonne die Entropie der Sonne und des umgebenden Weltraums erhöht wird und damit der Entropieverlust durch die Evolution ausgeglichen wird.

==Entropie und Zellteilung==
Korrekturmechanismen im genetischen Code zur Entropieverminderung

==Entropie und Gesundheit==
Gesundheit ist eigentlich ein antientropisches Prinzip. Biologische Organismen verstehen es, entgegen der Vielzahl der inneren und äusseren Störeinflüsse ihre biologische Ordnung aufrecht zu erhalten. Im Alter kommt dann die Entropie wieder vermehrt zum tragen, die Reparaturmechanismen versagen zunehmend. 

Zitat
 Es gibt nur eine Möglichkeit gesund zu sein, 
 aber tausend Möglichkeiten krank zu sein.

==Entropie im genetischen Code==

Sie haben eine Gensequenz und versuchen die Entropie dieser Sequenz zu berechnen ? Macht so eine Berechnung überhaupt Sinn ? Wie ändert sich die Berechnung, wenn man immer Triplets betrachtet ? Es sind ja immer zwei Basenpaare gekoppelt g und c sowie a und t, kann man das Ausnutzen, um die Redundanz zu reduzieren ? Wie schaut eine 01 Kodierung für Gene aus ?
Beispielsweise 
 a    00
 c    01
 g    10
 t    11
Gibt es dazu einen Standard ? 

    1 gagcagcgcg cgcaagcagg ccaggggaag gtgggcgcag gtgaggggcc gaggtgtgcg
   61 caggacttta gccggttgag aaggatcaag caggcatttg gagcacaggt gtctagaaac
  121 ttttaagggg ccggttcaag aaggaaaagt tcccttctgc tgtgaaacta tttggcaaga
  181 ggctggaggg cccaatggct gcaaaattgc aacccaacat tcccaaagcc aagagtctag
  241 atggcgtcac caatgacaga accgcatctc aagggcagtg gggccgtgcc tgggaggtgg
  301 actggttttc actggcgagc gtcatcttcc tactgctgtt cgcccccttc atcgtctact
  361 acttcatcat ggcttgtgac cagtacagct gcgccctgac cggccctgtg gtggacatcg
  421 tcaccggaca tgctcggctc tcggacatct gggccaagac tccacctata acgaggaaag
  481 ccgcccagct ctataccttg tgggtcacct tccaggtgct tctgtacacg tctctccctg
  541 acttctgcca taagtttcta cccggctacg taggaggcat ccaggagggg gccgtgactc
  601 ctgcaggggt tgtgaacaag tatcagatca acggcctgca agcctggctc ctcacgcacc
  661 tgctctggtt tgcaaacgct catctcctgt cctggttctc gcccaccatc atcttcgaca
  721 actggatccc actgctgtgg tgcgccaaca tccttggcta tgccgtctcc accttcgcca
  781 tggtcaaggg ctacttcttc cccaccagcg ccagagactg caaattcaca ggcaatttct
  841 tttacaacta catgatgggc atcgagttta accctcggat cgggaagtgg tttgacttca
  901 agctgttctt caatgggcgc cccgggatcg tcgcctggac cctcatcaac ctgtccttcg
  961 cagcgaagca gcgggagctc cacagccatg tgaccaatgc catggtcctg gtcaacgtcc
 1021 tgcaggccat ctacgtgatt gacttcttct ggaacgaaac ctggtacctg aagaccattg
 1081 acatctgcca tgaccacttc gggtggtacc tgggctgggg cgactgtgtc tggctgcctt
 1141 atctttacac gctgcagggt ctgtacttgg tgtaccaccc cgtgcagctg tccaccccgc
 1201 acgccgtggg cgtcctgctg ctgggcctgg tgggctacta catcttccgg gtggccaacc
 1261 accagaagga cctgttccgc cgcacggatg ggcgctgcct catctggggc aggaagccca
 1321 aggtcatcga gtgctcctac acatccgccg acgggcagag gcaccacagc aagctgctgg
 1381 tgtcgggctt ctggggcgtg gcccgccact tcaactacgt cggcgacctg atgggcagcc
 1441 tggcctactg cctggcctgt ggcggtggcc acctgctgcc ctacttctac atcatctaca
 1501 tggccatcct gctgacccac cgctgcctcc gggacgagca ccgctgcgcc agcaagtacg
 1561 gccgggactg ggagcgctac accgccgcag tgccttaccg cctgctgcct ggaatcttct
 1621 aagggcacgc cctagggaga agccctgtgg ggctgtcaag agcgtgttct gccaggtcca
 1681 tgggggctgg catcccagct ccaactcgag gagcctcagt ttcctcatct gtaaactgga
 1741 gagagcccag cacttggcag gtgtccagta cctaatcacg ctctgttcct tgcttttgcc
 1801 ttcaagggaa ttccgagtgt ccagcactgc cgtattgcca gcacagacgg attttctcta
 1861 atcagtgtcc ctgggcagga ggatgaccca gtcaccttta ctagtccttt ggagacaatt
 1921 tacctgtatt aggagcccag gccacgctac actctgccca cactggtgag caggaggtct
 1981 tcccacgccc tgtcattagg ctgcatttac tcttgctaaa taaaagtggg agtggggcgt
 2041 gcgcgttatc catgtattgc ctttcagctc tagatccccc tcccctgcct gctctgcagt
 2101 cgtgggtggg gcccgtgcgc cgtttctcct tggtagcgtg cacggtgttg aactgggaca
 2161 ctggggagaa aggggctttc atgtcgtttc cttcctgctc ctgctgcaca gctgccagga
 2221 gtgctctgcc tggagtctgc agacctcaga gaggtcccag cactggctgt ggctttcagg
 2281 tgtaggcagg tgggctctgc ttcccgattc cctgtgagcg cccaccctct cgaaagaatt
 2341 ttctgtcttg ccctgtgact gtgcagactc tggctcgagc aacccgggga acttcaccct
 2401 caggggcctc tccacacctt ctccagcgag gaggtctcag tcccagcctc gggagggcac
 2461 ctccttttct gtgctttctt ccctgaggca ttcttcctca tccctagggt gttgtgtaga
 2521 actcttttta aactctatgc tccgagtaga gttcatcttt atattaaact tcccctgttc
 2581 aaaaaaaaaa aaaaaaa

===Häufigkeit der einzelnen Basen in einer Codesequenz===
Eine einfache Fragestellung bei der Betrachtung von DNS Sequenzen, ist die Frage nach der Häufigkeit der einzelnen Basen.
Siehe dazu http://rosalind.info/problems/ini/

Gegeben ist ein DNS Strang von maximal 1000 Basen. 

Gesucht wird die Anzahl von a,c,g und t in diesem Strang. 

Rosalinds Beispiel : 
AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC

Berechnetes Ergebnis :
20 12 17 21

====Basic Programm ====

save&quot;dnastat.bas

 10 REM DNA ZAEHLEN
 15 REM ZAEHLERAUFNULL
 20 AZ = 0
 30 CZ = 0
 40 GZ = 0
 50 TZ = 0
 60 REM INPUT DNA SEQUENZ
 70 DNA$ = &quot;ACGTACGT&quot;
 80 REM N AS INTEGER
 90 REM    DIM TEMP AS STRING, CHAR AS STRING * 1
 110 REM TEMP = RTRIM$(LTRIM$(DNA$))
 120 FOR N = 1 TO LEN(DNA$)
 130 CHAR$ = MID$(DNA$, N, 1)
 140 IF CHAR$ = &quot;A&quot; THEN AZ = AZ + 1
 150 IF CHAR$ = &quot;C&quot; THEN CZ = CZ + 1
 160 IF CHAR$ = &quot;G&quot; THEN GZ = GZ + 1
 170 IF CHAR$ = &quot;T&quot; THEN TZ = TZ + 1
 240 NEXT 
 250 PRINT &quot;AZ = &quot;;AZ
 260 PRINT &quot;CZ = &quot;;CZ
 270 PRINT &quot;GZ = &quot;;GZ
 280 PRINT &quot;TZ = &quot;;TZ

run
AZ =  2 
CZ =  2 
GZ =  2 
TZ =  2 

Kopieren Sie ihre Sequenz in die Zeile 70 des Programmes und lassen sie es in Basic mit RUN laufen. In manchen Basicdialekten müssen die Zeilennummern noch herausgelöscht werden. 

===Redundanz im genetischen Code Quelle===
====Entropies of biosequences: The role of repeats ====
The American Physical Society  1994
*Hanspeter Herzel
**Institute of Theoretical Physics, Technical University, Hardenbergstrasse 36, D-10623 Berlin, Germany 
*Werner Ebeling and Armin O. Schmitt
**Institute of Physics, Humboldt University, Invalidenstrasse 110, D-10115 Berlin, Germany 
Received 23 May 1994 

DNA sequences of higher organisms contain thousands of nearly identical dispersed repetitive sequences. In order to understand the effect of such repeats on word entropies, we construct a model that can be analyzed analytically. The hypothetical model sequences consist of independent equidistributed symbols with randomly interspersed repeats. As a conclusion, we predict that the entropy of DNA sequences measuring the information content is much lower than expected.

==Links==
*http://rosalind.info/problems/ini/
**Grundlagen der Bioinformatik , Programm zur Analyse des genetischen Codes
==Literatur==
*Was ist Leben? - Die lebende Zelle mit den Augen des Physikers betrachtet
**von Erwin Schrödinger und L. Mazurcak</text>
      <sha1>0ttf6mmjk9rv7bifd9lr4f6piwd24nq</sha1>
    </revision>
    <revision>
      <id>1088592</id>
      <parentid>1088591</parentid>
      <timestamp>2026-07-03T17:28:19Z</timestamp>
      <contributor>
        <username>~2026-38044-54</username>
        <id>116480</id>
      </contributor>
      <comment>/* Entropie im genetischen Code */</comment>
      <origin>1088592</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="8685" sha1="3fut4v15rocbca7nrjlxqx592kcftok" xml:space="preserve">Zurück zur '''[[Entropie|Übersicht]]'''

[[Image:Human evolution.svg|thumb|300px|'''Widerspricht die biologische Evolution dem 2.Hauptsatz ?''']]
==Biologische Lebewesen sind Entropieerzeugende Systeme==
Jedes Tier nimmt entropiearme (und energiereiche) Nahrung zu sich und gibt entropiereiche Abfallstoffe wieder ab.

Interessant ist beispielsweise die Entropiebilanz eines Menschen.

Bei Pflanzen wird entropiearmes Licht von der Sonne aufgenommen und entropiereiche Wärmestrahlung wieder abgegeben.  


==Entropie und Lebensentstehung==
Nach Ansicht vieler religiöser Menschen und ''intelligenter Designer'' widerspricht die Entstehung des Lebens auf der Erde dem 2. Hauptsatz der Wärmelehre.
Nur eine höhere Macht, die ausserhalb der Physik steht, kann für die Lebensentstehung verantwortlich sein.

Wenn dem so wäre, würde auch die Sternbildung, die Kristallbildung und jede Goldmine dem 2. Hauptsatz widersprechen. Wichtig ist es zu verstehen, dass zwei Prozesse gekoppelt werden können, von denen ein Prozess entropieerzeugend ist und der andere entropievermindernd. Das Ergebnis ist dann die Entstehung von entropiearmen geordneten Strukturen, die man entgegen der allgemeinen Tendenz der Entropievermehrung nicht erwartet hätte.

==Entropie und Evolution==

===Zitate===
====Keine Entropie in der Evolution ?====
In dem Buch ''Ketten für Prometheus: Gegen die Natur oder mit ihr? Von Reinhard Demoll'' 
wird auf Seite 239 die Ansicht geäußert:
 Im Reich der Organismen gibt es keine Entropie 
 sondern nur ein Sich-Hinaufentwickeln, 
 den Drang zur Vervollkommnung des Typus; 
 und dies äußert sich im Geistigen ebenso wie im Körperlichen. 

Von Reinhard Demoll Veröffentlicht 1954 F. Bruckmann 248 Seiten 

Diese Ansicht ist aus heutiger Sicht falsch. 
Einmal ist bei der Rekombination und der Variation des Erbgutes der Zufall und damit auch die Entropie im Spiel. 
Außerdem kann die Evolution nur deswegen ablaufen, da durch den steten Energiestrom der Sonne die Entropie der Sonne und des umgebenden Weltraums erhöht wird und damit der Entropieverlust durch die Evolution ausgeglichen wird.

==Entropie und Zellteilung==
Korrekturmechanismen im genetischen Code zur Entropieverminderung

==Entropie und Gesundheit==
Gesundheit ist eigentlich ein antientropisches Prinzip. Biologische Organismen verstehen es, entgegen der Vielzahl der inneren und äusseren Störeinflüsse ihre biologische Ordnung aufrecht zu erhalten. Im Alter kommt dann die Entropie wieder vermehrt zum tragen, die Reparaturmechanismen versagen zunehmend. 

Zitat
 Es gibt nur eine Möglichkeit gesund zu sein, 
 aber tausend Möglichkeiten krank zu sein.

==Entropie im genetischen Code==

Sie haben eine Gensequenz und versuchen, die Entropie dieser Sequenz zu berechnen ? Macht so eine Berechnung überhaupt Sinn ? Wie ändert sich die Berechnung, wenn man immer Triplets betrachtet ? Es sind ja immer zwei Basenpaare gekoppelt g und c sowie a und t, kann man das Ausnutzen, um die Redundanz zu reduzieren ? Wie schaut eine 01 Kodierung für Gene aus ?
Beispielsweise 
 a    00
 c    01
 g    10
 t    11
Gibt es dazu einen Standard ? 

    1 gagcagcgcg cgcaagcagg ccaggggaag gtgggcgcag gtgaggggcc gaggtgtgcg
   61 caggacttta gccggttgag aaggatcaag caggcatttg gagcacaggt gtctagaaac
  121 ttttaagggg ccggttcaag aaggaaaagt tcccttctgc tgtgaaacta tttggcaaga
  181 ggctggaggg cccaatggct gcaaaattgc aacccaacat tcccaaagcc aagagtctag
  241 atggcgtcac caatgacaga accgcatctc aagggcagtg gggccgtgcc tgggaggtgg
  301 actggttttc actggcgagc gtcatcttcc tactgctgtt cgcccccttc atcgtctact
  361 acttcatcat ggcttgtgac cagtacagct gcgccctgac cggccctgtg gtggacatcg
  421 tcaccggaca tgctcggctc tcggacatct gggccaagac tccacctata acgaggaaag
  481 ccgcccagct ctataccttg tgggtcacct tccaggtgct tctgtacacg tctctccctg
  541 acttctgcca taagtttcta cccggctacg taggaggcat ccaggagggg gccgtgactc
  601 ctgcaggggt tgtgaacaag tatcagatca acggcctgca agcctggctc ctcacgcacc
  661 tgctctggtt tgcaaacgct catctcctgt cctggttctc gcccaccatc atcttcgaca
  721 actggatccc actgctgtgg tgcgccaaca tccttggcta tgccgtctcc accttcgcca
  781 tggtcaaggg ctacttcttc cccaccagcg ccagagactg caaattcaca ggcaatttct
  841 tttacaacta catgatgggc atcgagttta accctcggat cgggaagtgg tttgacttca
  901 agctgttctt caatgggcgc cccgggatcg tcgcctggac cctcatcaac ctgtccttcg
  961 cagcgaagca gcgggagctc cacagccatg tgaccaatgc catggtcctg gtcaacgtcc
 1021 tgcaggccat ctacgtgatt gacttcttct ggaacgaaac ctggtacctg aagaccattg
 1081 acatctgcca tgaccacttc gggtggtacc tgggctgggg cgactgtgtc tggctgcctt
 1141 atctttacac gctgcagggt ctgtacttgg tgtaccaccc cgtgcagctg tccaccccgc
 1201 acgccgtggg cgtcctgctg ctgggcctgg tgggctacta catcttccgg gtggccaacc
 1261 accagaagga cctgttccgc cgcacggatg ggcgctgcct catctggggc aggaagccca
 1321 aggtcatcga gtgctcctac acatccgccg acgggcagag gcaccacagc aagctgctgg
 1381 tgtcgggctt ctggggcgtg gcccgccact tcaactacgt cggcgacctg atgggcagcc
 1441 tggcctactg cctggcctgt ggcggtggcc acctgctgcc ctacttctac atcatctaca
 1501 tggccatcct gctgacccac cgctgcctcc gggacgagca ccgctgcgcc agcaagtacg
 1561 gccgggactg ggagcgctac accgccgcag tgccttaccg cctgctgcct ggaatcttct
 1621 aagggcacgc cctagggaga agccctgtgg ggctgtcaag agcgtgttct gccaggtcca
 1681 tgggggctgg catcccagct ccaactcgag gagcctcagt ttcctcatct gtaaactgga
 1741 gagagcccag cacttggcag gtgtccagta cctaatcacg ctctgttcct tgcttttgcc
 1801 ttcaagggaa ttccgagtgt ccagcactgc cgtattgcca gcacagacgg attttctcta
 1861 atcagtgtcc ctgggcagga ggatgaccca gtcaccttta ctagtccttt ggagacaatt
 1921 tacctgtatt aggagcccag gccacgctac actctgccca cactggtgag caggaggtct
 1981 tcccacgccc tgtcattagg ctgcatttac tcttgctaaa taaaagtggg agtggggcgt
 2041 gcgcgttatc catgtattgc ctttcagctc tagatccccc tcccctgcct gctctgcagt
 2101 cgtgggtggg gcccgtgcgc cgtttctcct tggtagcgtg cacggtgttg aactgggaca
 2161 ctggggagaa aggggctttc atgtcgtttc cttcctgctc ctgctgcaca gctgccagga
 2221 gtgctctgcc tggagtctgc agacctcaga gaggtcccag cactggctgt ggctttcagg
 2281 tgtaggcagg tgggctctgc ttcccgattc cctgtgagcg cccaccctct cgaaagaatt
 2341 ttctgtcttg ccctgtgact gtgcagactc tggctcgagc aacccgggga acttcaccct
 2401 caggggcctc tccacacctt ctccagcgag gaggtctcag tcccagcctc gggagggcac
 2461 ctccttttct gtgctttctt ccctgaggca ttcttcctca tccctagggt gttgtgtaga
 2521 actcttttta aactctatgc tccgagtaga gttcatcttt atattaaact tcccctgttc
 2581 aaaaaaaaaa aaaaaaa

===Häufigkeit der einzelnen Basen in einer Codesequenz===
Eine einfache Fragestellung bei der Betrachtung von DNS Sequenzen, ist die Frage nach der Häufigkeit der einzelnen Basen.
Siehe dazu http://rosalind.info/problems/ini/

Gegeben ist ein DNS Strang von maximal 1000 Basen. 

Gesucht wird die Anzahl von a,c,g und t in diesem Strang. 

Rosalinds Beispiel : 
AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC

Berechnetes Ergebnis :
20 12 17 21

====Basic Programm ====

save&quot;dnastat.bas

 10 REM DNA ZAEHLEN
 15 REM ZAEHLERAUFNULL
 20 AZ = 0
 30 CZ = 0
 40 GZ = 0
 50 TZ = 0
 60 REM INPUT DNA SEQUENZ
 70 DNA$ = &quot;ACGTACGT&quot;
 80 REM N AS INTEGER
 90 REM    DIM TEMP AS STRING, CHAR AS STRING * 1
 110 REM TEMP = RTRIM$(LTRIM$(DNA$))
 120 FOR N = 1 TO LEN(DNA$)
 130 CHAR$ = MID$(DNA$, N, 1)
 140 IF CHAR$ = &quot;A&quot; THEN AZ = AZ + 1
 150 IF CHAR$ = &quot;C&quot; THEN CZ = CZ + 1
 160 IF CHAR$ = &quot;G&quot; THEN GZ = GZ + 1
 170 IF CHAR$ = &quot;T&quot; THEN TZ = TZ + 1
 240 NEXT 
 250 PRINT &quot;AZ = &quot;;AZ
 260 PRINT &quot;CZ = &quot;;CZ
 270 PRINT &quot;GZ = &quot;;GZ
 280 PRINT &quot;TZ = &quot;;TZ

run
AZ =  2 
CZ =  2 
GZ =  2 
TZ =  2 

Kopieren Sie ihre Sequenz in die Zeile 70 des Programmes und lassen sie es in Basic mit RUN laufen. In manchen Basicdialekten müssen die Zeilennummern noch herausgelöscht werden. 

===Redundanz im genetischen Code Quelle===
====Entropies of biosequences: The role of repeats ====
The American Physical Society  1994
*Hanspeter Herzel
**Institute of Theoretical Physics, Technical University, Hardenbergstrasse 36, D-10623 Berlin, Germany 
*Werner Ebeling and Armin O. Schmitt
**Institute of Physics, Humboldt University, Invalidenstrasse 110, D-10115 Berlin, Germany 
Received 23 May 1994 

DNA sequences of higher organisms contain thousands of nearly identical dispersed repetitive sequences. In order to understand the effect of such repeats on word entropies, we construct a model that can be analyzed analytically. The hypothetical model sequences consist of independent equidistributed symbols with randomly interspersed repeats. As a conclusion, we predict that the entropy of DNA sequences measuring the information content is much lower than expected.

==Links==
*http://rosalind.info/problems/ini/
**Grundlagen der Bioinformatik , Programm zur Analyse des genetischen Codes
==Literatur==
*Was ist Leben? - Die lebende Zelle mit den Augen des Physikers betrachtet
**von Erwin Schrödinger und L. Mazurcak</text>
      <sha1>3fut4v15rocbca7nrjlxqx592kcftok</sha1>
    </revision>
  </page>
  <page>
    <title>Strukturierte Programmierung</title>
    <ns>0</ns>
    <id>84057</id>
    <revision>
      <id>1088579</id>
      <parentid>1088544</parentid>
      <timestamp>2026-07-03T12:11:39Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <comment>/* Leerräume */ aktualisiert</comment>
      <origin>1088579</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="180051" sha1="lj0y1zvs5sl6q0geene7xl3l71mgy4e" xml:space="preserve">{{Regal | ort=Programmierung}}
[[Datei:Programmierung.Java.Julia-Menge.png|mini|rechts|hochkant=2|Bildschirmaufnahme des mit Tastatursteuerung interaktiven Java-Programms [[Das Apfelmännchen/ FraktaleMengeAusgabe|FraktaleMengeAusgabe]] zur Berechnung und Darstellung von Julia-Mengen oder der Mandelbrot-Menge. Siehe auch '''Wikibook [[Das Apfelmännchen]]'''.]]
[[Datei:Programmierung.Java.Maze.png|mini|rechts|hochkant=2|Bildschirmaufnahme des Java-Programms [[Rekursive Labyrinthe/ MazeGraphs|Maze]] zur rekursiven Erstellung und Darstellung von Labyrinthen. Siehe auch '''Wikibook [[Rekursive Labyrinthe]]'''.]]
[[Datei:Programmierung.Java.SimForestFrame.png|mini|rechts|hochkant=2|Bildschirmaufnahme des Java-Programms [[Waldbrandsimulation/ SimForestFrame|SimForestFrame]] zur Simulation und Darstellung von sich ausbreitenden Waldbränden. Siehe auch '''Wikibook [[Waldbrandsimulation]]'''.]]
[[Datei:Programmierung.Java.Campingplatzraetsel.png|mini|rechts|hochkant=2|Bildschirmaufnahme des mit Maussteuerung interaktiven Java-Programms [[Campingplatzrätsel/ CampingplatzGraphs|CampingplatzGraphs]] zur Erstellung und Darstellung von Campingplatzrätseln. Siehe auch '''Wikibook [[Campingplatzrätsel]]'''.]]
[[Datei:Programmierung.Java.GameOfLife.png|mini|rechts|hochkant=2|Bildschirmaufnahme des Java-Programms &quot;GameOfLife&quot; zur Anzeige von Conways Spiel des Lebens. Siehe auch '''Wikibook [[Game of Life]]'''.]]

==Einleitung==
Das Buch '''Strukturierte Programmierung''' ist kein Lehrbuch zum Erlernen einer Programmiersprache, sondern soll als kleiner Leitfaden dazu dienen, besser strukturierte Programme erstellen zu können, selbst wenn die eingesetzten Programmiersprachen die strukturierte Programmierung weniger stark unterstützen.

&lt;big&gt;Warum lohnt es sich überhaupt, strukturiert zu programmieren&amp;nbsp;?&lt;/big&gt;

Es gibt eine ganze Reihe von naheliegenden Gründen, aber auch einige Vorteile, die nicht auf der Hand liegen oder jedermann sofort ersichtlich sind. Anfänger und Fortgeschrittene profitieren gleichermaßen von gut strukturierter Programmierung. Die Vorteile sind so erheblich, dass es unbedingt sinnvoll ist, gut strukturiert zu programmieren. Im Folgenden werden einige wichtige Vorteile aufgeführt und erläutert:

*'''Strukturierte Programme sind leichter nachvollziehbar.''' Dies erleichtert die Arbeit im Team und vereinfacht die Wartung, wenn der Quellcode ergänzt, geändert oder korrigiert werden muss.
*'''Strukturierte Programme haben weniger Programmierfehler.''' Dies reduziert die Entwicklungszeiten und erhöht die Akzeptanz bei den Auftraggebern und Nutzern der Software.
*'''Strukturierte Programme können ohne Laufzeit-Debugger erstellt werden.''' Dies spart enorm viel Zeit und Nerven bei der Entwicklung von Software.

Die geringen Laufzeiteinbußen, die bei hoch strukturierter Programmierung von Anwendungssoftware gegenüber laufzeitoptimiertem Code entstehen können, spielen –&amp;nbsp;sofern sie überhaupt existieren sollten&amp;nbsp;– bei den heutzutage zur Verfügung stehenden modernen und schnellen Rechenmaschinen praktisch keine Rolle mehr. Programmcode wegzulassen, der der inhärenten Betriebssicherheit von Software oder der inhärenten Datenintegrität dient, macht nur in sehr wenigen, extrem zeitkritischen Anwendungen Sinn, keineswegs jedoch bei herkömmlichen oder gar sicherheitskritischen Anwendungsprogrammen.

Die Ratschläge aus diesem Buch beruhen auf jahrzehntelanger Erfahrung mit der Softwareentwicklung komplexer Systeme und dem Hochschulunterricht im Fach Programmierung mit verschiedenen Programmiersprachen.

Die folgende Check-Liste enthalt eine Reihe von wichtigen Kriterien, die bei strukturierter Programmierung berücksichtigt werden sollten:

* &lt;big&gt;&lt;big&gt;'''[[Strukturierte Programmierung/ Checkliste|Checkliste]]'''&lt;/big&gt;&lt;/big&gt;

Übrigens: ''In der Kürze der Quelltextdatei liegt nicht die wahre Würze des Programmierens&amp;nbsp;!''

Und noch wichtiger:

:''So ists mit aller Bildung auch beschaffen:''
:''Vergebens werden ungebundne Geister''
:''Nach der Vollendung reiner Höhe streben.''

:''Wer Großes will, muß sich zusammenraffen;''
:''In der Beschränkung zeigt sich erst der Meister,''
:''Und das Gesetz nur kann uns Freiheit geben.''

::Johann Wolfgang von Goethe, Ende von ''Das Sonett''

Viel Erfolg beim strukturierten Programmieren wünscht [[Benutzer:Bautsch]]&amp;nbsp;!
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Quelltextgestaltung==
In diesem Abschnitt stehen einige Vorschläge zur allgemeinen Gestaltung der Quelltexte, die keine unmittelbare Auswirkung auf die Lauffähigkeit und die Funktion der Programme haben, aber dazu führen, dass der Quelltext besser verständlich und nachvollziehbar ist.

===Anweisungen===
Der Quelltext wird bei imperativen Programmiersprachen durch Anweisungen gestaltet, die ganz unterschiedlich geartet sein können. Zu den typischen und wichtigen Anweisungen gehören:

* Deklaration (declaration)
* Blockanweisung (block, begin / end)
* Zuweisung (assignment)
* Aufruf (call)
* Rücksprung (return)
* Verzweigung (branch)
* Schleife (loop)
* Sicherstellung (assertion)

Bei Kommentaren und Leerräumen (Leerzeichen, Tabulatoren, Zeilenumbrüche, ...) in Quelltexten handelt es sich nicht um Anweisungen, da sie vom Übersetzer (compiler) beziehungsweise Interpreter des Programmcodes ignoriert werden.

===Kommentare===
Jeder Quelltext sollte zu Beginn der Datei in einem von Compiler zu ignorierenden '''Kommentar''' einige Mindestangaben zum Inhalt und Ursprung machen. Dazu gehören der Dateiname, der Modulname (respektive Klassenname), die Autoren, Urheber oder Rechteinhaber, deren beabsichtigte Nutzungsarten/-rechte und Nutzungsbedingungen und weitere Angaben zur Lizenzierung, das Datum, eine Versionsangabe und die Angabe der verwendeten Programmiersprache (gegebenenfalls ebenfalls mit einer Versionsangabe).

Der Kommentartext wird bei vielen Programmiersprachen im Quelltext mit dem Symbolpaar &quot;/*&quot; und &quot;*/&quot; oder dem Symbolpaar &quot;(*&quot; und &quot;*)&quot; eingeschlossen.

Beispiel:

 /*
   Source file: editor.java
   Program: editor
   Author: Bautsch
   License: public domain
   Date: 7th January 2011
   Version: 1.0
   Programming language: Java
 */

Alle Methoden und Variablen werden ausreichend kommentiert, sofern sie nicht durch die Wahl „sprechender” Bezeichner selbsterklärend sind.

Bei Methoden werden insbesondere die Bedeutung aller Parameter und Rückgabewerte dokumentiert:

 /* The method &quot;add&quot; computes and returns the sum of &quot;summand1&quot; and &quot;summand2&quot; */
 double add (double summand1, double summand2)
 {
    double sum ← summand1 + summand2
    return sum
 }

Viele Entwicklungssysteme bieten Funktionen, die die Dokumentation der Quelltexte mit Kommentaren unterstützen.

Bei einigen Programmiersprachen ist Aufmerksamkeit geboten, wenn in der Sprachdefinition geschachtelte Kommentare nicht vorgesehen sind. Wird zum Beispiel während der Programmentwicklung Quelltext auskommentiert, um das Verhalten des modifizierten Programms zu überprüfen, und enthält dieser Quelltext einen Kommentar, ist dann nicht sofort erkennbar, welcher Abschnitt des Quelltextes tatsächlich auskommentiert werden soll. Dabei kann es auch vorkommen, dass einige Compiler die geschachtelten Kommentare erkennen und im eigentlichen Sinne des Programmierers berücksichtigen; andere Compiler, die sich streng an die standardisierten Sprachdefinitionen halten, jedoch nicht, so dass es bei der Portierung von Quellcode unweigerlich zu Übersetzungsfehlern kommt.

Das folgende Beispiel zeigt einen Programmabschnitt, bei dem hinter der letzten Anweisung zwischen den Zeichenfolgen &quot;/*&quot; und &quot;*/&quot; ein Textkommentar hinzugefügt wurde, der vom Compiler ignoriert werden soll.

 int i ← 1
 i ← i * i /* die Variable i wird quadriert. */

Wird zusätzlich mit den gleichen Zeichenfolgen &quot;/*&quot; und &quot;*/&quot; die gesamte Programmzeile auskommentiert, gibt es einen Übersetzungsfehler, wenn der Compiler die allerletzte Zeichenfolge &quot;*/&quot; als Kommentarende ohne Kommentaranfang interpretiert, sofern der zweite und nunmehr auskommentierte Kommentaranfang &quot;/*&quot; in der Zeile mit dem Textkommentar ignoriert wurde und die erste auftretende Zeichenfolge &quot;*/&quot; bereits als Kommentarende interpretiert wurde:

 int i ← 1
 /*
    i ← i * i /* die Variable i wird quadriert. */
 */

===Leerräume===
'''Leerräume''', also zum Beispiel Leerzeichen, Zeilen- und Seitenumbrüche oder Tabulatoren, werden - genauso wie Kommentare - von vielen Compilern überlesen und dienen in diesen Fällen ausschließlich zur Verbesserung der Lesbarkeit für die Programmierer. Daher sollten diese Leerräume sorgfältig eingesetzt werden, um die Nachvollziehbarkeit des Quellcodes für Programmierer zu erleichtern. Bei einigen Programmiersprachen werden allerdings bestimmte Formatierungen in der Sprachdefinition gefordert und müssen dann natürlich den Vorgaben entsprechend eingehalten werden.

Viele Entwicklungssysteme bieten sehr nützliche, unterstützende Funktionen zur einheitlichen Formatierung der Quelltexte, die sehr einfach anzuwenden sind und benutzt werden sollten. So ist es zum Beispiel allgemein üblich, Programmblöcke so zu formatieren, dass die Inhalte gegenüber dem Kopf und dem Fuß etwas eingerückt und durch Zeilenumbrüche voneinander getrennt werden:

 Blockkopf
    eingerückter Inhalt 1
    eingerückter Inhalt 2
 Blockfuß

Für die Einrückungen werden heute meist mehrere Leerzeichen oder ein Tabulatorzeichen verwendet. Neuerdings wird in manchen Programmiersprachen empfohlen, vier Leerzeichen zu verwenden. Manche Editoren fügen bei der Betätigung der Tabulatortaste eine gewünschte Anzahl von Leerzeichen ein. Das Mischen von mehreren Leerzeichen und Tabulatorzeichen für die Einrückungen kann nicht empfohlen werden, da dies bei der Bearbeitung mit verschiedenen Editoren zur uneinheitlichen Darstellung der Einrückungen führen kann. Moderne Editoren haben Funktionen, mit denen der gesamte Programmcode oder Teile davon einheitlich und korrekt eingerückt werden können (Englisch: &quot;correct indentation&quot;).

Siehe hierzu auch [[Strukturierte Programmierung#Blockanweisungen|Blockanweisungen]].

===Bezeichner===
In den meisten Programmiersprachen gibt es '''Bezeichner''' (oder '''Identifikatoren''', englisch: '''identifier''') für ganz unterschiedliche Dinge, wie für symbolische '''Konstanten''', für '''Variablen''', für '''Parameter''' oder '''Attribute''', für '''Methoden '''(respektive für '''Prozeduren''' oder für '''Funktionen'''), für '''Module''' (respektive für '''Klassen''') oder für '''Bibliotheken'''. Zur Strukturierung von Daten werden auch '''Pakete''' (englisch: '''packages''') eingesetzt.

In der Regel stehen alle Buchstaben ohne Diakritika zur Verfügung. Oft sind auch noch Ziffern und der Unterstrich &quot;_&quot; erlaubt. Das erste Zeichen muss üblicherweise immer ein Buchstabe sein. Leerzeichen sind innerhalb von Bezeichnern im Allgemeinen nicht zulässig.

Beim Lesen und Analysieren von Quelltexten ist es sehr hilfreich, wenn einem Bezeichner nicht nur beim ersten Auftauchen bei der Deklaration, sondern an jeder Stelle im Programm sofort angesehen werden kann, wofür er steht. Meist bildet sich für eine Gruppe von Programmiersprachen ein bestimmter Usus aus, wie die entsprechenden Bezeichner gestaltet werden sollen. Der Compiler stellt in der Regel keine Ansprüche an die Schreibweise von Bezeichnern, solange der definierte Zeichenvorrat verwendet wird. Eine Ausnahme stellen die vorgegebenen Schlüsselwörter dar, die häufig und je nach Programmiersprache nur aus Großbuchstaben oder nur aus Kleinbuchstaben bestehen, wie zum Beispiel:

* '''IMPORT''', '''CONST''', '''TYPE''', '''VAR''', '''PROCEDURE''', '''NIL''', '''LONG''', '''REAL''', '''BEGIN''', '''END''', '''WHILE'''
versus
* '''import''', '''final''', '''void''', '''static''', '''null''', '''long''', '''double''', '''while'''

In vielen Programmiersprachen haben sich für die frei definierbaren Bezeichner bestimmte Praktiken herausgebildet, damit die Bedeutung der Bezeichner im Quelltext von den beteiligten Programmierern leichter erkannt werden kann. Dieses Vorgehen ist allerdings nicht immer einheitlich gestaltet, wie anhand der folgenden, beispielhaften Liste gesehen werden kann:
* Die Bezeichner von übergeordnet verfügbaren Konstanten, Variablen, Datentypen, Klassen oder Modulen beginnen mit '''einem Großbuchstaben'''.
* Die Bezeichner von Konstanten werden '''vollständig mit Großbuchstaben''' geschrieben.
* Die Bezeichner von lokal verfügbaren Variablen, Attributen oder Parametern werden '''vollständig mit Kleinbuchstaben''' geschrieben.
* Die Bezeichner von Methoden werden '''vollständig mit Kleinbuchstaben''' geschrieben.

====Variablen und Methoden====
So ist es zum Beispiel üblich, Variablen und Methoden mit Kleinbuchstaben zu benennen. Dabei ist der Unterschied zwischen Variable und Methode immer und einfach anhand der obligatorischen Parameterliste von Methoden zu erkennen, die beim Fehlen von Parametern leer ist und in vielen Programmiersprachen durch runde Klammern begrenzt ist und direkt hinter dem Methodennamen steht:

 /* &quot;diameter&quot; is variable of the data type integer */
 int diameter
 
 /* &quot;radius&quot; is variable (parameter of the function &quot;calcDiameter&quot;) of the data type integer */
 /* &quot;calcDiameter&quot; is a function */
 /* the result of the function call has the data type integer */
 int calcDiameter (int radius)

&quot;calcDiameter&quot; ist hierbei mit dem Binnenmajuskel &quot;D&quot; versehen (umgangssprachlich auch &quot;Kamelhöcker-Notation&quot; genannt, englisch &quot;camel case&quot;), um den Anfang eines neuen Wortes ohne die Verwendung eines Leerzeichens erkennbar zu machen.

Es ist im Sinne der guten Lesbarkeit des Quelltextes allgemein hilfreich, in Bezeichnern immer passende grammatische Formen zu verwenden, wie zum Beispiel:
* für booleschen Variablen und Funktionen: Partizipien oder Adjektive
* für andere Variablen und Funktionen: Substantive
* für Methoden und Kommandos: Verben im Imperativ

In manchen Programmiersprachen ist es üblich, lokale Variablen mit einem Kleinbuchstaben zu beginnen und globale Variablen - also in mehreren Programmodulen, Klassen oder Methoden sichtbare Variablen - mit einem Großbuchstaben zu beginnen, um deren Sichtbarkeiten unmittelbar erkennbar zu machen.

====Konstanten====
Die Werte von Konstanten können zur Laufzeit nicht mehr verändert werden. Dieser Umstand wird dem Compiler bei der Deklaration der Konstanten durch entsprechende Deklarationen (wie zum Beispiel &quot;CONST&quot;) oder Modifikatoren (wie zum Beispiel &quot;final&quot;) mitgeteilt.

Damit an jeder Stelle des Quelltextes, also auch nach der Deklaration, erkannt werden kann, dass es sich um eine Konstante handelt, ist es hilfreich Konstanten mit einem '''Großbuchstaben''' beginnen zu lassen; manchmal werden für Konstanten sogar ausschließlich Großbuchstaben verwendet.

Es ist empfehlenswert, die Initialisierung einer Konstanten immer unmittelbar im Kontext der Deklaration vorzunehmen, damit es keine Mehrdeutigkeiten und somit auch keine Verwechslungen durch undefinierte Werte geben kann. Wenn dies nicht sinnvoll erscheint, sollte vorzugsweise keine Konstante verwendet werden. In vielen modernen Programmiersprachen ist es möglich, Klassenvariablen beziehungsweise globale Variablen zu schützen, indem diese nur innerhalb einer Klasse beziehungsweise innerhalb eines Moduls verändert werden dürfen. In diesem Fall gibt es von Außerhalb nur einen Lesezugriff auf den Wert der Variablen (&quot;read-only&quot;), oder der aktuelle Wert der Variablen kann durch den Aufruf eines Unterprogramms zurückgegeben werden (&quot;get&quot;-Methoden).

&lt;syntaxhighlight lang=&quot;Pascal&quot;&gt;
(* Programmiersprache Component Pascal *)

MODULE Zahlen;

(* Auf die globale ganzzahlige Konstante &quot;Konstante&quot; kann nur lesend zugegriffen werden. *)
(* Die globale Konstante &quot;Konstante&quot; ist durch Deklaration und Initialisierung vollständig definiert. *)
CONST
	Konstante = 7;

(* Auf die globale ganzzahlige Variable &quot;zahl&quot; kann von außerhalb des Moduls &quot;Zahlen&quot; nur lesend zugegriffen werden. *)
(* Die globale Variable &quot;zahl&quot; wird mit dem Zusatz &quot;-&quot; als &quot;read-only&quot; deklariert. *)
VAR
	zahl-: LONGINT;

BEGIN
	(* Die globale Variable &quot;zahl&quot; wird mit einem Wert initialisiert. *)
	zahl := 8;
END Zahlen.
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Zahlen;
{
	// Auf die öffentliche ganzzahlige Klassenkonstante &quot;Konstante&quot; kann nur lesend zugegriffen werden.
	// Die Klassenkonstante &quot;Konstante&quot; ist durch Deklaration und Initialisierung vollständig definiert.
	// Die Klassenkonstante &quot;Konstante&quot; wird mit dem Zusatz &quot;final&quot; deklariert.
	public static final long Konstante = 7;

	// Auf die nicht-öffentliche ganzzahlige Klassenvariable &quot;zahl&quot; kann von außerhalb der Klasse
	// nur über die öffentliche Methode &quot;getZahl ()&quot; lesend zugegriffen werden.
	// Die Klassenvariable &quot;zahl&quot; wird mit dem Zusatz &quot;private&quot; deklariert.
	private static long zahl = 8;

	public static long getZahl ()
	{
		return zahl;
	}
}
&lt;/syntaxhighlight&gt;

Im folgenden Java-Beispiel wird eine als konstant deklarierte lokale Variable erst innerhalb einer Fallunterscheidung (if-Anweisung) und zudem mit zwei verschiedenen optionalen Werten initialisiert. Wenn die Deklaration und die optionalen Initialisierungen im Quelltext weiter auseinanderliegen, ist es schwierig, den definierten Zustand der vermeintlich eindeutig definierten Variablen vollständig zu erfassen.

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
private static boolean boolescherAusdruck ()
{
	java.util.Random zufall = new java.util.Random ();
	boolean zufaelligerBoolescherWert = zufall.nextBoolean ();
	return zufaelligerBoolescherWert;
}

public static void main (java.lang.String [] arguments)
{
	// Deklaration der lokalen Konstante &quot;Zahl&quot;,
	// die wegen fehlender Initialisierung nicht definiert ist.
	final long Zahl;

	if (boolescherAusdruck ())
	{
		Zahl = 7;
	}
	else
	{
		Zahl = 8;
	}
	java.lang.System.out.println (&quot;Konstante Zahl = &quot; + Zahl);
}
&lt;/syntaxhighlight&gt;

====Klassen und Module====
Auch Unterprogrammeinheiten wie '''Module''' oder '''Klassen''' werden in der Regel mit eindeutigen Bezeichnern benannt, die üblicherweise mit einem '''Großbuchstaben''' beginnen.

Im Kontext eines Quellcodes ist es immer möglich, diese Unterprogrammeinheiten von anderen zu unterscheiden, die ebenfalls mit einem Großbuchstaben beginnen (beispielsweise Konstanten), weil die Bezeichner von Unterprogrammeinheiten von einer Blockanweisung (zum Beispiel geschweifte Klammern) für die Implementation von Programmcode oder von einem Separator (beispielsweise &quot;.&quot;) zur qualifizierten Bezeichnung von Teilen der Unterprogrammeinheiten gefolgt werden.

Das Konzept von Unterprogrammeinheiten ist, dass mehrere Unterprogramme (Methoden, Prozeduren, Funktionen, Kommandos) sowie mehrere Konstanten, Variablen oder Datenstrukturen (Verbunde (struct, record), Arrays) in einer speicherbaren Datei zusammengefasst werden. Insofern handelt es sich bei solchen Unterprogrammeinheiten um die '''kleinsten dauerhaft speicherbaren Einheiten''' in einem Software-Projekten.

Unterprogrammeinheiten werden in strukturierten Programmiersprachen unter der Verwendung von Schlüsselwörtern wie zum Beispiel &quot;program&quot;, &quot;MODULE&quot; oder &quot;class&quot; '''deklariert''':

&lt;syntaxhighlight lang=&quot;Pascal&quot;&gt;
(* Die Unterprogrammeinheit &quot;Programmeinheit&quot; in der Programmiersprache Pascal *)
program Programmeinheit;
begin
end.
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;modula2&quot;&gt;
(* Die Unterprogrammeinheit &quot;Programmeinheit&quot; in den Programmiersprachen Modula-2, Oberon oder Component Pascal *)
MODULE Programmeinheit;
BEGIN
END Programmeinheit.
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
// Die Unterprogrammeinheit &quot;Programmeinheit&quot; in der Programmiersprache Java
public class Programmeinheit;
{
}
&lt;/syntaxhighlight&gt;

====„Sprechende” Bezeichner====
Die Wahl '''„sprechender“ Bezeichner''' hilft beim Lesen, Verstehen und Nachvollziehen von Quelltext ungemein. Häufig erübrigt sich sogar ein erläuternder Kommentar, wenn mit hinreichend „sprechenden“ Variablen- beziehungsweise Methodennamen gearbeitet wird.

Also nicht eine solche Anweisung:

 h ← (t – b)

Sondern besser:

 height ← (top - bottom)

Die verpasste Chance, einen Bezeichner sprechend zu benennen, kann in vielen Entwicklungssystemen durch sogenanntes ''Refactoring'' zentral für den gesamten Quelltext durch Umbenennung geheilt werden.

====Parameter====
Bei Methodenaufrufen werden '''alle Parameter''' mit Variablen oder mit Konstanten übergeben, also nicht mit '''komplexen Ausdrücken''' (beispielsweise arithmetische Berechnungen und Aufrufe von Unterprogrammen) oder mit '''Literalen''' (also direkt eingegebene Werte, wie 100 oder &quot;Text&quot;).

Hier ein schlechtes Beispiel mit dem Aufruf des Java-Unterprogramms &quot;zeichneRechteck&quot; mit fünf kryptischen Parameterausdrücken in den runden Klammern. Jedes der fünf Literalen 50 hat eine eigene unabhängige Bedeutung, die bei dieser Schreibweise nicht unterschieden oder nachvollzogen werden können, was deswegen schnell zu Verwechslungen führen kann:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   zeichneRechteck (50, 50, 50, berechneHoehe (50), 50);
&lt;/syntaxhighlight&gt;

Ein strukturiertes Programm weist die Werte für alle fünf Parameter vor dem Aufruf des Unterprogramms an eigene Variablen mit sprechenden Bezeichnern zu:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   int x = 50;
   int y = 50;
   int breite = 50;
   int hoehe = berechneHoehe (breite);
   int helligkeitProzent = 50;
   zeichneRechteck (x, y, breite, hoehe, helligkeitProzent);
&lt;/syntaxhighlight&gt;

Diese Anweisungsfolge ist im Gegensatz zu der Anweisung darüber auch ohne die explizite Kenntnisnahme der '''Deklaration des Unterprogramms''' verständlich:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   /**
   * Zeichnet ein Rechteck in das Bildschirmfenster
   * @param x: x-Koordinate vom linken Bildschirmfensterrand nach rechts
   * @param y: y-Koordinate vom oberen Bildschirmfensterrand nach unten
   * @param breite: Breite des Rechtecks von x nach rechts
   * @param hoehe: Hoehe des Rechtecks von y nach unten
   * @param helligkeitProzent: Helligkeit des Rechtecks in Prozent (0 = schwarz, 100 = weiss)
   */
   public static void zeichneRechteck (int x, int y, int breite, int hoehe, int helligkeitProzent)
&lt;/syntaxhighlight&gt;

====Qualifizierte Bezeichner====
=====Programmeinheiten=====
Damit der sich hinter einem Bezeichner verborgene Inhalt eindeutig einer Programmeinheit zugeordnet werden kann, muss dieser '''qualifiziert bezeichnet''' werden.

In manchen Programmiersprachen geschieht dies für bestimmte Bezeichner inhärent, obwohl es eine explizite import-Anweisung für die entsprechenden Bezeichner gibt, so dass die Programmierer in diesen Sonderfällen also wissen müssen, worauf sich der unqualifizierte Bezeichner bezieht. In der Programmiersprache Java dürfen häufig verwendete Bezeichner wie beispielsweise die zur Textausgabe verwendete Methode &quot;print&quot; aus der Klasse &quot;System&quot; oder die für Zeichenketten verwendete Klasse &quot;String&quot; ohne eine vollständige und qualifizierte Bezeichnung in den Programmtext geschrieben werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   String text = &quot;Hallo Welt!&quot;;
   System.out.print (text);
&lt;/syntaxhighlight&gt;

In der Variablen &quot;text&quot; der Klasse &quot;String&quot; wird die Zeichenkette &quot;Hallo Welt!&quot; gespeichert und mit der klassengebundenen Methode &quot;print&quot; der Klassenvariablen &quot;out&quot; aus der Klasse &quot;System&quot; ausgegeben. Hier ist allerdings nicht ohne weiteres ersichtlich, wo sich die Deklarationen oder die Implementierungen beiden Klassen &quot;String&quot; und &quot;System&quot; befinden.

Die '''qualifizierte Bezeichnung''' dieser beiden Anweisungen hat folgendes Aussehen:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   java.lang.String text = &quot;Hallo Welt!&quot;;
   java.lang.System.out.print (text);
&lt;/syntaxhighlight&gt;

Durch die qualifizierte Bezeichnung wird klar, dass sich beide Klassen im Programmpaket &quot;java.lang&quot; des Programmmoduls &quot;java.base&quot; befinden. Jedes Modul (englisch &quot;module&quot;) und jedes Paket (englisch &quot;package&quot;) kann in der Systembibliothek der Programmiersprache beziehungsweise in der Programmbibliothek der Laufzeitumgebung eindeutig zugeordnet werden.

Alternativ wird die Qualifikation von bestimmten Bezeichnern durch eine Import-Anweisung zu Beginn des Programms vorgenommen:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   import java.lang.String;
   import java.lang.System;

//...

      String text = &quot;Hallo Welt!&quot;;
      System.out.print (text);
&lt;/syntaxhighlight&gt;

Dieses Vorgehen erlaubt innerhalb einer Programmdatei zwar grundsätzlich eine korrekte und eindeutige Zuordnung der weiter unten im Programmtext verwendeten '''unqualifizierten''' Bezeichner, bei der Analyse des Programmtextes sind sämtliche Import-Anweisungen jedoch stets und vollständig zu berücksichtigen, was die Sache für die Programmierer insbesondere bei langen oder komplexen Quelltexten sehr erschweren kann. Dies kann durch die ausschließliche und obligatorische Verwendung von qualifizierten Bezeichnern ausgeschlossen werden, und deswegen wird von streng strukturierten Programmiersprachen überall und immer eine qualifizierte Bezeichnung gefordert.

Leider dürfen diese qualifizierten Importe beziehungsweise Bezeichnungen in manchen Programmiersprachen für gängige Unterprogrammeinheiten weggelassen werden, wie im folgenden Beispiel in der Programmiersprache Java:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
public class Test
{
   public static void main (String [] args)
   {
   }
}
&lt;/syntaxhighlight&gt;

Ein Aufruf des formal korrekt deklarierten Hauptprogramms &quot;main&quot; kann zu folgender völlig irritierender Fehlermeldung führen, wenn gar nicht die dafür vorgesehene Standard-Java-Klasse &quot;java.lang.String&quot; referenziert wird, weil sich im Software-Projekt, in dem sich das Hauptprogramm befindet, eine gleichnamige Klasse &quot;String&quot; definiert ist, die durch die Regeln der Programmiersprache vorrangig referenziert wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
Error: Main method not found in class Test, please define the main method as: public static void main (String [] args)
&lt;/syntaxhighlight&gt;

=====Datenstrukturen=====
Auch bei Datenstrukturen müssen qualifizierte Bezeichner verwendet werden, damit eindeutig auf bestimmte Datenfelder zugegriffen werden kann. Im folgenden Beispiel in der Syntax der '''Pascal'''-Programmiersprachenfamilie wird dies anhand des komplexen Datentyps &quot;Postadresse&quot; mit den sechs Attributen &quot;vorname&quot;, &quot;nachname&quot;, &quot;strasse&quot;, &quot;hausnummer&quot;, &quot;postleitzahl&quot; und &quot;ort&quot; dargestellt:

&lt;syntaxhighlight lang=&quot;Pascal&quot;&gt;
   (* Datentyp &quot;Postadresse&quot; *)
   TYPE Postadresse =
      RECORD
         vorname: ARRAY OF CHAR;
         nachname: ARRAY OF CHAR;
         strasse: ARRAY OF CHAR;
         hausnummer: ARRAY OF CHAR;
         postleitzahl: LONGINT;
         ort: ARRAY OF CHAR;
      END;
&lt;/syntaxhighlight&gt;

In den Deklarationen der Attribute steht &quot;ARRAY OF CHAR&quot; für den Datentyp Zeichenkette, der zur Speicherung von Zeichenfolgen verwendet wird. Der Datentyp &quot;LONGINT&quot; dient zur Speicherung ganzer Zahlen.

Eine Instanz &quot;adresse&quot; dieses Datentyps &quot;Postadresse&quot; kann wie folgt mit der NEW-Prozedur erzeugt werden, wobei der dafür erforderliche Speicherplatz festgelegt und für andere Verwendungen gesperrt wird. Auf die sechs einzelnen Datenfelder der in &quot;adresse&quot; gespeicherten sechs Attribute des Datentyps &quot;Postadresse&quot; kann danach im Programm mit den entsprechenden qualifizierten Bezeichnern beispielsweise zugegriffen werden, indem die jeweiligen initialen Werte mithilfe des Zuweisungsoperators := zugewiesen werden. Auf die Prozeduren &quot;String&quot; und &quot;Int&quot; aus dem Modul &quot;Out&quot; wird über &quot;Out.String&quot; und &quot;Out.Int&quot; ebenfalls qualifiziert zugegriffen:

&lt;syntaxhighlight lang=&quot;Pascal&quot;&gt;
   IMPORT
      Out; (* Import des Moduls &quot;Out&quot; mit den Textausgabe-Prozeduren &quot;String&quot; für Zeichenketten und &quot;Int&quot; für ganze Zahlen *)
   VAR
      adresse: Postadresse; (* globale Variable &quot;adresse&quot; *)
   BEGIN
      NEW (adresse);  (* Speicherreservierung für den Bezeichner &quot;adresse&quot; *)
      adresse.vorname := &quot;Irgend&quot;;
      adresse.nachname := &quot;Jemand&quot;;
      adresse.strasse := &quot;Allee&quot;;
      adresse.hausnummer := &quot;100&quot;;
      adresse.postleitzahl := 10000;
      adresse.ort := &quot;Irgendwo&quot;;

      Out.String (adresse.vorname);
      Out.String (adresse.nachname);
      Out.String (adresse.strasse);
      Out.String (adresse.hausnummer);
      Out.Int (adresse.postleitzahl);
      Out.String (adresse.ort);
   END;
&lt;/syntaxhighlight&gt;

In einem weiteren Beispiel mit der Syntax der Programmiersprache '''Java''' wird die Datenstruktur dieses komplexen Datentyps als Klasse &quot;Postadresse&quot; mit den sechs Instanzvariablen &quot;vorname&quot;, &quot;nachname&quot;, &quot;strasse&quot;, &quot;hausnummer&quot;, &quot;postleitzahl&quot; und &quot;ort&quot; für diese sechs Attribute gebildet. Eine Instanz dieses Datentyps kann hier mit dem new-Operator erzeugt werden. Der öffentliche Konstruktor &quot;Postadresse ()&quot; ist eine Methode mit derselben Bezeichnung wie die Klasse selbst, die aufgerufen werden muss, um die sechs Datenfelder der jeweiligen Instanz &quot;this&quot; zu initialisieren. Auf die einzelnen Datenfelder der in der nicht-öffentlichen Klassenvariable &quot;adresse&quot; gespeicherten sechs Attribute des Datentyps &quot;Postadresse&quot; kann danach über die entsprechenden sechs qualifizierten Bezeichner zugegriffen werden. In der Methode &quot;main&quot; werden die Attribute zwischen den runden Klammern über die qualifizierten Bezeichner als Parameter bei den Aufrufen der allgemeinen Textausgabe-Methode &quot;println&quot; verwendet, die zur Klassenvariable &quot;out&quot; der Klasse &quot;System&quot; im Programmpaket &quot;java.lang&quot; gehört:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
public class Postadresse // Klasse &quot;Postadresse&quot;
{
   // Instanzvariablen
   java.lang.String vorname;
   java.lang.String nachname;
   java.lang.String strasse;
   java.lang.String hausnummer;
   long postleitzahl;
   java.lang.String ort;

   private static Postadresse adresse = new Postadresse (); // Klassenvariable &quot;adresse&quot;

   public Postadresse () // Konstruktor der Klasse &quot;Postadresse&quot;
   {
      this.vorname = &quot;Irgend&quot;;
      this.nachname = &quot;Jemand&quot;;
      this.strasse = &quot;Allee&quot;;
      this.hausnummer = &quot;100&quot;;
      this.postleitzahl = 10000;
      this.ort = &quot;Irgendwo&quot;;
   }

   public static void main (java.lang.String [] argumente) // main-Methode der Klasse &quot;Postadresse&quot;
   {
      java.lang.System.out.println (adresse.vorname);
      java.lang.System.out.println (adresse.nachname);
      java.lang.System.out.println (adresse.strasse);
      java.lang.System.out.println (adresse.hausnummer);
      java.lang.System.out.println (adresse.postleitzahl);
      java.lang.System.out.println (adresse.ort);
   }
}
&lt;/syntaxhighlight&gt;

====Komplexe Anweisungen====
In der Programmiersprache Java kann die Gestaltung eines softwaretechnischen Containers &quot;host&quot; beispielsweise mit der Variablen &quot;layout&quot; realisiert werden. Hierzu werden Instanzen von Objekten der Klassen &quot;Container&quot; und &quot;GroupLayout&quot; erzeugt:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   java.awt.Container host = new java.awt.Container ();
   javax.swing.GroupLayout layout = new javax.swing.GroupLayout (host);
&lt;/syntaxhighlight&gt;

Eine multiple qualifizierte Bezeichnung zur Referenzierung von Datenfeldern mit diversen Aufrufen typengebundener Methoden (Unterprogramme) kann dann mit einer einzigen hyperkomplexen Anweisung in einer Zeile zusammengefasst werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   layout.setVerticalGroup (layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING).addGroup (layout.createSequentialGroup ().addContainerGap ().addGroup(layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING).addGroup (layout.createSequentialGroup().addGroup (layout.createParallelGroup (javax.swing.GroupLayout.Alignment.BASELINE))))));
&lt;/syntaxhighlight&gt;

Mit Zeilenumbrüchen wird der inhaltlich identische Quelltext schon besser nachvollziehbar:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   layout.setVerticalGroup
   (
      layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING)
      .addGroup (layout.createSequentialGroup ()
      .addContainerGap ()
      .addGroup (layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING)
      .addGroup (layout.createSequentialGroup()
      .addGroup (layout.createParallelGroup (javax.swing.GroupLayout.Alignment.BASELINE)))))
   );
&lt;/syntaxhighlight&gt;

Durch Verwendung von Hilfsvariablen mit sprechenden Bezeichnern wird der Quelltext zwar etwas länger, aber noch verständlicher. Die Komplexität ist deutlich reduziert, und die Anweisungsfolge kann viel einfacher nachvollzogen, überprüft oder angepasst werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
      javax.swing.GroupLayout.SequentialGroup sequentialGroup2 = layout.createSequentialGroup ();
      javax.swing.GroupLayout.ParallelGroup parallelBaselineGroup = layout.createParallelGroup (javax.swing.GroupLayout.Alignment.BASELINE);
      sequentialGroup2 = sequentialGroup2.addGroup (parallelBaselineGroup);

      javax.swing.GroupLayout.ParallelGroup parallelLeadingGroup2 = layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING);
      parallelLeadingGroup2 = parallelLeadingGroup2.addGroup (sequentialGroup2);

      javax.swing.GroupLayout.SequentialGroup sequentialGroup1 = layout.createSequentialGroup ();
      sequentialGroup1 = sequentialGroup1.addContainerGap ();
      sequentialGroup1 = sequentialGroup1.addGroup (parallelLeadingGroup2);

      javax.swing.GroupLayout.ParallelGroup parallelLeadingGroup1 = layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING);
      parallelLeadingGroup1 = parallelLeadingGroup1.addGroup (sequentialGroup1);

      layout.setVerticalGroup (parallelLeadingGroup1);
&lt;/syntaxhighlight&gt;

==Programmgestaltung==
Idealerweise kann die kontextfreie Grammatik der verwendeten Programmiersprache mit einer strukturierten Metasprache, wie zum Beispiel der '''Erweiterten Backus-Naur-Form''' ('''EBNF''') nach der Norm ISO/IEC 14977 dargestellt werden. Jedes strukturierte Programm und jede Datenstruktur kann damit eindeutig definiert werden. Leider trifft dies für viele Programmiersprachen nicht zu. Die Darstellung beliebiger ganzer Zahlen (sowohl negative, als auch positive und die Null) mit Zeichen kann in der Erweiterten Backus-Naur-Form zum Beispiel schrittweise so definiert werden:

&lt;syntaxhighlight lang=&quot;ebnf&quot;&gt;
 NatuerlicheZiffer = &quot;1&quot; | &quot;2&quot; | &quot;3&quot; | &quot;4&quot; | &quot;5&quot; | &quot;6&quot; | &quot;7&quot; | &quot;8&quot; | &quot;9&quot;;
 Ziffer = &quot;0&quot; | NatuerlicheZiffer;
 NatuerlicheZahl = NatuerlicheZiffer{Ziffer};
 GanzeZahl = &quot;0&quot; | [&quot;-&quot;]NatuerlicheZahl;
&lt;/syntaxhighlight&gt;

[[Datei:Nassi-Shneiderman diagram - InsertionSort.svg|mini|rechts|hochkant=2|Beispiel für einen Algorithmus mit zwei geschachtelten, kopfgesteuerten Schleifen in der Darstellung als Nassi-Shneidermann-Diagramm.]]

Programme können als '''Struktogramm''' (auch '''Nassi-Shneidermann-Diagramm genannt''') nach Norm DIN 66261 notiert werden. Alle Teilprogramme sind dabei so geartet, dass sie ausgehend von einem einfachen Hauptblock, der für das gesamte Programm und somit für mindestens einen Unterprogrammaufruf steht, durch schrittweise Verfeinerung hierarchisch zusammengesetzt werden können. Am Ende der Hierarchie stehen dann elementare Teilprogramme, die nicht weiter zerlegt werden können.

Die zyklomatische Komplexität der Software kann zum Beispiel mit der '''McCabe-Metrik''' untersucht und analysiert werden. Hierbei sollte darauf geachtet werden, dass die Komplexität beschränkt bleibt, damit der Quelltext überschaubar bleibt und gut nachvollzogen werden kann. Durch geeignete Strukturierung ist dies in modernen Programmiersprachen immer möglich, und mit einer McCabe-Metrik bis maximal 10 ist die Komplexität meist hinreichend niedrig.

Dies gilt nicht nur für den prozeduralen Programmablauf, sondern gleichermaßen für Datenstrukturen, bei denen komplexe Datentypen aus elementaren Datentypen übersichtlich und hierarchisch zusammengesetzt werden können.

Wichtig ist, dass die Anzahl der Programmzeilen ('''lines of code''') zwar gut als Maß für das zeitliche Wachstum einer bestimmten Software herangezogen werden kann, dies jedoch nicht geeignet ist, um eine Aussage über die Qualität oder Strukturiertheit des Programmcodes zu treffen. Weder eine besonders kleine noch eine besonders große Anzahl von Programmzeilen sind ein Garant für guten oder strukturierten Code.

Das Optimum ist nicht erreicht, wenn nichts mehr hinzugefügt werden kann, weil schon alles implementiert ist, sondern wenn nichts mehr entfernt werden kann, ohne dass die Implementierung hiervon beeinträchtigt wird (frei nach Antoine de Saint-Exupéry in ''Wind, Sand und Sterne - Terre des Hommes'' (1939)).

Programmieren ist nicht nur ein einfaches Handwerk, sondern eine anspruchsvolle Kunstfertigkeit (vergleiche auch Donald E. Knuth: ''The Art of Computer Programming'').
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

===Sichtbarkeiten===
Grundsätzlich gilt immer das '''Prinzip der Lokalität'''. Dies bedeutet, dass auf Programmkonstrukte nur dort zugegriffen werden kann und darf, wo es unbedingt erforderlich ist. Zum Datenaustausch zwischen verschiedenen Programmteilen dienen unter diesen Voraussetzungen Schnittstellen, die in der strukturierten Programmierung exakt definiert sein müssen.

Alle Klassenvariablen, Instanzvariablen und Parametervariablen sowie Rückgabewerte werden in Bezug auf ihre Teilprogramme zum Beispiel als '''lokale Variablen''' behandelt, so dass sie nur innerhalb dieser Teilprogramme aufgerufen und verändert werden können. Auf diese Weise können unbeabsichtigte und unerwünschte Seiteneffekte nachhaltig vermieden werden.

Je weniger lokal eine Variable definiert ist, desto größer ist die Gefahr, dass diese unbeabsichtigt oder sogar zuwider den Absichten des Programmierers verändert werden kann, was dann zu entsprechend dramatischen und schwer identifizierbaren Programmfehlern führen kann, die zudem erst zur Laufzeit auftreten und oft nur zufällig und somit umso schwerer zu entdecken sind. Variablen sollen also immer so '''lokal''' wie möglich definiert werden. Am besten sind Variablen lokalisiert, wenn sie innerhalb der Teilstruktur definiert werden, wo die Variablen üblicherweise „sichtbar” (und demzufolge verwendbar) sind. Außerhalb der Blöcke sind diese Variablen dann „unsichtbar” und somit auch nicht benutzbar.

Für Programmiersprachen die keine explizite Blockanweisung für Teilprogramme haben, ist die am stärksten lokalisierte Definition in der Regel innerhalb einer Methode respektive einer Prozedur oder einer Funktion. Die nächsthöhere Strukturebene ist dann - sofern möglich - das Modul beziehungsweise die Klasse (dies ist zwar häufig eine vom Compiler zu übersetzende Einheit, ist jedoch nicht unbedingt identisch mit einer Quelltextdatei). Innerhalb von Programmstrukturen sollten Variablen möglichst mit dem Sichtbarkeitsmodifikator für die ausschließlich interne Verwendbarkeit (zum Beispiel mit dem Modifikator ''private'' oder ''limited'') deklariert werden. Solche internen Variablen können dann gegebenenfalls mit entsprechend zu implementierenden Konstruktoren initialisiert, mit sogenannten Getter-Methoden abgefragt und mit Setter-Methoden verändert werden. Falls diese exportiert werden (beispielsweise mit dem Modifikator ''public'' oder ''export''), ist auch außerhalb der Deklarationsstruktur ein definierter indirekter Zugriff auf die internen Variablen möglich.

Manche Programmiersprachen erlauben eine Deklaration, die außerhalb des Deklarationsbereiches nur gesehen respektive gelesen werden können (zum Beispiel mit dem Modifikator ''read-only'' für Variablen oder ''implement-only'' für Methoden). In diesem Fall können die entsprechenden Variablen oder Methoden außerhalb der Deklarationsstruktur also nicht verändert, aber zumindest abgefragt oder aufgerufen werden.

'''Globale Variablen''', die überall innerhalb von großen Programmeinheiten verändert werden können, sind immer vermeidbar, erhöhen die Gefahr von Programmfehlern und erleichtern unter Umständen Cyber-Attacken.

Besondere Probleme ergeben sich, wenn innerhalb eines Sichtbarkeitsbereiches für verschiedene Dinge gleichlautende '''Bezeichner''' verwendet werden dürfen. Dies kann wegen der Wahlfreiheit bei der Benennung sehr leicht vermieden werden, indem einfach keine gleichlautenden Bezeichner benutzt werden. Im folgenden Beispiel wird verdeutlicht, wie in einem Java-Programm zwischen den Bezeichnern von lokalen und globalen Variablen sowie von Methoden formal dennoch eindeutig unterschieden werden kann:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
public class Bezeichner
{
	// globale Variable &quot;bezeichner&quot; (Klassenvariable)
	private static long bezeichner = 1;

	// Methode &quot;bezeichner&quot; (Unterprogramm)
	private static long bezeichner ()
	{
		// lokale Variable &quot;bezeichner&quot; in der Methode &quot;bezeichner&quot;
		long bezeichner = 3;
		return bezeichner;
	}

	// Hauptprogramm (Methode &quot;main&quot;)
	public static void main (java.lang.String [] argumente)
	{
		// Ausgabe der globalen Variable aus der Klasse &quot;Bezeichner&quot;
		java.lang.System.out.println (&quot;Wert der globalen Variable = &quot; + Bezeichner.bezeichner);

		// lokale Variable &quot;bezeichner&quot; in der Methode &quot;main&quot;
		long bezeichner = 2;
		// Ausgabe der lokalen Variable aus der Methode &quot;main&quot;
		java.lang.System.out.println (&quot;Wert der lokalen Variable = &quot; + bezeichner);

		// Ausgabe des Ergebnisses des Aufrufs der Methode &quot;bezeichner&quot;
		java.lang.System.out.println (&quot;Wert des Unterprogramms = &quot; + bezeichner ());
	}
}
&lt;/syntaxhighlight&gt;

In dieser Java-Klasse &quot;Bezeichner&quot; gibt es vier gleichlautende Bezeichner &quot;bezeichner&quot;:

* Der Name einer '''globalen Klassenvariable'''.
* Der Name einer '''Methode'''.
* Der Name einer '''lokalen Variable''' in der Methode &quot;bezeichner&quot;.
* Der Name einer '''lokalen Variable''' in der Methode &quot;main&quot;.

Nach den Regeln der Programmiersprache Java haben lokale Bezeichner bei der Referenzierung innerhalb einer Blockanweisung Vorrang, so dass bei der Verwendung dieser Bezeichner immer auf die lokale Variable zugegriffen wird. Im obigen Beispiel haben die beiden lokalen Variablen &quot;'''bezeichner'''&quot; nichts miteinander zu tun und können nur in ihrer entsprechenden Methode referenziert werden. Soll in einem lokalen Sichtbarkeitsbereich auf die globale Klassenvariable referenziert werden, so kann dies durch einen expliziten und '''qualifizierten Bezeichner''' erwirkt und sichergestellt werden, im obigen Beispiel mit &quot;'''Bezeichner.bezeichner'''&quot;. Der Bezeichner einer Methode kann durch das stets folgende runde Klammerpaar identifiziert werden, im obigen Beispiel &quot;'''bezeichner ()'''&quot;.

===Modularisierung===
Teilprogramme können Methoden oder ganze Sammlungen von Datenstrukturen und Methoden sein. Diese werden oft '''Klassen''' oder '''Module''' genannt und können in '''Paketen''' gruppiert werden. Alle Teilprogramme sollen eindeutige und sprechende Bezeichner und streng definierte Signaturen und Schnittstellen für die Namen und die Datentypen aller Parameter beziehungsweise Klassen- und Instanzvariablen haben. Bei diesen Teilprogrammen handelt es sich in der Regel um die kleinsten dauerhaft speicherbaren Programmeinheiten, die zum Beispiel in einer Datenbank oder einem Dateisystem zu größeren Einheiten wie Verzeichnissen, Paketen oder Bibliotheken zusammengefasst werden.

Solche Programmeinheiten werden durch ihre '''Signatur''' eindeutig gekennzeichnet. Die Signatur besteht zunächst aus dem '''Namen''' der Programmeinheit. Ferner kann mit einem Modifikator explizit definiert werden, dass diese Programmeinheit allgemein, also von allen und beliebigen anderen Programmeinheiten, verfügbar sein soll (Modifikator ''public'' / ''öffentlich''). Für eine Beschränkung nur auf die nächst höhere Programmeinheit, wie beispielsweise einem Paket (englisch &quot;package&quot;), kann der Modifikator ''private'' verwendet werden.

Eine typische Programmbibliothek hat in der Programmiersprache Java am Beispiel des Moduls &quot;java.base&quot; und der beiden Pakete &quot;java.io&quot; und &quot;java.lang&quot; folgende ausschnittsweise Struktur und Hierarchie:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
module java.base;

   package java.io;

      class Reader;
      {
         // Implementation der Klasse Reader
      }

      class Writer;
      {
         // Implementation der Klasse Writer
      }

   package java.lang;

      class String;
      {
         // Implementation der Klasse String
      }

      class System;
      {
         // Implementation der Klasse System
      }
&lt;/syntaxhighlight&gt;

===Methoden===
'''Methoden''' beziehungsweise '''Prozeduren''' werden ebenfalls durch ihre '''Signatur''' eindeutig deklariert, und alle Methodenaufrufe müssen sich streng an diese Deklaration halten. Die Signatur besteht zunächst aus dem '''Namen''' der Methode.

Methoden haben optional einen '''Rückgabewert''', für die der Datentyp ebenfalls festgelegt werden muss und der in streng strukturierten Programmiersprachen ebenfalls zur Signatur der Methode gehört und verwendet werden muss. Solche Methoden werden auch '''Funktionen''' genannt. Leider ist es in manchen Programmiersprachen erlaubt, Rückgabewerte von Funktionen einfach zu ignorieren und diese nicht in einer Variablen zu speichern oder im Rahmen eines Ausdrucks auszuwerten, da dies zu leicht zu übersehenden Programmierfehlern führen kann.

Ferner gibt es innerhalb der Signatur optionale '''Modifikatoren''', die die Regeln für die Sichtbarkeit (zum Beispiel ''öffentlich'' / ''privat'' / ''eingeschränkt'', englisch: ''public'' / ''private'' / ''limited'') festlegen.

Die Überschreibbarkeit einer Methode wird mit einem weiteren Modifikator festgelegt (wie zum Beispiel mit ''statisch'' / ''erweiterbar'' / ''abstrakt'' / ''abgeschlossen'', englisch: ''static'' / ''extensible'' / ''abstract'' / ''final'').

Methoden haben keinen, einen oder mehrere '''Parameter'''. Methoden ohne Parameter werden auch parameterlose Methoden genannt. Parameter sind innerhalb der Methode lokale Variablen, die beim Aufruf der Methode angegeben werden müssen und gegebenenfalls zusammen mit dem Rückgabewert die Schnittstelle für den Datenaustausch zum aufrufenden Programm darstellen. Die Anzahl, die Namen, die Datentypen und die Reihenfolge der '''Parameter''' gehören ebenfalls zur Signatur einer Methode. Beim Aufruf einer Methode müssen alle Parameter in der richtigen Reihenfolge und zuweisungskompatibel angegeben werden. Parameter können unterschieden werden in:

* '''Eingangsparameter''' ('''in'''), die als Wert (englisch ''value'') übergeben und nur innerhalb der Methode verwendet werden. Nach Beendigung des Methodenaufrufs sind sie ungültig und dürfen nicht weiterhin referenziert werden.
* '''Ausgangsparameter''' ('''out'''), die als Referenzen (Zeiger auf einen Speicherbereich, englisch ''pointer'') übergeben und deren Werte erst innerhalb der Methode ermittelt und zugewiesen werden. Nach Beendigung des Methodenaufrufs sind ihre Werte über die Referenzen abrufbar. Die referenzierten Speicherbereiche müssen vor dem Methodenaufruf allokiert worden sein, aber die Speicherinhalte müssen nicht festgelegt werden, da sie innerhalb der Methode nicht verwendet, sondern bestimmt und zugewiesen werden. Beim Programmieren ist große Sorgfalt darauf zu legen, dass die entsprechenden Zuweisungen innerhalb der Methode in jedem Fall erfolgen, falls die verwendete Programmiersprache dies nicht sowieso vorschreibt und erzwingt.
* '''Durchgangsparameter''' ('''var'''iable), die als Referenzen mit definierten Speicherinhalten übergeben, innerhalb der Methode verwendet und nach einer möglichen Veränderung (respektive '''Var'''iation) während des Methodenaufrufs weiterverwendet werden können. Nach Beendigung des Methodenaufrufs sind ihre aktuellen Werte in den aufrufenden Programmteilen über die Referenzen abrufbar.

===Grundlegende Anweisungen===
Grundsätzlich kommt die strukturierte Programmierung in imperativen Programmiersprachen mit folgenden grundlegenden Anweisungen aus:

* '''Deklaration''', zum Beispiel bei Klassen, Methoden, Variablen oder Konstanten mit einer eindeutigen Signatur:
** '''Modifikatoren''' für die Sichtbarkeit, Verwendbarkeit oder Veränderbarkeit
** '''Bezeichner'''
** Optional (bei Methoden, Funktionen, Prozeduren): '''Parameter''' mit Deklaration der Bezeichner, der Veränderbarkeiten und der Datentypen
** Optional (bei Funktionen): Datentyp des '''Rückgabewertes'''
* '''Blockanweisung''', zum Beispiel BEGIN ... END oder { ... }
* '''Zuweisung''', zum Beispiel a := b - c; (das Gleichheitseichen ist nicht zu verwechseln mit einem Vergleichsoperator)
* '''Aufruf von Unterprogrammen''':
** '''Kommandos''' (ohne Parameter und ohne Rückgabewert)
** '''Prozeduren''' oder Methoden (ohne Rückgabewert)
** '''Funktionen''' (mit Rückgabewert)
* '''Rückgabe''' bei Funktionen, zum Beispiel return x;

Anweisungen werden häufig durch ein reserviertes Zeichen abgeschlossen, wie zum Beispiel mit einem Semikolon.

Das folgende Beispiel zeigt eine Java-Klasse mit 15 grundlegenden Anweisungen:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
// Deklaration der oeffentlichen Klasse &quot;Anweisungen&quot;
public class Anweisungen
// Implementation der Klasse mit einer Blockanweisung &quot;{}&quot;
{	
	// Deklaration der privaten, globalen Klassenvariable &quot;flaeche&quot; vom Datentyp &quot;double&quot;
	private static double flaeche;

	// Deklaration der privaten statischen Methode &quot;kreisflaeche&quot; (Unterprogramm) zur Berechnung der Flaeche eines Kreises mit dem Radius &quot;radius&quot;
	// mit dem Parameter &quot;radius&quot; vom Datentyp &quot;double&quot;
	// und mit einer Gleitkommazahl vom Datentyp &quot;double&quot; als Rueckgabewert
	private static double kreisflaeche (double radius)
	// Implementation der Methode &quot;kreisflaeche&quot; mit einer Blockanweisung &quot;{}&quot;
	{
		// Deklaration der lokalen Variable &quot;ergebnis&quot; vom Datentyp &quot;double&quot;
		double ergebnis;

		// Zuweisung eines Ausdrucks an die Variable &quot;ergebnis&quot; mit dem Zuweisungsoperator &quot;=&quot;
		// Syntax: &quot;Variablenname Zuweisungsoperator Ausdruck Semikolon&quot;
		// Der arithmetische Ausdruck verwendet zwei Multiplikationsoperatoren &quot;*&quot;
		// Die Kreiszahl pi aus der Klasse &quot;java.lang.Math&quot; wird qualifiziert bezeichnet: &quot;java.lang.Math.PI&quot;
		ergebnis = java.lang.Math.PI * radius * radius;

		// Ruecksprunganweisung &quot;return&quot; mit der Rueckgabe der Gleitkommazahl &quot;ergebnis&quot;
		return ergebnis;
	}

	// Deklaration der oeffentlichen statischen Methode main (Hauptprogramm)
	public static void main (java.lang.String [] arguments)
	// Implementation der Methode &quot;main&quot; mit einer Blockanweisung &quot;{}&quot;
	{
		// Deklaration der lokalen Variable &quot;raddurchmesser&quot; vom Datentyp double
		double raddurchmesser;

		// Initialisierung der lokalen Variable &quot;raddurchmesser&quot; durch Zuweisung des konstanten arithmetischen Zahlenausdrucks &quot;1.5&quot;
		raddurchmesser = 1.5;

		// Aufruf der Methode &quot;kreisflaeche&quot; mit dem arithmetischen Ausdruck &quot;raddurchmesser / 2&quot; als Parameter
		// Der Rueckgabewert des Methodenaufrufs ist ein Ausdruck und wird der globalen Klassenvariablen &quot;flaeche&quot; zugewiesen
		flaeche = kreisflaeche (raddurchmesser / 2);

		// Aufruf der Methode &quot;println&quot; mit dem Parameter &quot;flaeche&quot; zur Ausgabe der berechneten Kreisflaeche
		// Die Methode aus der Klasse &quot;java.lang.System&quot; wird qualifiziert bezeichnet: &quot;java.lang.System.out.println&quot;
		java.lang.System.out.println (flaeche);
	}
}
&lt;/syntaxhighlight&gt;

Diese Anweisungen sind in der Reihenfolge des Auftretens:
# '''Deklaration''' der Klasse &quot;Anweisungen&quot;
# '''Blockanweisung''' zur Implementation der Klasse &quot;Anweisungen&quot;
# '''Deklaration''' der Klassenvariable &quot;flaeche&quot;
# '''Deklaration''' der Methode &quot;kreisflaeche&quot; (Unterprogramm)
# '''Blockanweisung''' zur Implementation der Methode &quot;kreisflaeche&quot;
# '''Deklaration''' einer lokalen Variable &quot;ergebnis&quot; in der Methode &quot;kreisflaeche&quot; 
# '''Zuweisung''' an die lokale Variable &quot;ergebnis&quot; in der Methode &quot;kreisflaeche&quot;
# '''Rücksprung''' vom Unterprogramm &quot;kreisflaeche&quot; zum Hauptprogramm &quot;main&quot;
# '''Deklaration''' der Methode &quot;main&quot; (Hauptprogramm)
# '''Blockanweisung''' zur Implementation der Methode &quot;main&quot;
# '''Deklaration''' der lokalen Variable &quot;raddurchmesser&quot;
# '''Zuweisung''' an die lokale Variable &quot;raddurchmesser&quot;
# '''Aufruf''' des Unterprogramms &quot;kreisflaeche&quot;
# '''Zuweisung''' an die globale Klassenvariable &quot;flaeche&quot;
# '''Aufruf''' des Unterprogramms &quot;println&quot;

===Anweisungsstrukturen===
Anweisungesstrukturen setzen sich aus mehreren Anweisungen zusammen. Eine Methode besteht zum Beispiel aus einer Deklaration mit der Definition der Schnittstelle, der unmittelbar eine Blockanweisung mit der Implementierung folgt.

Zu den weiteren elementaren Anweisungsstrukturen für Teilprogramme gehören:

* '''Anweisungsfolgen'''
* '''Kontrollstrukturen'''
** '''Fallunterscheidungen'''
*** bedingte Anweisungen (if - then)
*** einfache Verzweigungen (if - then - else)
*** mehrfache Verzweigungen (switch - case - else)
** '''Wiederholungen (Schleifen)'''
*** kopfgesteuerte Schleifen (while-Schleifen, for-Anweisungen)
*** fußgesteuerte Schleifen (repeat - until, do - while)

Bei jedem elementaren Teilprogramm (respektive jeder Methode, Prozedur oder Funktion, aber auch bei jeder Definition von Datenstrukturen) sollte der Quelltext bequem und vollständig auf einer Bildschirmseite gelesen werden können, ohne dass der Text im Betrachtungsfenster verschoben werden muss. Dabei empfiehlt es sich, Methodenaufrufe und übersichtliche Blockanweisungen zu verwenden, mit denen der Quellcode in Unterabschnitte gegliedert werden kann (Verfeinerung).

Im folgenden Beispiel werden drei geschachtelte Blockanweisungen durch jeweils ein Paar geschweifter Klammern begrenzt. Die äußersten Klammern dienen zur Begrenzung der Implementation der Methode &quot;printMonth&quot;, die inneren Blockanweisungen sind ebenso wie alle anderen Anweisungen nach rechts eingerückt:

 printMonth ()
 {
    const int NumberOfWeekdays ← 7
    const int LastDay ← 31
 
    int column
    int day ← 1
 
    while (day &lt;= LastDay)
    {
       printInt (day)
       column ← day modulo NumberOfWeekdays
       if (column = 0)
       {
          printLine ()
       }
       day ← day + 1
    }
 }

Wächst die Länge einer Methode zu sehr an, können und sollen einzelne Blockanweisungen unter Berücksichtigung der entsprechenden Übergabeparameter in eigene, aufzurufende Methoden ausgelagert werden, wodurch der Code geringfügig länger, aber wesentlich besser verständlich wird:

 optionalNewLine (int day)
 {
    const int NumberOfWeekdays ← 7
 
    int column ← day modulo NumberOfWeekdays
 
    if (column = 0)
    {
       printLine ()
    }
 }
 
 void printMonth ()
 {
    const int LastDay ← 31
    int day ← 1
 
    while (day &lt;= LastDay)
    {
       printInt (day)
       optionalNewLine (day)
       day ← day + 1
    }
 }

Hierbei ist es hilfreich, wenn die aufzurufenden Programmteile vor ihrer ersten Verwendung implementiert werden, im Quelltext also zuerst definiert (also deklariert und implementiert) und erst weiter unten benutzt (respektive aufgerufen oder referenziert) werden.

Häufig wird behauptet, dass die Performanz der ausgeführten Programme durch die Aufteilung in solche Unterprogramme leiden würde, da die zahlreichen Aufrufe und Rücksprünge Rechenzeit und Speicherressourcen kosten. In den allermeisten Fällen ist dies auf modernen Rechenmaschinen jedoch zu vernachlässigen. Bei den meisten Anwendungen wird am Speicherbedarf und an der Rechenzeit nicht bemerkt werden können, ob ein strukturiertes oder ein unstrukturiertes Programm vorliegt. Bestenfalls bei extrem rechenintensiven Aufgaben (wie zum Beispiel beim sogenannten &quot;number crunching&quot; (&quot;Zahlenfressen&quot;), bei Monte-Carlo-Simulationen oder Big-Data-Analysen) kann dies bei den extrem häufig aufgerufenen Unterprogrammen einen nennenswerten Effekt haben. Hierbei kann eine wohlstrukturierte Parallelisierung von Programmen oder die Ausgliederung von Rechenaufgaben in spezialisierte Hardware (Graphikprozessoren, digitale Signalprozessoren (DSP), Field Programmable Gate Arrays (FPGA) oder Quantencomputer) wesentlich zu einer Beschleunigung der Programmabläufe beitragen.

Eine Software, die von den Anwendern als zu langsam empfunden wird, ist meist nur schlecht programmiert. Ferner kann gar nicht häufig genug betont werden, dass die Entwicklung und Wartung unstrukturierter Programme erheblich länger dauert und wesentlich fehleranfälliger ist.

=== Schrittweise Verfeinerung ===
Die Implementierung von Software geschieht in der Regel vom Großen ins Kleine. Grob entworfene Anweisungsfolgen und Datenstrukturen werden dabei im Rahmen einer '''schrittweisen Verfeinerung''' immer genauer den Anforderungen angepasst.

Die folgenden Aspekte sind bei der schrittweisen Verfeinerung nach wie vor typisch:&lt;ref&gt;Niklaus Wirth: [http://sunnyday.mit.edu/16.355/wirth-refinement.html Program Development by Stepwise Refinement], Communications of the Association for Computing Machinery, Band 14, Nummer 4, April 1971, Seiten 221 bis 227&lt;/ref&gt;

* In jedem Schritt wird eine Aufgabe (ein Programmteil / ein Datensatz) in Unteraufgaben (in Unterprogramme / in Unterdatensätze) aufgeteilt.
* Der Grad der Abkapselung von Unteraufgaben bestimmt, wie leicht oder schwer Programme und Datenstrukturen angepasst oder übertragen werden können.
* Die Notation für Programme und Daten sollte stets so weit wie möglich sowohl der natürlichen Sprache und der Natur der Sache als auch der Hardware und den Software-Werkzeugen angepasst sein.
* Die Berücksichtigung der Kriterien Laufzeiteffizienz und Speichereffizienz sowie Klarheit und Regelmäßigkeit der Strukturen ist in allen Entwicklungsschritten bis zur Fertigstellung relevant.
* Es muss immer erwogen werden, dass ein korrekt funktionierendes Programm durch eine bessere Version ersetzt werden kann und dass frühere Entscheidungen aus allen Entwicklungsschritten revidiert werden können.
* Die Entwicklung und Wartung guter Programme ist alles andere als trivial, wird aber durch den Einsatz streng strukturierter Programmiersprachen deutlich erleichtert.

== Datenstrukturen ==
Nicht nur der Programmcode, sondern auch die zu verarbeitenden Daten müssen gut strukturiert werden, um die Entwicklungszeiten zu reduzieren, die Qualität der Programme zu erhöhen und die Wartung der Quelltexte zu erleichtern. Gehören zum Beispiel ganz verschiedene Attribute zu einer Sache, sollen diese Attribute zu einer Datenstruktur zusammengefasst werden. Datenstrukturen können auch geschachtelt eingesetzt werden, so dass sehr umfangreiche und komplexe Datenstrukturen abgebildet werden können.

===Aufzählungen===
Eine '''Aufzählung''' (englisch &quot;enumeration&quot;) wird verwendet, wenn bestimmte Eigenschaften von Datenstrukturen abzählbar und endlich sind. Mit diesen thematisch zusammengehörigen Aufzählungen können im Programmtext an allen entsprechenden Stellen statt abstrakt zugeordneter Zahlen konkret zugeordnete symbolische Konstanten mit sprechenden und selbsterklärenden Bezeichnern verwendet werden. Manche Programmiersprachen bieten dafür sogar die Möglichkeit an, dafür eigene Datentypen zu erstellen, in vielen Programmiersprachen wird das jedoch auf sehr simple Weise mit ganzzahligen Basisdaten nachgebildet.

Im folgenden Beispiel wird erläutert, wie verschiedene Kalendersysteme als Aufzählung behandelt werden können. Hierbei werden die folgenden vier Kalendersysteme zu Auswahl:
* Jüdisches Kalendersystem, Kennzahl = 1
* Julianisches Kalendersystem, Kennzahl = 2
* Gregorianisches Kalendersystem, Kennzahl = 3
* Islamisches Kalendersystem, Kennzahl = 4

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Kalendersystem
{
   public final static long JUEDISCH = 1; // Lunisolarkalender
   public final static long JULIANISCH = 2; // Solarkalender bis 4. Oktober 1582 (Donnerstag)
   public final static long GREGORIANISCH = 3; // Solarkalender seit 15. Oktober 1582 (Freitag)
   public final static long ISLAMISCH = 4; // Lunarkalender
}
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;oberon2&quot;&gt;
(* Programmiersprache Oberon *)

MODULE Kalendersystem;

   CONST
      JUEDISCH = 1; (* Lunisolarkalender *)
      JULIANISCH = 2; (* Solarkalender bis 4. Oktober 1582 (Donnerstag) *)
      GREGORIANISCH = 3; (* Solarkalender seit 15. Oktober 1582 (Freitag) *)
      ISLAMISCH = 4; (* Lunarkalender *)
&lt;/syntaxhighlight&gt;

In manchen, meist älteren Programmiersprachen gibt es explizite Aufzählungstypen, bei denen der Compiler automatisch die dazugehörigen ganzen Kennzahlen festlegt, ohne dass diese im Quelltext auftauchen, weil ausschließlich die symbolischen Konstanten aus der Deklaration des Aufzählungstyps verwendet werden. Variablen des Datentyps &quot;Kalendersystem&quot; im folgenden Beispiel dürfen nur die vier zwischen den runden Klammern explizit angegebenen respektive aufgezählten symbolischen Konstanten und keine beliebigen ganzen Zahlen verwenden:

&lt;syntaxhighlight lang=&quot;modula2&quot;&gt;
(* Programmiersprache Modula-2 *)

   TYPE Kalendersystem = (JUEDISCH, JULIANISCH, GREGORIANISCH, ISLAMISCH);
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;cpp&quot;&gt;
/* Programmiersprache C++ */

   enum Kalendersystem = {JUEDISCH, JULIANISCH, GREGORIANISCH, ISLAMISCH};
&lt;/syntaxhighlight&gt;

===Verbunde===
Gehören mehrere verschiede Attribute zu einer Datenstruktur, spricht man auch von einem '''Verbund'''. Diese Datenstrukturen werden je nach Programmiersprache häufig &quot;struct&quot; oder &quot;record&quot; genannt. Alle Attribute können und müssen über einen zentralen Zugang adressiert werden. Dies soll im Folgenden anhand der Datenstruktur &quot;Kalenderdatum&quot; beispielhaft erläutert werden.

Ein Kalenderdatum möge aus einem '''Tag''', einem '''Monat''', einem '''Jahr''' und einem '''Kalendersystem''' bestehen:

Alle vier Attribute werden in vier unabhängigen Datenfeldern gespeichert. Im vorliegenden Beispiel sind zwar alle vier Datenfelder vom Basisdatentyp &quot;ganze Zahl&quot; (&quot;long&quot; oder &quot;INTEGER&quot;), die Bedeutung und die gültige Zahlenbereiche unterscheiden sich jedoch:
* Tag: ganze Zahl im Intervall [1..31]
* Monat: ganze Zahl im Intervall [1..12]
* Jahr: ganze Zahl
* Kalendersystem. ganze Zahl des Aufzählungstyps &quot;Kalendersystem&quot; mit den vier Optionen (JUEDISCH, JULIANISCH, GREGORIANISCH, ISLAMISCH)

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Kalenderdatum
{
   // Instanzvariablen
   private long tag;
   private long monat;
   private long jahr;
   private long kalendersystem;

   public Kalenderdatum (long tag, long monat, long jahr, long kalendersystem) // Konstruktor zur Initialisierung von Instanzvariablen der Klasse Kalenderdatum
   {
      this.tag = tag;
      this.monat = monat;
      this.jahr = jahr;
      this.kalendersystem = kalendersystem;
   }

   public static void main (java.lang.String [] argumente) // main-Methode der Klasse &quot;Kalenderdatum&quot;
   {
      Kalenderdatum kalenderdatum = new Kalenderdatum (10, 4, 2023, Kalendersystem.GREGORIANISCH); // Eine neue Instanz wird erzeugt und durch den Aufruf des Konstruktors initialisiert
      java.lang.System.out.print (kalenderdatum.tag);
      java.lang.System.out.print (&quot;.&quot;);
      java.lang.System.out.print (kalendekalenderdatum.monat);
      java.lang.System.out.print (&quot;.&quot;);
      java.lang.System.out.print (kalenderdatum.jahr);
      java.lang.System.out.println (); // Zeilenumbruch
   }
}
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;oberon2&quot;&gt;
(* Programmiersprache Oberon *)

   IMPORT Out; (* Import des Moduls &quot;Out&quot; für die Textausgabe *)

   TYPE Kalenderdatum =
   RECORD
      tag: INTEGER;
      monat: INTEGER;
      jahr: INTEGER;
      kalendersystem: INTEGER;
   END;

   VAR kalenderdatum; (* Variable *)

   BEGIN
      kalenderdatum.tag = 10;
      kalenderdatum.monat = 4;
      kalenderdatum.jahr = 2023;
      kalenderdatum.kalendersystem = Kalendersystem.GREGORIANISCH;

      Out.Int (kalenderdatum.tag);
      Out.String (&quot;.&quot;);
      Out.Int (kalenderdatum.monat);
      Out.String (&quot;.&quot;);
      Out.Int (kalenderdatum.jahr);
      Out.Ln; (* Zeilenumbruch *)
   END;
&lt;/syntaxhighlight&gt;

Die Textausgabe lautet jeweils:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
23.4.2023
&lt;/syntaxhighlight&gt;

===Arrays===
In Arrays werden endlich viele und abzählbare Elemente eines bestimmten Datentyps in einer geordneten Reihe gespeichert. Die einzelnen Elemente können über einen ganzzahligen Index angesprochen werden. Der niedrigste Index ist meistens der Index Null, und dieser zeigt auf die erste Speicheradresse des Arrays. Da alle Elemente vom gleichen Datentyp sind, wird für jedes Element immer der gleiche Speicherplatz benötigt. Elemente mit komplexen Datentypen, werden nicht direkt im Array gespeichert, sondern dieses enthält als Verweise Zeiger mit den Speicheradressen der Inhalte der Elemente. Wenn der Speicherbedarf für ein Element (oder dessen Zeiger) &lt;math&gt;S_E&lt;/math&gt; Bytes beträgt und das Array insgesamt &lt;math&gt;N&lt;/math&gt; Elemente hat, dann berechnet sich der Speicherbedarf &lt;math&gt;S&lt;/math&gt; für das ganze Array aus dem Produkt:

&lt;math&gt;S = S_E \cdot N&lt;/math&gt;

Die Speicheradresse &lt;math&gt;A_i&lt;/math&gt; des i-ten Elements des Arrays berechnet sich dann mit einfacher und effizient ausführbarer Arithmetik aus der Speicheradresse des Arrays &lt;math&gt;A&lt;/math&gt;, dem Speicherbedarf für ein Element (oder dessen Zeiger) &lt;math&gt;S_E&lt;/math&gt; und dem Index &lt;math&gt;i&lt;/math&gt; :

&lt;math&gt;A_i = A + S_E \cdot i&lt;/math&gt; mit &lt;math&gt;0 \le i &lt; N&lt;/math&gt;

Die Speicheradresse des ersten Elements mit dem Index Null &lt;math&gt;A_0&lt;/math&gt; ist also stets identisch mit der Speicheradresse des Arrays &lt;math&gt;A&lt;/math&gt;.

Im folgenden Beispiel wird ein Array mit acht zufällig verteilten Gleitkommazahlen dargestellt, bei denen jede Gleitkommazahl einen Speicherplatz von '''8&amp;nbsp;Bytes''' (Datentyp '''double''' mit 64&amp;nbsp;Bits) belegt:

{| class=&quot;wikitable&quot;
|'''Länge des Arrays &lt;math&gt;N&lt;/math&gt;'''
|'''Speicheradresse des Arrays (dezimal) &lt;math&gt;A&lt;/math&gt;'''
|'''Speicheradresse des Arrays (hexadezimal) &lt;math&gt;A&lt;/math&gt;'''
|'''Speicherbedarf für eine Gleitkommazahl in Bytes &lt;math&gt;S_E&lt;/math&gt;'''
|-
|8
|10000000
|98 96 80
|8
|-
|'''Index &lt;math&gt;i&lt;/math&gt;'''
|'''Speicheradresse des Elements im Array (dezimal) &lt;math&gt;A_i = A + S_E \cdot i&lt;/math&gt;'''
|'''Speicheradresse des Elements im Array (hexadezimal) &lt;math&gt;A_i = A + S_E \cdot i&lt;/math&gt;'''
|'''Gespeicherter Inhalt des Elements (Gleitkommazahl)'''
|-
|0
|10000000
|98 96 80
|678,1495238
|-
|1
|10000008
|98 96 88
|317,4610959
|-
|2
|10000016
|98 96 90
|574,3131347
|-
|3
|10000024
|98 96 98
|673,9323679
|-
|4
|10000032
|98 96 A0
|854,6637912
|-
|5
|10000040
|98 96 A8
|764,4845853
|-
|6
|10000048
|98 96 B0
|335,5146962
|-
|7
|10000056
|98 96 B8
|545,0787382
|}

Das folgende Java-Programm implementiert ein solches Array mit acht Gleitkommazahlen:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Array
{
	
	// Klassenvariable zufallszahlen als Array mit acht Gleitkommazahlen
   private static double zufallszahlen [] = new double [8];

   public static void setzeZufallszahlen (long startwert) // Methode zur Bestimmung aller Gleitkommazahlen
   {
	   // Variable zufallszahl
	   java.util.Random zufallszahl = new java.util.Random (startwert); // Startwert für erste Zufallszahl

	   long anzahl = zufallszahlen.length;
	   int zaehler = 0; // der Index von Arrays darf nicht vom Datentyp long sein
	   while (zaehler &lt; anzahl)
	   {
		   zufallszahlen [zaehler] = zufallszahl.nextDouble ();
		   zaehler++;
	   }
   }

   public static void ausgabeZufallszahlen () // Methode zur Ausgabe aller Gleitkommazahlen
   {
	   long anzahl = zufallszahlen.length;
	   int zaehler = 0; // der Index von Arrays darf nicht vom Datentyp long sein
	   while (zaehler &lt; anzahl)
	   {
		   java.lang.System.out.println (zufallszahlen [zaehler]);
		   zaehler++;
	   }
   }

   public static void main (java.lang.String [] argumente) // Hauptprogramm &quot;main&quot; zum Aufruf der beiden Unterprogramme
   {
	   setzeZufallszahlen (1000); // Aufruf des Unterprogramms setzeZufallszahlen mit dem Parameter 1000 als Startwert
	   ausgabeZufallszahlen (); // Aufruf des Unterprogramms ausgabeMonatsname ohne Parameter
   }
}&lt;/syntaxhighlight&gt;

Mit dem Aufruf des Hauptprogramms ''main'' erfolgt die Ausgabe von acht Pseudozufallszahlen:

&lt;syntaxhighlight&gt;
0.7101849056320707
0.574836350385667
0.9464192094792073
0.039405954311386604
0.4864098780914311
0.4457367367074283
0.6008140654988429
0.550376169584217
&lt;/syntaxhighlight&gt;

Im nächsten Beispiel mit einem Array für die zwölf Monatsnamen ist der Datentyp eines Arrayelements jeweils eine Zeichenkette, die je nach ihrer Länge verschieden große Speicherbereiche belegen:

{| class=&quot;wikitable&quot;
|'''Länge des  Arrays'''
|'''Speicheradresse des Arrays'''
|'''Speicherbedarf für eine Speicheradresse'''
|'''Speicherbedarf für ein Zeichen'''
|
|
|-
|13
|10000000
|4
|2
|
|
|-
|Index
|'''Speicheradresse des Elements im Array'''
|'''Gespeicherter Inhalt des Elements (Speicheradresse)'''
|'''Länge der Zeichenkette'''
|'''Speicherbedarf der Zeichenkette'''
|'''Gespeicherter Inhalt des Elements (Zeichenkette)'''
|-
|0
|10000000
|20000000
|8
|16
|&quot;deutsch&quot;
|-
|1
|10000004
|20000016
|7
|14
|&quot;Januar&quot;
|-
|2
|10000008
|20000030
|8
|16
|&quot;Februar&quot;
|-
|3
|10000012
|20000046
|5
|10
|&quot;März&quot;
|-
|4
|10000016
|20000056
|6
|12
|&quot;April&quot;
|-
|5
|10000020
|20000068
|4
|8
|&quot;Mai&quot;
|-
|6
|10000024
|20000076
|5
|10
|&quot;Juni&quot;
|-
|7
|10000028
|20000086
|5
|10
|&quot;Juli&quot;
|-
|8
|10000032
|20000096
|7
|14
|&quot;August&quot;
|-
|9
|10000036
|20000110
|10
|20
|&quot;September&quot;
|-
|10
|10000040
|20000130
|8
|16
|&quot;Oktober&quot;
|-
|11
|10000044
|20000146
|9
|18
|&quot;November&quot;
|-
|12
|10000048
|20000164
|9
|18
|&quot;Dezember&quot;
|}

In den folgenden Beispielen in der Programmiersprache werden die zwölf Monatsnamen in Arrays mit Zeichenketten gespeichert. Hierzu wird die Sprache der Monatsnamen im ersten Arrayfeld mit dem Index 0 und die zwölf Monatsnamen in den folgenden Arrayfeldern mit den Indizes 1 bis 12 gespeichert:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Monatsnamen
{
   // Klassenvariable
   private static java.lang.String monatsnamen [] = {&quot;deutsch&quot;,
      &quot;Januar&quot;, &quot;Februar&quot;, &quot;März&quot;, &quot;April&quot;, &quot;Mai&quot;, &quot;Juni&quot;, &quot;Juli&quot;, &quot;August&quot;, &quot;September&quot;, &quot;Oktober&quot;, &quot;November&quot;, &quot;Dezember&quot;};

   public static void ausgabeMonatsname (int monat) // Methode zur Textausgabe von Monatsnamen
   {
      java.lang.System.out.println (monatsnamen [monat]);
   }

   public static void main (java.lang.String [] argumente) // Hauptprogramm &quot;main&quot; zum Aufruf der Methode ausgabeMonatsname
   {
      ausgabeMonatsname (1); // Aufruf des Unterprogramms ausgabeMonatsname mit dem Parameter 1
   }
}
&lt;/syntaxhighlight&gt;

Mit dem Aufruf des Hauptprogramms ''main'' erfolgt die Ausgabe mit dem ersten Monatsnamen:

&lt;syntaxhighlight&gt;
Januar
&lt;/syntaxhighlight&gt;

In einigen Programmiersprachen muss die Größe der Array vor der Initialisierung festgelegt werden, und die Zuordnung zwischen den Indizes und den Arrayfeldern ist dann auch bei der Initialisierung explizit erkennbar:

&lt;syntaxhighlight lang=&quot;oberon2&quot;&gt;
(* Programmiersprache Component Pascal *)

MODULE Monatsnamen;

   IMPORT Out; (* Import des Moduls &quot;Out&quot; für die Textausgabe *)

   TYPE Monatsnamen = POINTER TO ARRAY OF ARRAY OF CHAR;

   VAR monatsnamen: Monatsnamen;

   PROCEDURE InittialisiereMonatsnamen (); (* Prozedur zur Initialisierung von Monatsnamen *)
   BEGIN
      NEW (monatsnamen, 13, 10); (* Reservierung von 13 Zeichenketten mit je 10 Zeichen) *)
      monatsnamen [0] := &quot;deutsch&quot;;
      monatsnamen [1] := &quot;Januar&quot;;
      monatsnamen [2] := &quot;Februar&quot;;
      monatsnamen [3] := &quot;März&quot;;
      monatsnamen [4] := &quot;April&quot;;
      monatsnamen [5] := &quot;Mai&quot;;
      monatsnamen [6] := &quot;Juni&quot;;
      monatsnamen [7] := &quot;Juli&quot;;
      monatsnamen [8] := &quot;August&quot;;
      monatsnamen [9] := &quot;September&quot;;
      monatsnamen [10] := &quot;Oktober&quot;;
      monatsnamen [11] := &quot;November&quot;;
      monatsnamen [12] := &quot;Dezember&quot;;
   END InittialisiereMonatsnamen;

   PROCEDURE AusgabeMonatsname (monat: INTEGER); (* Prozedur zur Textausgabe von Monatsnamen *)
   BEGIN
      Out.String (monatsnamen [monat]);
   END AusgabeMonatsname;

   PROCEDURE Hauptprogramm*;
   BEGIN
      InittialisiereMonatsnamen (); (* Initialisierung beim Laden des Moduls &quot;Monatsnamen&quot; *)
      AusgabeMonatsname (1); (* Aufruf des Unterprogramms AusgabeMonatsname mit dem Parameter 1 *)
   END Hauptprogramm;

END Monatsnamen.
&lt;/syntaxhighlight&gt;

Durch den Aufruf von ''Monatsnamen.Hauptprogramm'' erfolgt die Ausgabe mit dem ersten Monatsnamen:

&lt;syntaxhighlight&gt;
Januar
&lt;/syntaxhighlight&gt;

Arrays können mehrdimensional gestaltet werden. Um zum Beispiel zwei Sprachen mit Monatsnamen zu speichern, kann eine weitere Dimension mit einem Index für die gewünschte Sprache implementiert werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Monatsnamen
{
   // Konstanten für Sprachaufzählung
   public final static int DEUTSCH = 0;
   public final static int ENGLISCH = 1;

   // Klassenvariablen
   private static java.lang.String monatsnamen [] [] =
   {
      {&quot;deutsch&quot;, &quot;Januar&quot;, &quot;Februar&quot;, &quot;März&quot;, &quot;April&quot;, &quot;Mai&quot;, &quot;Juni&quot;, &quot;Juli&quot;, &quot;August&quot;, &quot;September&quot;, &quot;Oktober&quot;, &quot;November&quot;, &quot;Dezember&quot;},
      {&quot;english&quot;, &quot;January&quot;, &quot;February&quot;, &quot;March&quot;, &quot;April&quot;, &quot;May&quot;, &quot;June&quot;, &quot;July&quot;, &quot;August&quot;, &quot;September&quot;, &quot;October&quot;, &quot;November&quot;, &quot;December&quot;}
   };

   public static void ausgabeMonatsname (int monat) // Methode zur Textausgabe von Monatsnamen
   {
      java.lang.System.out.println (&quot;Deutschsprachiger Monatsname = &quot; + monatsnamen [DEUTSCH] [monat]);
      java.lang.System.out.println (&quot;Englischsprachiger Monatsname = &quot; + monatsnamen [ENGLISCH] [monat]);
   }

   public static void main (java.lang.String [] argumente) // Hauptprogramm &quot;main&quot; zum Aufruf der Methode ausgabeMonatsname
   {
      ausgabeMonatsname (2);
   }
}
&lt;/syntaxhighlight&gt;

Mit dem Aufruf des Hauptprogramms ''main'' erfolgt die Ausgabe mit den beiden zweiten Monatsnamen:

&lt;syntaxhighlight&gt;
Deutschsprachiger Monatsname = Februar
Englischsprachiger Monatsname = February
&lt;/syntaxhighlight&gt;

Bei anderen Programmiersprachen ist durch die obligatorische Verwendung von symbolischen Konstanten (im Beispiel unten &quot;DEUTSCH&quot; und &quot;ENGLISCH&quot;) bei jeder erforderlichen, also auch bei allen initialen Zuweisungen zu Array-Elementen übersichtlich und klar erkennbar, welches Feld angesprochen wird:

&lt;syntaxhighlight lang=&quot;oberon2&quot;&gt;
(* Programmiersprache Component Pascal *)

MODULE Monatsnamen;

   IMPORT Out; (* Import des Moduls &quot;Out&quot; für die Textausgabe *)

   CONST
      DEUTSCH = 0;
      ENGLISCH = 1;

   TYPE Monatsnamen = POINTER TO ARRAY OF ARRAY OF ARRAY OF CHAR;

   VAR monatsnamen: Monatsnamen;

   PROCEDURE InittialisiereMonatsnamen ();  (* Prozedur zur Initialisierung von Monatsnamen *)
   BEGIN
      NEW (monatsnamen, 2, 13, 10); (* Reservierung von 2 mal 13 Zeichenketten mit je 10 Zeichen) *)
      monatsnamen [DEUTSCH, 0] := &quot;deutsch&quot;;
      monatsnamen [DEUTSCH, 1] := &quot;Januar&quot;;
      monatsnamen [DEUTSCH, 2] := &quot;Februar&quot;;
      monatsnamen [DEUTSCH, 3] := &quot;März&quot;;
      monatsnamen [DEUTSCH, 4] := &quot;April&quot;;
      monatsnamen [DEUTSCH, 5] := &quot;Mai&quot;;
      monatsnamen [DEUTSCH, 6] := &quot;Juni&quot;;
      monatsnamen [DEUTSCH, 7] := &quot;Juli&quot;;
      monatsnamen [DEUTSCH, 8] := &quot;August&quot;;
      monatsnamen [DEUTSCH, 9] := &quot;September&quot;;
      monatsnamen [DEUTSCH, 10] := &quot;Oktober&quot;;
      monatsnamen [DEUTSCH, 11] := &quot;November&quot;;
      monatsnamen [DEUTSCH, 12] := &quot;Dezember&quot;;

      monatsnamen [ENGLISCH, 0] := &quot;english&quot;;
      monatsnamen [ENGLISCH, 1] := &quot;January&quot;;
      monatsnamen [ENGLISCH, 2] := &quot;February&quot;;
      monatsnamen [ENGLISCH, 3] := &quot;March&quot;;
      monatsnamen [ENGLISCH, 4] := &quot;April&quot;;
      monatsnamen [ENGLISCH, 5] := &quot;May&quot;;
      monatsnamen [ENGLISCH, 6] := &quot;June&quot;;
      monatsnamen [ENGLISCH, 7] := &quot;July&quot;;
      monatsnamen [ENGLISCH, 8] := &quot;August&quot;;
      monatsnamen [ENGLISCH, 9] := &quot;September&quot;;
      monatsnamen [ENGLISCH, 10] := &quot;October&quot;;
      monatsnamen [ENGLISCH, 11] := &quot;November&quot;;
      monatsnamen [ENGLISCH, 12] := &quot;December&quot;;
   END InittialisiereMonatsnamen;

   PROCEDURE AusgabeMonatsname (monat: INTEGER); (* Prozedur zur Textausgabe von Monatsnamen *)
   BEGIN
      Out.String (&quot;Sprache = &quot; + monatsnamen [DEUTSCH, 0] + &quot;: &quot; + monatsnamen [DEUTSCH, monat]);
      Out.Ln;
      Out.String (&quot;Sprache = &quot; + monatsnamen [ENGLISCH, 0] + &quot;: &quot; + monatsnamen [ENGLISCH, monat]);
      Out.Ln;
   END AusgabeMonatsname;

   PROCEDURE Hauptprogramm*;
   BEGIN
      InittialisiereMonatsnamen (); (* Initialisierung beim Laden des Moduls &quot;Monatsnamen&quot; *)
      AusgabeMonatsname (2);
   END Hauptprogramm;

END Monatsnamen.
&lt;/syntaxhighlight&gt;

Durch den Aufruf von ''Monatsnamen.Hauptprogramm'' erfolgt die Ausgabe mit den beiden zweiten Monatsnamen:

&lt;syntaxhighlight&gt;
Sprache = deutsch: Februar
Sprache = english: February
&lt;/syntaxhighlight&gt;

Die Verwendung von Indizes außerhalb der deklarierten oder angeforderten Array-Größen verursachen in streng strukturierten Programmiersprachen zur Laufzeit einen Programmabbruch. Bei sorgfältiger Programmierung ist deswegen darauf zu achten, dass nur gültige Indizes zur Anwendung kommen können. In schlecht strukturierten Programmiersprachen wie C oder C++ werden die Indizes von Arrays in der Regel nicht automatisch geprüft, so dass unbemerkt auf ungültige Speicheradressen zugegriffen werden kann und bei entsprechenden Angriffen Daten verfälscht und schadhafter Binärcode in die Programme eingeschleust sowie zur Ausführung gebracht werden kann.

==Kontrollstrukturen==
Kontrollstrukturen dienen dazu, den Programmablauf in wohlstrukturierter Weise im Sinne eines Algorithmus zu beeinflussen. Hierfür können '''Unterprogramme''' aufgerufen, '''Fallunterscheidungen''' vorgenommen oder Programmteile mehrfach durchlaufen werden ('''Schleifen''').

===Sprunganweisungen===
Sprünge an andere Programmstellen ergeben sich inhärent beim Aufruf von Unterprogrammen. Geschieht ein solcher Sprung durch eine explizite Sprunganweisung im Programmcode, wie zum Beispiel mit Goto-, Break- oder Continue-Anweisungen, ist dies unstrukturiert und im Übrigen auch völlig überflüssig, denn Programme mit Sprunganweisungen können immer und ohne großen Aufwand durch Kontrollstrukturen, also mit Hilfe von '''Unterprogrammen''', '''Schleifen''' oder '''Fallunterscheidungen''', gestaltet werden.

Explizite Sprunganweisungen stellen eine &quot;Programmiertechnik mit dem Holzhammer&quot; und wegen der daraus resultierenden verschlungenen Pfade während des Programmablaufs einen sogenannten '''Spaghetti-Code''' dar. Im Quellcode ist der Programmablauf nicht mehr ohne weiteres nachvollziehbar, beispielsweise bei der Untersuchung, von welchen Stellen des Programms an welche anderen Stellen gesprungen werden soll oder worden sein kann.

Im Falle der Switch-Case-Anweisung handelt es sich bei der in manchen Programmiersprachen verwendeten Break-Anweisung eigentlich nicht um eine Sprunganweisung, sondern um einen obligatorischen Begrenzer (englisch: ''delimiter''), der zur Herstellung der Programmstruktur erforderlich ist. In einigen Programmiersprachen darf dieser Begrenzer (''break'') jedoch weggelassen werden, um den Code in bestimmten aber vereinzelten Fällen etwas kürzer gestalten zu können, was aber gleichzeitig und unabdingbar zu unstrukturierter Programmierung führt, die Programmabläufe unübersichtlich macht und dazu führen kann, dass die Programme gegebenenfalls nur noch schwierig nachzuvollziehen und zu warten sind.

====Unterprogramme====
[[Datei:Unterprogrammaufruf.png|mini|rechts|hochkant=1|Von der Hauptroutine &quot;Procedure main&quot; eines gestarteten Programms wird nach Ausführung der Anweisungen &quot;Instructions&amp;nbsp;1&quot; ein Unterprogramm &quot;Procedure sub&quot; aufgerufen (&quot;Call sub&quot;), und der Programmablauf wird mit den dortigen Anweisungen &quot;Instructions&quot; fortgeführt. Wenn die letzte Anweisung &quot;Return&quot; des Unterprogramms erreicht worden ist, wird in das Hauptprogramm zurückgesprungen und der Programmablauf an der Stelle direkt hinter dem Aufruf des Unterprogramms mit den Anweisungen &quot;Instructions&amp;nbsp;2&quot; fortgesetzt.]]

Eine besonders häufig angewendete Programmiertechnik ist der Aufruf von Unterprogrammen. Unterprogramme stellen im Sinne des Quelltextes eines Programmes üblicherweise Prozeduren, Methoden oder Funktionen dar. Mit der Programmanweisung des Aufrufs kann der Programmablauf zum entsprechenden Unterprogramm verzweigt werden. Hierbei können in der Regel auch Parameter übergeben werden, um zwischen dem aufrufenden Programmteil und dem Unterprogramm Daten austauschen zu können. Ist das Unterprogramm vollständig abgearbeitet worden, wird der Programmablauf hinter der Stelle des Unterprogrammaufrufs fortgesetzt.

Unterprogramme können mehrfach und von allen Stellen des Programcodes aufgerufen werden, in dem das Unterprogramm sichtbar ist. Die Unterscheidung zwischen Prozeduren und Methoden ist nicht einheitlich. Etliche Programmiersprachen verwenden kategorisch nur einen der beiden Begriffe. Hierbei kann zwischen traditionellen (statischen) Prozeduren und objektorientierten (typengebunden oder dynamischen) Prozeduren unterschieden werden. Letztere werden als Methoden einer Klasse oder aber auch als typengebundene Prozeduren eines Programmoduls bezeichnet.

====Rücksprunganweisungen====
Nach Ablauf des Unterprogramms kann ein Rückgabewert an das aufrufende Programm zurückgegeben werden, der im aufrufenden Programmteil dann zur Verfügung steht und als Ausdruck zum Beispiel an eine Variable zugewiesen werden kann. In diesem Fall wird ein Unterprogramm auch '''Funktion''' genannt, da als Ergebnis des Unterprogrammaufrufs ein Funktionswert berechnet wurde und dann zurückgegeben wird.

Jedes Unterprogramm hat daher exakt eine Rücksprunganweisung (oft mit dem Schlüsselwort '''return''' gekennzeichnet), die logischerweise die letzte Anweisung sein muss, damit alle Anweisungen vorher durchgeführt werden können. Der Rücksprung erfolgt immer zur Stelle des Unterprogrammaufrufs, wo die Programmausführung anschließend fortgeführt wird.

Hat das Unterprogramm keinen Rückgabewert, der an den aufrufenden Programmteil zurückgegeben werden muss, wird in vielen Programmiersprachen auf eine explizite Rücksprunganweisung verzichtet; in diesem Fall wird sie also implizit ausgeführt. Ist das Hauptprogramm vollständig durchlaufen, wird das Programm nach dessen Rücksprunganweisung beendet, und die Kontrolle an das Laufzeitsystem oder das Betriebssystem zurückgegeben, von wo aus das Hauptprogramm aufgerufen worden war.

Mehrfache und insbesondere vorzeitige Rücksprunganweisungen in einem Unterprogramm sind unstrukturiert und daher zu unterlassen, auch wenn die Programmiersprache dies nicht zwingend fordert. Vorzeitige Unterprogrammabbrüche ('''Break'''-Anweisungen) verhindern, dass nachfolgende Programmsequenzen ausgeführt werden können, obwohl sie bei einer Ausführung das Ergebnis für den Rückgabewert beeinflussen würden. Dies kann zur Verwirrung führen, weil das Unterprogramm bei einer Überprüfung oder einer Analyse immer vollständig auf potentielle vorzeitige Unterprogrammabbrüche durchsucht werden muss.

Der folgende unstrukturierte Java-Code, der den in der Variablen '''ergebnis''' gespeicherten Wert vor dessen Rückgabe als Text ausgeben soll, verdeutlicht dies:

&lt;syntaxhighlight lang=&quot;java&quot;&gt;
private static double unterprogramm (double parameter)
{
   double ergebnis = parameter;
   boolean ganzzahlig = (parameter % 1 == 0);
   if (ganzzahlig) return ergebnis;
   ergebnis = ergebnis + 1;
   java.lang.System.out.println (&quot;Ergebnis = &quot; + ergebnis);
   return ergebnis;
}
&lt;/syntaxhighlight&gt;

Die Erhöhung des Wertes der Variablen '''ergebnis''' sowie die Textausgabe mit dem Aufruf der Methode '''println''' unmittelbar vor der Rücksprunganweisung erfolgen wegen der beiden vorhandenen Rücksprunganweisungen nur, wenn der Wert des Parameters '''parameter''' nicht ganzzahlig ist. Demzufolge erzeugen die folgenden beiden Unterprogrammaufrufe

&lt;syntaxhighlight lang=&quot;java&quot;&gt;
   unterprogramm (0);
   unterprogramm (0.5);
&lt;/syntaxhighlight&gt;

die Textausgabe:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
Ergebnis = 1.5
&lt;/syntaxhighlight&gt;

Dieses formal korrekte, aber unerwünschte Verhalten wird nur nachvollziehbar, wenn der gesamte Code des Unterprogramms analysiert wird, was bei komplexeren Unterprogrammen und beim Vorhandensein mehrerer Rücksprunganweisungen sehr aufwendig werden kann..

Das folgende Unterprogramm implementiert den eigentlich gewünschten Algorithmus in strukturierter Form mit einer einzigen Rücksprunganweisung am Ende des Unterprogramms:

&lt;syntaxhighlight lang=&quot;java&quot;&gt;
private static double unterprogramm (double parameter)
{
   double ergebnis = parameter;
   boolean ganzzahlig = (parameter % 1 == 0);
   if (! ganzzahlig)
   {
      ergebnis = ergebnis + 1;
   }
   java.lang.System.out.println (&quot;Ergebnis = &quot; + ergebnis);
   return ergebnis;
}
&lt;/syntaxhighlight&gt;

Die Textausgabe bei den oben angegebenen  Aufrufen des Unterprogramms erfolgt nun wie gewünscht:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
Ergebnis = 0.0
Ergebnis = 1.5
&lt;/syntaxhighlight&gt;

Es empfiehlt sich grundsätzlich ebenfalls immer, innerhalb von Rücksprunganweisungen keine komplexen Ausdrücke, Kontrollstrukturen oder Unterprogrammaufrufe zu verwenden, um einfache und eindeutige Rückgabewerte zu erhalten sowie diese gegebenenfalls mit einer Textausgabe oder einem Debugger kontrollieren zu können. Im Idealfall wird in der Rücksprunganweisung nur der Wert einer zuvor berechneten lokalen Variable mit einem sprechenden Bezeichner zurückgegeben:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
   ergebnis ← f (a, b, c);
   return ergebnis;
&lt;/syntaxhighlight&gt;

In der Regel ergeben sich durch die zusätzliche explizite Zuweisung an die lokale Variable '''ergebnis''' keine Laufzeiteinbußen, da im übersetzten Maschinencode implizit für den Rückgabewert sowieso eine Zuweisung ausgeführt werden muss. Moderne Übersetzer berücksichtigen diesen Kontext automatisch, so dass in beiden Fällen derselbe Maschinencode erzeugt wird.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

===Fallunterscheidungen===
Die einfachste Fallunterscheidung ist die bedingte Anweisung. Verzweigungen enthalten mindestens zwei alternative Programmpfade.

====Bedingte Anweisung====
[[Datei:einfAusw.png|mini|rechts|hochkant=2|Struktogramm einer bedingten Anweisung.]]

Im folgenden Beispiel mit einer bedingten Anweisung (zum Beispiel if - then - end) wird die Dekrement-Anweisung a-- (der Wert der numerischen Variablen a soll um eins erniedrigt werden) nur dann ausgeführt, falls der boolesche Ausdruck a &gt; b wahr ist, die entsprechende Bedingung also erfüllt ist:

 falls a &gt; b dann a-- ende

Hier wird der Wert der Variablen a also nur dann dekrementiert, wenn der Wert der Variablen a größer ist als der Wert der Variable b. Ansonsten wird der Programmablauf sofort hinter der ende-Marke fortgeführt.

====Einfache Verzweigung====
[[Datei:zweifAusw.png|mini|rechts|hochkant=2|Struktogramm einer einfachen Verzweigung.]]

Die einfachste Verzweigung (zum Beispiel if - then - else - end) enthält genau zwei alternative Pfade, von denen in Abhängigkeit eines booleschen Ausdrucks nur einer ausgeführt wird, wie in diesem Beispiel:

 falls a &gt; b dann a-- ansonsten b-- ende

Je nachdem die entsprechende Bedingung erfüllt ist oder nicht, wird die eine oder die andere Anweisung ausgeführt. Im obigen Beispiel wird der Wert der Variablen a nur dann dekrementiert, falls der Wert der Variablen a größer ist als der Wert der Variable b, ansonsten wird hier im Vergleich zur bedingten Anweisung allerdings der Wert der Variablen b um eins erniedrigt. In beiden Fällen wird das Programm anschließend hinter der ende-Marke fortgeführt.

====Mehrfache Verzweigung====
[[Datei:Mehrseitige Auswahl.png|mini|rechts|hochkant=2|Struktogramm einer mehrfachen Verzweigung.]]

Eine mehrfache Verzweigung (zum Beispiel switch - case - else - end) enthält mehr als zwei alternative Programmpfade, die meist, wie auch im folgenden Beispiel, von ganzzahligen Ausdrücken gesteuert werden:

 verzweige mit dem Wert von a
    falls 1 : unterprogramm_A ()
    falls 2 : unterprogramm_B ()
    falls 3 : unterprogramm_C ()
    ansonsten unterprogramm_D ()
 ende

In Abhängigkeit des in der ganzzahligen Variablen a gespeicherten Zahlenwertes wird genau eines der vier angegebenen Unterprogramme aufgerufen; beim Wert 1 unterprogramm_A, beim Wert 2 unterprogramm_B, beim Wert 3 unterprogramm_C und ansonsten unterprogramm_D. Danach wird der Programmablauf hinter den ende-Marke fortgeführt.

In manchen weniger stakt strukturierten Programmiersprachen wie C sind Vorsicht und Aufmerksamkeit geboten, weil beispielsweise dort die verschiedenen Fälle der entsprechenden switch-Anweisung nur optional mit einer break-Anweisung und nicht immer und obligatorisch abgeschlossen werden. Dies nutzen einige Programmierer, um in bestimmten Situationen mehrere Fälle hintereinander abarbeiten zu lassen. Dieses Vorgehen ist jedoch hochgradig unstrukturiert und führt sehr schnell und unübersichtlichem Programmcode und somit sehr leicht zu Programmierfehlern. Dies kann vermieden werden, wenn in diesen Programmiersprachen hinter jedem unterschiedenem Fall kategorisch die break-Anweisung implementiert wird, auch wenn die Programmiersprache oder der Übersetzer dies nicht fordern.

[[Datei:MehrfAusw.png|mini|rechts|hochkant=2|Struktogramm mit verschachtelten einfachen Verzweigungen, um eine mehrfache Verzweigung zu implementieren.]]

Mehrfache Verzweigungen mit aufeinanderfolgenden numerischen oder aufzählbaren Werten, wie im obigen Beispiel 1, 2 und 3, können rechnerintern unter Umständen effizient genutzt werden, weil die Sprungadressen arithmetisch berechnet werden können. Dies ist bei modernen Laufzeitsystemen in der Regel aber nicht mehr so relevant, und diese mehrfachen Verzweigungen können auch immer durch mehrfache Fallunterscheidungen programmiert werden. Durch eine eigene Anweisung für die mehrfache Verzweigung kann die Übersichtlichkeit des Quelltextes allerdings oft gesteigert werden. Auf der anderen Seite können die Übersichtlichkeit und die Nachvollziehbarkeit in der Regel auch hier mit entsprechenden Unterprogrammaufrufen gesteigert werden.

===Schleifen===
Bei Schleifen wird eine Anweisungsfolge nur dann ausgeführt, wenn die entsprechende boolesche, im Sinne der Schleife lokale Laufvariable den Wert &quot;wahr&quot; hat. Alle Schleifen können auf eine grundlegende Form zurückgeführt werden, bei der ein wesentliches Merkmal ist, ob die Laufvariable '''zu Beginn''' der Schleifenanweisungen den initialen Wert &quot;wahr&quot; erhält (fußgesteuert) oder in der Anfangsbedingung durch einen variablen booleschen Ausdruck bestimmt ist (kopfgesteuert). Es ist sinnvoll, dass diese Laufvariable nur zum Zwischenspeichern der Abbruchbedingung dient und ausschließlich im Zusammenhang mit der Schleife verwendet wird.

Bei wohlstrukturierter Programmierung mit zählenden Schleifen können numerische Laufvariablen verwendet werden, die innerhalb der Schleife vorzugsweise erst in der letzten Anweisung der Schleife aktualisiert werden, damit es innerhalb des Schleifendurchlaufs nicht zu Inkonsistenzen, Verwechslungen oder Mehrdeutigkeiten kommen kann.

Ferner gibt es in der strukturierten Programmierung keine expliziten Sprunganweisungen, die irgendwo innerhalb einer Schleife zum Beispiel mit dem Kommando '''continue''' den Rest der Schleife überspringen und sofort die nächstfolgende Abbruchbedingung der Schleife prüfen lassen. Innerhalb von Schleifen ist es ohne Weiteres möglich, alle Zwischenschritte mit Verzweigungen zu steuern beziehungsweise alle Zwischenergebnisse in lokalen Variablen zu speichern, ohne dass es in modernen Computersystemen zu längeren Ausführungszeiten kommt.

Im Folgenden soll dies mit der Programmiersprache Java an sehr einfachen Schleifen, die alle Zahlen außer der Fünf von Eins bis Zehn ausgeben sollen, erläutert werden.

Unstrukturiertes Beispiel:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
long i = 1;
do
{
  if (i == 5)
  {
    i++; // Die Schleifenendanweisung zum Hochzaehlen der Laufvariable muss hier dupliziert werden, damit es nicht zu einer Fehlfunktion kommt.
    continue; // Die Schleife wird durch diese explizite Sprunganweisung unstrukturiert abgebrochen.
  }
  java.lang.System.out.println (i);
  i++;
} while (i &lt;= 10);
&lt;/syntaxhighlight&gt;

Strukturiertes Beispiel:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
long i = 1;
do
{
  if (i != 5)
  {
     java.lang.System.out.println (i);
  }
  i++;
} while (i &lt;= 10);
&lt;/syntaxhighlight&gt;

====Kopfgesteuerte Schleifen====
[[Datei:KopfgesteuerteSchleife.png|mini|rechts|hochkant=2|Struktogramm einer kopfgesteuerten Schleife.]]

Kopfgesteuerte Schleifen werden auch als '''While'''-Anweisungen bezeichnet.

{| class=&quot;wikitable&quot; style=&quot;text-align:center&quot;
| rowspan=&quot;4&quot; | Kopfgesteuerte Schleife
| colspan=&quot;2&quot; | Setze Laufvariable auf boolesche Anfangsbedingung
|-
| rowspan=&quot;3&quot; | Solange wie die Laufvariable den Wert &quot;wahr&quot; hat führe aus
|-
|Anweisungsfolge
|-
| Setze Laufvariable auf boolesche Endbedingung
|}

Wenn die boolesche Anfangsbedingung zu Beginn den Wert &quot;falsch&quot; hat, wird die Schleife '''nicht durchlaufen'''.

====Fußgesteuerte Schleifen====
[[Datei:FussgesteuerteSchleife.png|mini|rechts|hochkant=2|Struktogramm einer fußgesteuerten Schleife.]]

Die fußgesteuerte Schleife, die auch '''Repeat'''-Anweisung genannt wird, ist ein Sonderfall der kopfgesteuerten Schleife, bei der die boolesche Anfangsbedingung immer auf &quot;wahr&quot; gesetzt wird. Daher wird eine fußgesteuerte Schleife '''immer mindestens einmal durchlaufen'''.

{| class=&quot;wikitable&quot; style=&quot;text-align:center&quot;
| rowspan=&quot;4&quot; | Fußgesteuerte Schleife
| colspan=&quot;2&quot; | Setze Laufvariable auf &quot;wahr&quot;
|-
| rowspan=&quot;3&quot; | Solange wie die Laufvariable den Wert &quot;wahr&quot; hat führe aus
|-
|Anweisungsfolge
|-
| Setze Laufvariable auf boolesche Endbedingung
|}

Da der Ausdruck der booleschen Anfangs- und Endbedingung oft identisch formuliert ist, bietet es sich an, dafür einen Funktionsaufruf zu verwenden, um eine Codewiederholung zu vermeiden.

Aus Gründen der Laufzeiteffizienz wird das Setzen der Laufvariablen zu Beginn und die erstmalige Überprüfung der Laufvariablen oft weggelassen, was für die allermeisten Anwendungen heute jedoch unwesentlich ist. Da die Laufvariable in diesem Fall zu Beginn jedoch nicht definiert werden muss und daher gegebenenfalls auch gar nicht definiert wird, birgt dieses Vorgehen die Gefahr in sich, dass die Laufvariable ihren undefinierten Zustand behält. Insbesondere tritt dies ein, wenn das Setzen der Laufvariable auf eine boolesche Endbedingung nicht erfolgt, weil dies in der verwendeten Programmiersprache nicht obligatorisch ist beziehungsweise vom Programmierer vergessen wurde, oder weil dies wegen eines zwangsläufig unstrukturierten Abbruchs innerhalb der Schleife (zum Beispiel mit einer Break-Anweisung) gar nicht erfolgen kann.

====Endlosschleifen====
'''Endlosschleifen''' sind unstrukturiert, da das Programm nicht regelgerecht beendet werden kann. Daher sind diese sogenannten Loop-Anweisungen, wie zum Beispiel

 for (;;)
 {
    ...
 }

 while (true)
 {
    ...
 }

 repeat
 {
    ...
 }
 until (false)

beziehungsweise

 do
 {
    ...
 }
 while (true)

oder

 loop
 {
    ...
 }

zu unterlassen. Insbesondere das Verlassen von Endlosschleifen mit einer '''Sprunganweisung''' oder gar mehreren potentiellen Sprunganweisungen, wie zum Beispiel ''break'' oder ''exit'', ist hochgradig unstrukturierte Programmierung, da der Ausstiegszeitpunkt oder die Stelle des Ausstiegs aus der Schleife (wenn überhaupt) nur schwierig nachzuvollziehen oder zu bestimmen ist.

====For-Schleifen====
Die For-Schleifen-Anweisung

 int i
 for (i ← 0; i &lt; max; i++)
 {
  ...
 }

ist identisch mit der kopfgesteuerten while-Anweisung:

 int i
 i ← 0
 while (i &lt; max)
 {
  ...
  i = i + 1
 }

Es ist im Sinne eines einfachen Sprachumfangs und eines einheitlichen Sprachstils unter Umständen nützlich, für kopfgesteuerte Schleifen keine For-Schleifen, sondern ausschließlich While-Schleifen zu benutzen.

Wenn die Programmiersprache es erlaubt, Zählvariablen ausschließlich für eine Schleife zu definieren, dann hat dies den Vorteil, dass das Prinzip der Lokalität für diese Zählvariablen sehr gut erfüllt ist, da die Zählvariable dann außerhalb der Schleife nicht sichtbar ist und somit auch nicht verwendet werden kann:

 for (int i ← 0; i &lt; max; i++)
 {
  ...
 }

Die äquivalente Schreibweise mit einer while-Schleife sieht wie folgt aus, wobei die äußere Blockanweisung dafür sorgt, dass die Zählvariable &quot;i&quot; innerhalb der Blockanweisung deklariert ist und nur in Verbindung mit der Schleife sichtbar respektive verwendbar ist:

 {
    int i
    i ← 0
    while (i &lt; max)
    {
     ...
     i++
    }
 }

Bei Algorithmen, die aus mehreren Kontrollstrukturen bestehen, ist es im Sinne der besseren Strukturierung vorzuziehen, alle Schleifen in eigene Methoden auszulagern, die aufgerufen werden und deren Schnittstellen über ihre Parameter eindeutig festgelegt sind. Hierbei können die Schleifen verschachtelt sein (innere und äußere Schleife) oder hintereinander ausgeführt werden. In jedem Fall sind alle Parameter und Variablen (also auch die jeweiligen Zählvariablen) innerhalb der entsprechenden Methoden lokal verfügbar.

==Codewiederholungen==
Codewiederholungen gehören insbesondere bei Anfängern sehr häufig zu den kapitalen Fehlern beim Softwareentwurf. Es ist nur scheinbar bequem, bereits vorhandenen Quelltext zu kopieren und für eine ähnliche Aufgabe geringfügig anzupassen. Es ist Größenordnungen besser, den bereits vorhandenen Quelltext so anzupassen, dass er für alle ähnlichen oder zumindest mehrere ähnliche Aufgabenstellungen eingesetzt werden kann. Erfahrene Programmierer wittern schon von Anfang an, dass eine bestimmte Methode auch in einem ähnlichen Kontext eingesetzt werden könnte und entwerfen den Code von vornherein so allgemein wie möglich.

===Symbolische Konstanten===
Konstante Ausdrücke werden in der Regel als '''symbolische Konstanten''' definiert, wie zum Beispiel mit der symbolischen Konstante &quot;Pi&quot; für die Kreiszahl oder die symbolische Konstante &quot;Title&quot; für den Text &quot;Programmierung&quot;:

 const double Pi ← 3.141592654
 const String Title ← &quot;Programmierung&quot;

Statt konstante Ausdrücke zu wiederholen – und sei es nur eine ganze Zahl – ist es erheblich besser, stattdessen eine symbolische Konstante mit einem „sprechenden“ Bezeichner zu verwenden.

Also nicht mit der ganzen Zahl 3:

 int inputNumber ← 3
 ...
 if (inputNumber = 3) ...

Sondern besser mit der symbolischen Konstante &quot;Exit&quot; mit dem unveränderlichen, ganzzahligen Wert 3:

 const int Exit ← 3
 
 int inputNumber ← Exit
 ...
 if (inputNumber = Exit) ...

Oder nicht zweimal mit derselben ganzen Zahl 3:

 if (a &gt; 3) and (b &gt; 3) ...

Sondern besser mit zwei verschiedenen symbolischen Konstanten &quot;Limit_a&quot; und &quot;Limit_b&quot;:

 const int Limit_a ← 3
 const int Limit_b ← 3
 
 if (a &gt; Limit_a) and (b &gt; Limit_b) ...

Auf diese Weise kann auch leicht vermieden werden, dass gleichlautende Ausdrücke mit unterschiedlicher Bedeutung verwechselt werden können, insbesondere wenn sie später einmal geändert werden müssen:

 if (numberOfConstellation &gt; 12)
 {
    Ausgabe (&quot;Diese Sternbildnummer ist ungültig.&quot;)
 }
 
 if (numberOfHalftones &gt; 12)
 {
    Ausgabe (&quot;Das Intervall ist größer als eine Oktave.&quot;)
 }

Die beiden konstanten Zahlensymbole &quot;12&quot; haben nichts außer ihrem Zahlenwert gemeinsam, und daher ist der folgende Code erheblich besser nachvollziehbar:

 const int Number_Of_Constellations ← 12
 const int Number_Of_Halftones_Per_Octave ← 12
 
 ...
 
 if (numberOfConstellation &gt; Number_Of_Constellations)
 {
    Ausgabe (&quot;Diese Sternbildnummer ist ungültig.&quot;)
 }
 
 if (numberOfHalftones &gt; Number_Of_Halftones_Per_Octave)
 {
    Ausgabe (&quot;Das Intervall ist größer als eine Oktave.&quot;)
 }

===Aufruf von Unterprogrammen===
[[Datei:Aufruf.png|mini|rechts|hochkant=2|Struktogramm eines Unterprogrammaufrufs.]]

Unterprogramme, die in vielen Programmiersprachen auch Methoden, Prozeduren oder Funktionen genannt werden, beinhalten sequenzielle Rechenvorschriften (Algorithmen) zum Bearbeiten von Daten, die zu einer Einheit zusammengefasst sind.

So kann zum Beispiel die Rechenvorschrift für die Berechnung des Kreisumfangs aus dem Kreisradius als Folge von Programmanweisungen formuliert werden, aber auch in eine Methode ausgelagert werden. Dieses Unterprogramm kann dann irgendwo im Programmcode aufgerufen werden. Dies gewinnt besonders dann Bedeutung, wenn das Unterprogramm an verschiedenen Stellen aufgerufen werden soll, so dass dann diese Programmanweisungen nicht mehrfach programmiert oder kopiert werden müssen.

Insbesondere wenn die ursprünglichen, an mehreren Stellen auftauchenden Programmanweisungen einen Fehler enthalten, muss dieser nach dem Entdecken des Fehlers - also möglicherweise zu einem viel späteren Zeitpunkt - zur Fehlerbehebung zwangsweise an mehreren Stellen im Programmcode korrigiert werden. Das ist nicht nur mühsam, sondern einzelne relevante Stellen können leicht übersehen werden, so dass der entdeckte Fehler gar nicht vollständig ausgemerzt wird.

Die mehrfach eingegebenen Programmanweisungen zur Berechnung des Kreisumfangs werden beim Auftreten von '''Codewiederholung''' an drei Stellen des Quelltextes programmiert:

 const double Pi ← 3.141592654
 
 double perimeter1 ← radius1 * 2 * Pi
 double perimeter2 ← radius2 * 2 * Pi
 double perimeter3 ← radius3 * 2 * Pi

Mithilfe des im Unterprogramm &quot;perimeter&quot; nur einmal implementierten Algorithmus' zur Ermittlung des Kreisumfangs und dessen dreimaligem Aufruf kann die Wiederholung der Implementierung der Rechenvorschrift leicht vermieden werden:

 /* &quot;perimeter&quot; computes and returns the perimeter of a circle with radius &quot;radius&quot; */
 double perimeter (radius)
 {
    const double Pi ← 3.141592654
    double perimeter ← radius * 2 * Pi
    return perimeter
 }
 
 double perimeter1 ← perimeter (radius1)
 double perimeter2 ← perimeter (radius2)
 double perimeter3 ← perimeter (radius3)

==Zuweisungskompatibilität==
'''Zuweisungskompatibilität''' liegt vor, wenn Ausdrücke und Variablen aufgrund hinreichend kompatibler Datentypen einander zugewiesen, miteinander verglichen oder eindeutig miteinander verknüpft werden können.

Es kann bereits im Quelltext überprüft werden, ob eine hinreichende Zuweisungskompatibilität vorliegt. Liegt diese nicht vor, handelt es sich um eine Typverletzung, und es muss eine explizite Typumwandlung programmiert werden. In diesem Fall kann es sehr leicht zu Programmfehlern kommen.

Programmiersprachen, die für die maschinennahe Programmierung konzipiert wurden, wie zum Beispiel Assemblersprachen oder die Programmiersprache C, haben oft gar keine oder nur eine sehr schwache Typprüfung, was sehr leicht zu Programmfehlern führen kann.

In manchen Programmiersprachen, wie zum Beispiel C, ist es sogar erlaubt, beliebige Zeiger einer Zeigervariablen zuzuweisen, ohne dass geprüft wird oder überhaupt geprüft werden kann, ob die Datentypen der referenzierten Daten kompatibel sind.

===Zeichenketten===
Ein weiteres schwerwiegendes Problem kann sich bei der Verwendung von Zeichenketten (englisch: string) ergeben, die in der Regel zum Speichern von Texten Verwendung finden und die aus einer Sequenz von einzelnen Zeichen respektive Buchstaben (englisch: character) bestehen.

Eine strukturierte Programmiersprache, die Zeichenkettenverarbeitung und einen entsprechenden Datentyp zur Verfügung stellt, sollte fordern, dass jede Zeichenkette mit einem Zeichen abgeschlossen wird, das das Ende der Zeichenkette markiert (englisch: string terminator). Hierfür wird allgemein das Zeichen mit dem numerischen Wert null verwendet, das keinen Buchstaben repräsentiert und in Quelltexten häufig mit den Symbolen NUL, 0X oder \0 kodiert wird.

Manche unstrukturierte Programmiersprachen fordern nicht, dass eine solche Kennzeichnung des Endes der Zeichenkette verwendet werden muss. Bei der Implementation von Zeichenkettenfunktionen in Programmbibliotheken, insbesondere wenn die dazugehörige Programmiersprache gar keinen Datentyp für Zeichenketten zur Verfügung stellt, ist auch bei strukturierten Programmiersprachen nicht unbedingt gewährleistet, dass eine entsprechende Kennzeichnung des Zeichenkettenendes obligatorisch ist. Bei der Implementierung von Vergleichsfunktionen oder Zeichenkettenmanipulationen in unstrukturierten Programmiersprachen oder Programmbibliotheken muss die Tatsache, ob das Nullzeichen vorhanden ist oder nicht, regelmäßig untersucht und berücksichtigt werden. Einfacher und sicherer ist es, mit einer strukturierten Programmiersprache oder einer entsprechenden Programmbibliothek zu arbeiten, bei der immer gewährleistet ist und vorausgesetzt werden kann, dass alle Zeichenketten mit einem Endezeichen abgeschlossen sind.

===Strenge Zuweisungskompatibilität===
Zuweisungen sind uneingeschränkt zulässig, wenn eine strenge Zuweisungskompatibilität gegeben ist. Dazu müssen die Datentypen eines zuzuweisenden Ausdrucks und einer Variable exakt übereinstimmen, wie in folgendem Beispiel mit dem Datentyp &quot;Mann&quot; und den beiden Instanzen &quot;otto&quot; und &quot;emil&quot;:

 TYPE Mann = Verbund von alter und groesse
 
 VARIABLE otto, emil: Mann
 
 otto.alter   ← 50
 otto.groesse ← 1.80
 
 emil ← otto

Alle Attribute von „otto“, nämlich „alter“ und „groesse“, können „emil“ eindeutig zugewiesen werden.

Zwei Instanzen sind streng zuweisungskompatibel, wenn sie derselben Klasse angehören, wie in diesem Beispiel die beiden Objekte &quot;fenster1&quot; und &quot;fenster2&quot; aus der Klasse &quot;Rechteck&quot;:

 TYPE Rechteck = Klasse mit breite, hoehe und mit Methode flaechenberechnung&amp;nbsp;()
 
 VARIABLE fenster1, fenster2: Rechteck
 
 fenster1.breite ← 200
 fenster1.hoehe  ← 100
 fenster1.flaechenberechnung&amp;nbsp;() (Flächenberechnung für „fenster1“ ausführen)
 
 fenster2 ← fenster1
 fenster2.flaechenberechnung&amp;nbsp;() (Flächenberechnung für „fenster2“ ausführen)

Die Zuweisung in der vorletzten Programmzeile ist möglich, da beide Instanzvariablen &quot;fenster1&quot; und &quot;fenster2&quot; derselben Klasse &quot;Rechteck&quot; angehören, und daher liefert auch der Methodenaufruf in der letzten Programmzeile ein korrektes Ergebnis.

====Logische Kompatibilität====
Zwei übereinstimmende Definitionen von zwei Datentypen sind nicht zuweisungskompatibel. Die Daten können zwar eindeutig überführt werden (technische Kompatibilität), es liegen zwei formal zwar identische, aber dennoch verschiedene Definitionen vor, so dass diese keine logische Kompatibilität aufweisen. Folgendes Beispiel wäre demzufolge formal korrekt, aber nicht logisch:

 TYPE Mann = Verbund von alter und groesse
 TYPE Frau = Verbund von alter und groesse
 
 VARIABLE otto: Mann
 VARIABLE anna: Frau
 
 otto.alter   ← 50
 otto.groesse ← 1.80
 
 anna ← otto

Die Zuweisung in der letzten Programmzeile ist technisch zwar ohne Probleme möglich, aber logisch nicht korrekt, und sie birgt daher die Gefahr der Entstehung von Programmierfehlern. Um solche Fehler zu vermeiden, sind Zuweisungen mit impliziter Typumwandlung in einigen Programmiersprachen mit starker Typisierung nicht zulässig, und der Compiler verweigert die Übersetzung dieser Zuweisung.

In der objektorientierten Programmierung kann durch die Vererbung der gemeinsamen Eigenschaften von Datentypen leicht eine logische Kompatibilität hergestellt werden:

 TYPE Mensch = Verbund von alter und groesse
 
 TYPE Mann = Mensch
 TYPE Frau = Mensch
 
 VARIABLE otto: Mann
 VARIABLE anna: Frau
 
 otto.alter   ← 50
 otto.groesse ← 1.80
 
 anna ← otto

Die Objekteigenschaften &quot;alter&quot; und &quot;groesse&quot; sind hierbei Eigenschaften von Objekten des Datentyps &quot;Mensch&quot; und daher sowohl zuweisungskompatibel, als auch logisch korrekt; bei der Zuweisung können und werden nur die Attribute &quot;alter&quot; und &quot;groesse&quot; der gemeinsamen Basisklasse &quot;Mensch&quot; übertragen.

====Wahrheitswerte====
In einigen älteren Programmiersprachen, wie zum Beispiel C, gibt es keinen eigenen Datentyp für zweiwertige boolesche Variablen. Zur Behandlung und Verarbeitung entsprechender Information wird dann häufig der ganzzahlige Datentyp mit dem kleinsten Speicherbedarf verwendet, wobei der Zahlenwert null für den Wahrheitswert „Falsch“ und alle anderen Zahlenwerte für den Wahrheitswert „Wahr“ Verwendung finden. Auch hier ergeben sich logische Inkompatibilitäten und somit ein gefährliches Potential für Komplikationen, da mit binären Werten keine Arithmetik und mit Zahlen keine logischen Verknüpfungen oder logischen Operationen durchgeführt werden können. Im folgenden Beispiel wird dieser Missbrauch verdeutlicht:

 VARIABLE schlechteWahrheit1, schlechteWahrheit2, ergebnisWahrheit: INTEGER
 
 schlechteWahrheit1 ← 0
 schlechteWahrheit2 ← 1
 
 ergebnisWahrheit ← (schlechteWahrheit1 + schlechteWahrheit2)
 
 ergebnisWahrheit ← (schlechteWahrheit2 + schlechteWahrheit2)

Das Ergebnis der ersten arithmetischen Addition ist 1, was fälschlich als der Wahrheitswert „Wahr“ missinterpretiert werden könnte, der nicht dem Ergebnis der logischen Und-Verknüpfung entspricht. Noch offensichtlicher ist das Problem in der zweiten arithmetischen Addition, wo das Ergebnis 2 erzielt wird. Somit existieren ohne Not mehr als zwei Zustände für die binären (also zweiwertigen) Variablen, was schnell zu Missverständnissen und Programmierfehlern führen kann.

Eine eindeutige und korrekte Implementierung wird erreicht, wenn die Programmiersprache oder eine dazugehörige Programmbibliothek einen zweiwertigen Datentyp, wie zum Beispiel „BOOLEAN“ oder „bool“, zwei entsprechende Ausprägungen, wie zum Beispiel &quot;false&quot; und &quot;true&quot;, und die dazugehörigen eindeutigen booleschen Operatoren und Funktionen (beispielsweise &quot;and&quot;, &quot;or&quot; oder &quot;not&quot;) anbietet.

 VARIABLE richtigeWahrheit1, richtigeWahrheit2, ergebnisWahrheit: BOOLEAN
 
 richtigeWahrheit1 ← falsch
 richtigeWahrheit2 ← wahr
 
 ergebnisWahrheit ← (richtigeWahrheit1 und richtigeWahrheit2)
 
 ergebnisWahrheit ← (richtigeWahrheit2 und richtigeWahrheit2)

Sinngemäß gilt das Gleiche für die Verknüpfungen von Mengen. Wenn hier bei den Datentypen und zulässigen Operatoren nicht zwischen Bitmengen (englisch: (bit) sets) und Zahlen unterschieden wird, kommt es wie zum Beispiel bei der Bestimmung von Vereinigungs- oder Differenzmengen zu Interpretationsproblemen. Eine eindeutige und korrekte Implementierung verwendet Datentypen, die für Mengen und Mengenoperationen definiert sind. In einigen Programmiersprachen werden solche Datentypen im Sprachumfang implizit angeboten, in anderen gibt es dafür standardisierte Programmbibliotheken, auf die über Unterprogrammaufrufe zugegriffen werden kann.

===Zuweisungskompatibilität ohne Informationsverlust===
In einigen Fällen kann die Information, die mit einem Datentyp dargestellt werden kann, eindeutig und ohne Informationsverlust in einen anderen Datentyp überführt werden. Typische Beispiele sind ganze Zahlen mit unterschiedlicher Speichergröße. So kann ein Integer mit 16&amp;nbsp;Bit Speichergröße eindeutig in einer vorzeichenbehafteten Integer-Variablen mit 32&amp;nbsp;Bit Speichergröße abgelegt werden, ohne dass die ursprünglich nur mit 16&amp;nbsp;Bit gespeicherte Zahl verändert wird. Umgekehrt ist dies jedoch nicht allgemein möglich, insbesondere unter der Beachtung von Vorzeichen und großen Zahlen. Der folgende Programmierabschnitt zeigt ein Beispiel ohne Zuweisungskompatibilität, da der Datentyp „BYTE“ nur 8&amp;nbsp;Bit Speichertiefe hat und nur Werte zwischen -128 bis +127 und somit nicht die Zahl 555 repräsentieren kann, wohingegen der Datentyp „SHORTINT“ eine Speichertiefe von 16&amp;nbsp;Bit hat und ganze Zahlen von -32768 bis +32767 repräsentieren kann:

 zahl1: BYTE
 zahl2: SHORTINT
 
 zahl2 ← 555
 zahl1 ← zahl2

Die letzte Programmzeile stellt einen ungültigen Versuch der Zuweisung der ganzen Zahl&amp;nbsp;555 aus der Variablen „zahl2“ an die Variable „zahl1“ dar.

Bei einer solchen Programmanweisung kann bei typsicheren Programmiersprachen bereits der Compiler verhindern, dass ausführbarer Maschinencode erzeugt wird. Bei fehlender Überprüfung durch den Compiler kann unbemerkt Information verloren gehen, so dass bei nachfolgenden Berechnungen unter Umständen grobe Berechnungsfehler auftreten, die relativ schwierig zu analysieren sind.

===Zuweisungskompatibilität mit geringem Informationsverlust===
Ein Sonderfall ist die Zuweisung von ganzen Zahlen an Variablen, die Gleitkommazahlen repräsentieren. In der Regel kann ohne die Gefahr von Programmfehlern toleriert werden, große ganze Zahlen implizit in Gleitkommazahlen umzuwandeln, da der Rechenfehler (wenn überhaupt vorhanden) hierbei sehr klein ist. Auch dies kann an einem Beispiel verdeutlicht werden: ein „LONGINT“ mit 64&amp;nbsp;Bit Speichergröße kann die Zahl 9223372036854775807 mit 19 Dezimalstellen speichern. Der folgende Programmierabschnitt zeigt ein Beispiel mit Zuweisungskompatibilität mit einem in der Regel zu vernachlässigenden Informationsverlust, da der Datentyp „REAL“ nach IEEE 754 mit 64&amp;nbsp;Bit nur Zahlen mit einer Mantisse mit maximal 14 Nachkommastellen speichern kann:

 zahl1: LONGINT
 zahl2: REAL
 
 zahl1 ← 9223372036854775807
 zahl2 ← zahl1

Die letzte Anweisung stellt in fast allen Programmiersprachen einen gültigen Versuch der Zuweisung der ganzen Zahl&amp;nbsp;&lt;math&gt;{2}^{63} - 1&lt;/math&gt; aus der Variablen „zahl1“ an die Variable „zahl2“ dar, da diese gerundeten Zahlenwert &lt;math&gt;9{,}22337203685478 \cdot {10}^{18}&lt;/math&gt; enthält, und der Fehler durch das Abschneiden der letzten Nachkommastellen hier nur in einer Größenordnung von &lt;math&gt;{10}^{-14}&lt;/math&gt; liegt und daher für praktisch alle Anwendungen vernachlässigt werden kann.

Bei einer erneuten Datentypkonvertierung zurück zu einem geeigneten ganzzahligen Datentyp kommt es dann aber zu einer Abweichung zu der ursprünglichen ganzen Zahl. In solchen Fällen ist es daher besser, vorsichtshalber und mit Inkaufnahme etwas längerer Programmlaufzeiten ausschließlich mit Gleitkommazahlen zu operieren.

===Zuweisungskompatibilität mit definiertem Informationsverlust===
Zwei Instanzen sind mit definiertem Informationsverlust zuweisungskompatibel, wenn die zuzuweisende Klasse einer Klasse angehört, die von der zugewiesenen Klasse abgeleitet wurde. Alle Daten die in der zugewiesenen Klasse deklariert und somit erforderlich sind, können dann zugewiesen werden, jedoch werden die in der zuzuweisenden abgeleiteten Klasse möglicherweise hinzugefügten Attribute ignoriert, wie das folgende Beispiel verdeutlichen soll, in welchem der Datentyp „Mensch“ alle Eigenschaften vom Datentyp „Lebewesen“ erbt und zusätzlich das Attribut „intelligenzquotient“ bekommt:

 TYPE Lebewesen = Verbund von alter und gewicht
 
 TYPE Mensch = Lebewesen mit intelligenzquotient
 
 VARIABLE     otto: Mensch
 VARIABLE eukaryot: Lebewesen
 
 otto.alter               ← 50
 otto.gewicht             ← 75
 otto.intelligenzquotient ← 100
 
 eukaryot ← otto

Die Zuweisung in der letzten Zeile ist korrekt, das Attribut „intelligenzquotient“ der Variable „otto“ vom Datentyp „Mensch“ wird jedoch nicht an die Variable „eukaryot“ zugewiesen, da es beim Datentyp „Lebewesen“ der Basisklasse nicht deklariert ist.

==Komplexe Ausdrücke==
Zusammengesetzte Ausdrücke mit verschiedenartigen Operatoren können sehr unübersichtlich und somit fehleranfällig sein. Manche Programmiersprachen haben sehr viele Hierarchieebenen für Operatoren, die auch durch erfahrene Programmierer kaum durchschaut werden können, oder sogar dafür sorgen, dass bestimmte Teile des Quellcodes zur Laufzeit gar nicht erreicht werden können. Daher ist es dringend empfehlenswert, Anweisungen in kleine, überschaubare Einheiten zu untergliedern. In einigen Programmiersprachen ist es sogar möglich, die Zuweisung in andere Anweisungen zu integrieren, da sie selber als ein Ergebniswert interpretiert werden darf. Ferner ist nicht immer offensichtlich welchen Datentyp ein Ergebnis hat, was insbesondere in Ermangelung eines zweiwertigen Datentyps ''Boolean'' zu Missverständnissen führen kann.

Also zum Beispiel nicht:

 if (a ← b – c = 0) ...

In dieser bedingten Anweisung (if) ist nicht klar, in welcher Reihenfolge der Zuweisungsoperator (←), der Differenzoperator (-) und der Vergleichsoperator (=) ausgeführt werden (sollen). 

Es ist erheblich besser, die Anweisungen klar zu trennen:

 a ← (b – c)
 if (a = 0) ...

Die folgenden beiden Beispiele mit dem Zuweisungsoperator &quot;=&quot; und dem Vergleichsoperator &quot;==&quot; zeigen Programmsequenzen in der Programmiersprache C, die zu sehr leicht zu übersehenden Programmierfehlern führen können:

&lt;syntaxhighlight lang=&quot;C&quot;&gt;
 /* Programmiersprache C */
 int i = 0;
 if (i = 1)
 {
    /*
       Dieser Block wird immer ausgeführt,
       weil die Zuweisung i = 1 immer das numerische Ergebnis 1 hat,
       was als der boolesche Wert &quot;wahr&quot; interpretiert wird.
    */
 }
 
 int i = 0;
 if (i == 1)
 {
    /*
       Dieser Block wird nie ausgeführt,
       weil die Vergleichsoperation i == 1 immer das numerische Ergebnis 0 hat,
       was als der boolesche Wert &quot;falsch&quot; interpretiert wird.
    */
 }
&lt;/syntaxhighlight&gt;

Die folgende Rückgabe-Anweisung (&quot;return&quot;) in der Programmiersprache Java ist nicht nur verwirrend, sondern sinnfrei:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 2;
 long y = 1;
 return y + x--;
&lt;/syntaxhighlight&gt;

Der Dekrement-Operator &quot;- -&quot; wird in vielen Programmiersprachen gar nicht ausgeführt, weil er hierarchisch erst nach einer Zuweisung ausgeführt wird oder nach einer die Code-Sequenz beendende Return-Anweisung noch ausgeführt werden müsste, aber de facto gar nicht mehr ausgeführt wird. Deswegen ist die folgende Anweisungsfolge nicht nur weniger komplex, gut strukturiert und korrekt, sondern auch sinnvoll und leicht sowie eindeutig nachvollziehbar:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 2;
 long y = 1;
 x--;
 long summe = y + x;
 return summe;
&lt;/syntaxhighlight&gt;

Beeindruckend sinnlos, verwirrend und komplex sind Monster-Ausdrücke (nach Niklaus Wirth: ''notational monsters''), die in einigen Programmiersprachen wie zum Beispiel C erlaubt sind, wie zum Beispiel bei der Kombination einer Rücksprunganweisung (&quot;return&quot;) mit einer Zuweisung (&quot;=&quot;), zwei verschiedenen Inkrement-Operatoren (&quot;++&quot;) und einem Additionsoperator (&quot;+&quot;). Es ist sehr schwierig durchschaubar, in welcher Reihenfolge diese fünf Anweisungen ausgeführt werden und ob diese überhaupt ausgeführt werden. Selbst wenn die Zuweisung oder die nachrangige Inkrementierung ausgeführt würden, wären sie völlig sinnlos, da auf die lokale Variable i nach der Return-Anweisung gar nicht mehr zugegriffen werden kann:

&lt;syntaxhighlight lang=&quot;C&quot;&gt;
/* Programmiersprache C */
int i = 0;
return i = ++i+i++;
&lt;/syntaxhighlight&gt;

Auch im folgenden Java-Beispiel ist die Sachlage nicht wesentlich besser. Das Ergebnis dieser Anweisungsfolge für die Variable y ergibt den Wert 2 + 2 = 4 , weil der letzte Inkrementoperator die Variable x vor der Ausführung aller anderen Operatoren auf den Wert 2 erhöht, und der erste Inkrementoperator die Variable x erst nach der Addition und der Zuweisung auf den Wert 3 erhöht:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 1;
 long y = x++ + ++x;
&lt;/syntaxhighlight&gt;

Es ist ebenfalls nicht leicht zu durchschauen, dass das Ergebnis dieser Anweisungsfolge in Java für die Variable y den Wert 2 + 3 = 5 ergibt, weil die Variable x vor der Auswertung des arithmetischen Summe zweimal inkrementiert wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 1;
 long y = ++x + ++x;
&lt;/syntaxhighlight&gt;

Ferner ist das Ergebnis der nächsten Anweisungsfolge in Java für die Variable y der Wert 2 + 2 = 4, weil die Variable x vor der Auswertung der arithmetischen Summe nur beim ersten Inkrementoperator für die Summenbildung wirksam verändert wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 1;
 long y = ++x + x++;
&lt;/syntaxhighlight&gt;

Auf der anderen Seite ist das Ergebnis der nächsten Anweisungsfolge in Java für die Variable y der Wert 1 + 2 = 3, weil die Variable x während der Auswertung des arithmetischen Ausdrucks nur beim ersten Inkrementoperator für die Summenbildung wirksam verändert wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 1;
 long y = x++ + x++;
&lt;/syntaxhighlight&gt;

Noch gefährlicher wird es, wenn die Reihenfolge der Auswertung von arithmetischen Ausdrücken mit gleichwertigen Operanden für den Compiler oder Interpreter nicht definiert ist:

&lt;syntaxhighlight lang=&quot;C&quot;&gt;
/* Programmiersprache C */
 int x = 1;
 long y = ++x * --x;
&lt;/syntaxhighlight&gt;

Wird die Multiplikation von links nach rechts ausgewertet, ergibt sich für die Variable y der Wert 2, wird die Multiplikation von rechts nach links ausgewertet, ergibt sich für die Variable y der Wert 0. Derselbe Quelltext kann auf zwei verschiedenen Systemen also völlig andere Rechenergebnisse hervorrufen.

In anderen Programmiersprachen werden die Inkremente und Dekremente von ganzzahligen Variablen daher mit Prozeduraufrufen bewerkstelligt (beispielsweise INC() und DEC()), die fester Bestandteil der Programmiersprache sind, wie zum Beispiel in Pascal, wo der Zuweisungsoperator aus zwei verschiedenen Zeichen besteht (&quot;:=&quot;), damit es keine Verwechslungen mit einem Identitätsoperator oder Vergleichsoperator geben kann:

&lt;syntaxhighlight lang=&quot;pascal&quot;&gt;
(* Programmiersprache Pascal *)
 VAR
    x, y, produkt: integer;
 BEGIN
    x := 1;
    INC (x);
    y := x;
    DEC (x);
    produkt := y * x;
 END;
&lt;/syntaxhighlight&gt;

Die Aufrufe der Inkrement- beziehungsweise Dekrementprozeduren dürfen und können –&amp;nbsp; genauso wie Zuweisungen&amp;nbsp;– in der Programmiersprache Pascal also gar nicht Bestandteil eines arithmetischen Ausdrucks sein, so dass der Zeitpunkt der Ausführung immer eindeutig aus der Reihenfolge der Anweisungen hervorgeht.

===Ternäre Operatoren===
Ein '''ternärer Operator''' hat als Ergebnis einen beliebigen Wert und verknüpft hierzu drei Ausdrücke:

* Der erste Ausdruck ein '''binärer Ausdruck''', der wahr oder falsch ist.
* Der zweite Ausdruck beschreibt den Ergebniswert, wenn der erste Ausdruck '''wahr''' ist.
* Der dritte Ausdruck beschreibt den Ergebniswert, wenn der erste Ausdruck '''falsch''' ist.

In vielen Programmiersprachen werden die drei Ausdrücke mit den Begrenzungszeichen ? und : voneinander getrennt, und der binäre Ausdruck wird eingebettet in runde Klammern vorangestellt:

 (binärer Ausdruck) ? zweiter Ausdruck : dritter Ausdruck

Jeder dieser drei Ausdrücke kann sich wiederum aus mehreren anderen Ausdrücken zusammensetzen, so dass der Überblick schnell verloren gehen kann.

Die Ergebniswerte von Ausdrücken mit ternären Operatoren sollten besser nicht in andere Ausdrücke eingesetzt werden, sondern in einer lokalen Variable zwischengespeichert und erst danach weiterverwendet werden:

 variable ergebnis;
 ergebnis ← (binärer Ausdruck) ? zweiter Ausdruck : dritter Ausdruck

Grundsätzlich ist es wegen der größeren Übersichtlichkeit, Transparenz und einfacheren Modifikation vorzuziehen, für das Ergebnis gar '''keine ternären Operatoren''' zu verwenden, sondern eine '''bedingte Anweisung mit Blockanweisungen''' zu verwenden:

 variable ergebnis;
 falls (binärer Ausdruck)
 dann
    Block für ergebnis ← zweiter Ausdruck
 ansonsten
    Block für ergebnis ← dritter Ausdruck
 ende

===Blockanweisungen===
'''Blockanweisungen''' sind ein elegantes Mittel, um Programmcode zu strukturieren sowie die Sichtbarkeit von lokalen Variablen zu begrenzen. In vielen Programmiersprachen werden eindeutige Symbole für die Kennzeichnung von Programmblöcken verwendet, wie zum Beispiel geschweifte Klammern:

 {
    ...
 }

Die drei Punkte stehen hierbei für beliebige Anweisungsfolgen.

In anderen Programmiersprachen werden Schlüsselwörter für die Begrenzung von Blockanweisungen verwendet, wie zum Beispiel &quot;BEGIN&quot; und &quot;END&quot;:

 BEGIN
    ...
 END

Der Blockinhalt mit Anweisungen -&amp;nbsp;in beiden obenstehenden Beispielen durch die drei aufeinanderfolgenden Punkte symbolisiert&amp;nbsp;-, wird in der Regel eingerückt, um die Lesbarkeit des Quelltextes für die Programmierer zu erleichtern.

Blockanweisungen können geschachtelt, dürfen -&amp;nbsp;sofern in der Syntax einer Programmiersprache überhaupt möglich&amp;nbsp;- jedoch nicht verschränkt werden. Dies bedeutet, dass bei geschachtelten Blöcken ein begonnener Block immer erst vollständig abgearbeitet werden muss, bevor der nächstäußere weitergeführt und abgeschlossen werden kann:

 {
    ... /* Äußerer Block */
    {
       ... /* Mittlerer Block */
       {
          ... /* Innerer Block */
       }
       ... /* Mittlerer Block */
    }
    ... /* Äußerer Block */
 }

Verschränkte Blockanweisungen sind unsinnig, unstrukturiert sowie überflüssig und daher in den meisten Programmiersprachen nicht zulässig:

 BEGIN1
    ...
    BEGIN2
       ...
    ...
 END1
 ...   ...
    END2

Die Implementationen von allen Modulen, Klassen und Unterprogrammen sowie auch von allen Kontrollstrukturen (also Fallunterscheidungen und Schleifen) sollten '''kategorisch mit Blockanweisungen''' strukturiert werden.

=== Blockanweisungen bei Kontrollstrukturen ===
[[Datei:lineareAnw.png|mini|rechts|hochkant=2|Struktogramm einer Anweisungsfolge.]]

Auch wenn die Programmiersprache die Verwendung von Blockanweisungen für Anweisungsfolgen in einer Kontrollstruktur nicht vorschreibt, ist es sehr ratsam, die Blockanweisung kategorisch einzusetzen, um Programmierfehler zu vermeiden. Wenn zum Beispiel eine if-Anweisung so wie in den Programmiersprachen C und Java so strukturiert ist, dass genau eine Folgeanweisung ausgeführt wird, wenn die Bedingung wahr ist, kann es ohne Blockanweisungen bei der Programmentwicklung oder -wartung leicht zu übersehenden Programmierfehlern kommen. Im folgenden korrekt formulierten Java-Programmbeispiel wird die Variable v1 auf den Wert null zurückgesetzt, falls sie den gleichen Zahlenwert wie max hat:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
    v1 = 0;
&lt;/syntaxhighlight&gt;

Soll zudem auch noch eine Textausgabe erfolgen, kann diese zusätzlich programmiert werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
    v1 = 0;
    java.lang.System.out.println (&quot;Der Maximalwert wurde erreicht.&quot;);
&lt;/syntaxhighlight&gt;

Die unterste Programmierzeile ist zwar eingerückt, was suggeriert, dass sie nur ausgeführt wird, wenn die darüberstehende Bedingung erfüllt ist. Ein Java-Interpreter führt jedoch nur eine einzige unmittelbar nach der Bedingung aufgeführte Anweisung aus, wenn die Bedingung wahr ist. Mit anderen Worten: die Textausgabe erfolgt im obigen Programmbeispiel immer, also insbesondere auch wenn die Variablen v1 und max nicht den gleichen Zahlenwert haben. Im Quelltext sollte das daher besser folgendermaßen formuliert werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
    v1 = 0;
 java.lang.System.out.println (&quot;Der Maximalwert wurde erreicht.&quot;);
&lt;/syntaxhighlight&gt;

Ähnlich tückisch ist die Tatsache, dass in manchen weniger streng strukturierten Programmiersprachen, auf die Bedingung der if-Anweisung eine beliebige Anweisung folgen darf, die nicht notwendigerweise eine Blockanweisung sein muss, sondern auch eine einzelne Anweisung sein darf, die zum Beispiel mit einem Semikolon abgeschlossen wird und auch eine '''leere Anweisung''' sein kann. Dies führt zu leicht zu übersehenden Programmierfehlern, wie im folgenden Beispiel:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max);
 {
    v1 = 0;
    java.lang.System.out.println (&quot;Der Maximalwert wurde erreicht.&quot;);
 }
&lt;/syntaxhighlight&gt;

Die Blockanweisung wird immer ausgeführt, obwohl ihre Darstellung mit korrekter Einrückung suggeriert, dass sie nur dann ausgeführt wird, wenn die boolesche Bedingung (v1 == max) erfüllt ist. Dies ist allerdings nicht der Fall, da direkt hinter den runden Klammern der if-Anweisung ein Semikolon steht, welches eine '''leere Anweisung''' implementiert, die bei der Erfüllung der Bedingung ausgeführt wird.

All diese Missverständnisse können leicht vermieden werden, indem bei der Programmierung von Kontrollstrukturen '''kategorisch Blockanweisungen''' verwendet werden, selbst wenn die Programmiersprache dies nicht fordert:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
 {
    v1 = 0;
 }
&lt;/syntaxhighlight&gt;

Beziehungsweise:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
 {
    v1 = 0;
    java.lang.System.out.println (&quot;Der Maximalwert wurde erreicht.&quot;);
 }
 else
 {
    java.lang.System.out.println (&quot;Der Maximalwert wurde nicht erreicht.&quot;);
 }
&lt;/syntaxhighlight&gt;

==== Verschachtelung ====
In noch stärkerem Maße leidet die Verständlichkeit von Quellcode, wenn mehrere Kontrollstrukturen ohne die Verwendung von Blockstrukturen verschachtelt werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long v1, v2, v3;
 v1 = 3;
 v2 = 3;
 v3 = 7;
 if ((v1 &gt; 0) &amp;&amp; (v2 &gt; 0))
    if (v1 &gt; v2)
       v3 = v1 - v2;
 else
    v3 = v2 - v1;
 java.lang.System.out.println (&quot;v3 = &quot; + v3);
&lt;/syntaxhighlight&gt;

Beim Lesen des Quellcodes mit einer solchen &quot;baumelnden&quot; ''else''-Anweisung (englisch: ''dangling else'') kann schnell der Eindruck entstehen, dass sie zur ersten ''if''-Anweisung gehört und das Ergebnis für die Variable ''v3'' 7 bleibt, da ''v1'' und ''v2'' positive Zahlen sind. Tatsächlich wird der Quellcode jedoch so ausgeführt, so dass die Variable ''v3'' den Wert 0 erhält.

Um solche Missverständnisse zu vermeiden, ist es -&amp;nbsp;wie oben bereits erwähnt&amp;nbsp;- dringend geboten, Blockanweisungen kategorisch einzusetzen, auch wenn sie durch die Definition der Programmiersprache nicht sowieso vorgeschrieben sind:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long v1, v2, v3;
 v1 = 3;
 v2 = 3;
 v3 = 7;
 if ((v1 &gt; 0) &amp;&amp; (v2 &gt; 0))
 {
    if (v1 &gt; v2)
    {
       v3 = v1 - v2;
    }
    else
    {
       v3 = v2 - v1;
    }
 }
 java.lang.System.out.println (&quot;v3 = &quot; + v3);
&lt;/syntaxhighlight&gt;

==Wertebereiche==
===Division durch null===
Im Zusammenhang mit dem '''Divisionsoperator''' gibt es in allen Programmiersprachen das Problem, dass der Divisor nicht null werden darf.

Die Division durch null kann und sollte kategorisch durch eine geeignete Kontrollstruktur mit dem Vergleichsoperator &quot;&lt;&gt;&quot; verhindert werden, der nur bei Ungleichheit der beiden Operanden den Ergebniswert &quot;wahr&quot; erzeugt:

 if (divisor &lt;&gt; 0)
 {
    quotient ← dividend / divisor
 }
 else
 {
    /* Ausnahmebehandlung / Fehlermeldung */
 }

===Wertebereichsprüfung===
Bei Parametern mit eingeschränktem zulässigen Wertebereich kann eine allgemeine und an allen entsprechenden Stellen verwendbare Funktion programmiert werden, die den gültigen Wertebereich überprüft und einen entsprechenden (häufig zweiwertigen respektive booleschen) Funktionswert zurückgibt, wie zum Beispiel die folgende Funktion &quot;waterIsLiquid &quot;, die überprüft, ob die Wassertemperatur zwischen 0° und 100° Celsius liegt, bevor das spezifische Gewicht des Wassers berechnet werden darf:

 boolean waterIsLiquid (double temperature) /* temperature in degrees Celsius */
 {
    final long freezingPoint ← 0;
    final long boilingPoint  ← 100;
    boolean waterIsLiquid ← (temperature &gt; freezingPoint) and (temperature &lt; boilingPoint);
    return waterIsLiquid;
 }
 
 ...
 
 double temperature, density;
 
 ...
 
 if waterIsLiquid (temperature)
 {
    /* function computes an approximation of the density of air-free liquid water in kilograms per cubic metre */
    density ←
       (    999.83952
          + (16.945176 * temperature)
          - (0.0079870401 * temperature * temperature)
          - (0.000046170461 * temperature * temperature * temperature)
          + (0.00000010556302 * temperature * temperature * temperature * temperature)
          - (0.00000000028054253 * temperature * temperature * temperature * temperature * temperature)
       ) / ((0.01689785 * temperature) + 1);
 }
 else
 {
    /* exception handling, because water is not liquid */
 }

===Parameterkombinationen===
Es ist wichtig, dass immer alle auftretenden Parameterkombinationen berücksichtigt und vom Programmcode verarbeitet werden, wenn aus diesen Parametern valide berechnete Werte abgeleitet werden sollen.

Um zum Beispiel das Argument (also den Phasenwinkel zwischen -180° und +180°) einer komplexwertigen Zahl mit den reellwertigen Komponenten x und y über den Arcustangens (&quot;arctan&quot;) zu berechnen, muss geprüft werden, ob der Parameter x gleich null ist, und welche Vorzeichen die Parameter x und y haben:

 double x
 double y
 
 ...
 
 double argument
 
 if (x = 0)
 {
    if (y &gt; 0)
    {
       argument ← 90
    }
    elseif (y &lt; 0)
    {
       argument ← -90
    }
    else /* y is equal to 0, too */
    {
       stop /* argument is not defined */
    }
 }
 else /* x is not equal to 0 */
 {
    argument ← arctan (y / x)
    if (x &lt; 0)
    {
       if (y &gt;= 0)
       {
          argument ← argument + 180
       }
       else /* both, x and y are less than 0 */
       {
          argument ← argument - 180
       }
    }
 }

==Schnittstellen==
Schnittstellen definieren die Sichtbarkeits- und Zugriffsregeln zwischen verschiedenen Bestandteilen eines Programms und ermöglichen so die Interaktion zwischen diesen. Dabei ist es keineswegs sinnvoll, alle Bezeichner überall sichtbar zu machen, da dadurch die Übersichtlichkeit und Nachvollziehbarkeit insgesamt drastisch eingeschränkt wird. Dies führt letztlich zu Programmfehlern, da der Programmierer wegen der großen zu berücksichtigenden Datenmenge nicht mehr in der Lage ist, alle Implikationen seiner Arbeit zu überschauen.

Alle Eigenschaften (Attribute) und Methoden (Werkzeuge), die zusammengehören (aber auch nur diese), sollen in jeweils einer Einheit zusammengefasst werden, wie zum Beispiel einer Klasse oder einem Modul. Oft wird eine solche Einheit in einer Quelltextdatei zusammengefasst, was sinnvoll ist und die Nachvollziehbarkeit erleichtert.

Nur diejenigen Eigenschaften und Methoden, die außerhalb dieser Einheiten benutzt werden sollen oder müssen, dürfen mit einem Modifikator versehen werden, der dies ermöglicht (zum Beispiel &quot;public&quot;). Alle anderen Eigenschaften und Methoden sollten explizit als intern (zum Beispiel &quot;private&quot;) deklariert sein. ''packages'' sind wegen der unübersichtlichen Sichtbarkeitsregeln (zum Beispiel durch den Modifikator &quot;protected&quot;) als Zwischenebene entbehrlich und eher zu vermeiden. Alternativ können ohne weiteres längere, zusammengesetzte Klassennamen verwendet werden, um die Zugehörigkeit zu einem bestimmten Themenbereich zu kennzeichnen, wie zum Beispiel mit einfachen Bezeichnern:

 StatisticsMyEvaluation
 StatisticsMyAssessment

Diese Bezeichner sind in der Regel unmittelbar mit den Programmdateien im Dateisystem korreliert. Hierbei sind also keine '''qualifizierten Bezeichner''' auf verschiedene Konstrukte erforderlich, die hier im Beispiel aus mehreren Bezeichnern mit zwischengestellten Punkten zusammengesetzt sind. Links vom Punkt steht der Bezeichner der Programmbibliothek (Modulsammlung, Paket), und rechts vom Punkt steht der Bezeichner für ein Programmbaustein (Modul, Klasse):

 package statistics
 
 statistics.MyEvaluation
 statistics.MyAssessment

===Importe===
====Import-Anweisungen====
'''Import-Anweisungen''' werden häufig nicht dazu benutzt anzumelden und anzuzeigen, welche externen Module (respektive Klassen) in einer Quelldatei verwendet werden, sondern werden als Möglichkeit missbraucht, den Quelltext möglichst kurz zu fassen.

Nicht:

 import MyModule
 ...
 drawLine ()
 ...

Sondern eindeutig mit qualifiziertem Bezeichner:

 ...
 MyModule.drawLine ()
 ...

Mit diesen qualifizierten Bezeichnern ist es dann auch einfach und eindeutig möglich, gleichnamige Bezeichner, wie zum Beispiel für die Methode ''drawLine'', aus verschiedenen Klassen zu benutzen:

 ...
 MyModule.drawLine ()
 YourModule.drawLine ()
 ...

Die Erkennbarkeit der Herkunft eines importierten Bezeichners an jeder Stelle des Auftretens in einem Quelltext ist in der Regel von großer Nützlichkeit, insbesondere wenn andere Programmierer den Quelltext nachvollziehen können sollen oder wenn der Quellcode nach längerer Zeit gewartet werden soll.

Insbesondere Import-Anweisungen mit Wildcards sind schlecht nachvollziehbar (auch wenn viele Entwicklungssysteme Funktionen für eine gewisse Transparenz bieten), so wie zum Beispiel:

 import myPackage.*
 import yourPackage.*
 
 drawLine () /* To which package does the method &quot;drawLine&quot; belong? */
 
 Class var ← new Class () /* To which package does the class &quot;Class&quot; belong? */

====Zyklische Importe====
[[Datei:Zyklischer.Import.png|mini|rechts|hochkant=2|Zyklische Importe durch Aufruf (&quot;call&quot;) des Unterprogramms (&quot;procedure&quot;) '''sum''' aus der Klasse '''B''' in das Unterprogramm '''add''' der Klasse A sowie Aufruf des Unterprogramms '''add''' aus der Klasse '''A''' in das Unterprogramm '''sum''' der Klasse '''B'''.]] 

'''Zyklische Importe''' beziehungsweise Zirkelbezüge sind nicht nur unübersichtlich, sondern auch unstrukturiert und können zu Speicherüberläufen führen, da sich Programmteile immer wieder gegenseitig aufrufen, ohne beendet zu werden. Ferner kann die Funktion des übersetzten Programms bei einer Optimierung des Codes von der Reihenfolge der Übersetzung der Quelltexte abhängen. Die Schnittstellen der Klassen und Module können im Allgemeinen weder unabhängig voneinander noch eindeutig überprüft werden.

'''Beispiel''': Die beiden Funktionen Funktionen ''add'' aus der Klasse ''A'' und ''sum'' aus der Klasse ''B'' rufen sich endlos gegenseitig auf, um die Summe zweier Zahlenwerte zu berechnen, bis der Speicher überlaufen würde und das Laufzeitsystem die Ausführung deswegen abbricht oder der Speicher überläuft, das Programm unkontrolliert und ohne (nachvollziehbare) Fehlermeldung abstürzt.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

 public class A
 {
    public int procedure add (int a, int b)
    {
       int result ← B.sum (a, b);
       return result;
    }
 }

 public class B
 {
    public int procedure sum (int x, int y)
    {
       int result ← A.add (x, y);
       return result;
    }
 }

[[Datei:Circular Reference.svg|mini|rechts|hochkant=1|Variante von Abhängigkeiten zwischen Modulen oder Klassen, in denen die zyklischen Bezüge weniger offensichtlich sind, wenn nur der nächste Nachbar betrachtet wird. Der dunkelrote Pfeil oben rechts zeigt nach unten auf ein bereits vorher definiertes Element, das sich rechts in der Mitte befindet. Die Definition dieses Elements darf bei einem strukturierten Aufbau der Programmteile allerdings nicht von dem Element ober rechts abhängig sein.]]

Solche zyklischen Abhängigkeiten können durch Verzweigungen und indirekte Aufrufe wesentlich weniger offensichtlich sein, und sind dann nur sehr schwierig zu erkennen und zu beheben. Sichere Programmiersprachen überprüfen solche zyklischen Zusammenhänge daher und lassen sie nicht zu.

In der Regel ist es bei der Anwendung von rekursiven Programmiertechniken mit wohldefinierten Abbruchbedingungen möglich, ohne zyklische Modulabhängigkeiten auszukommen. Ein Übersetzer kann in den Metadaten von Programm-Modulen Zeitstempel verwenden, um bei der Interpretation eines Programmteils herausfinden zu können, ob alle anderen importierten Programmteile bereits vorher gültig übersetzt wurden.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Nebeneffekte==
'''Nebeneffekte''' treten auf, wenn der Programmierer von naheliegenden, jedoch falschen Annahmen ausgeht, die die Programmiersprache betreffen. Solche Nebeneffekte sind unerwünscht und können durch ein strukturiertes Vorgehen oft leicht vermieden werden.

===Durch arithmetischen Überlauf===
Als Indiz für solche Nebeneffekte möge folgendes Beispiel in Java dienen, bei dem die Dezimalzahl 127 (die hexadezimale Repräsentation dieses Zahlenwerts ist durch die acht Ziffern 7F gegeben) um eins erhöht wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 byte zahl = 127;
 java.lang.System.out.println (&quot;zahl = &quot; + zahl);
 zahl++;
 java.lang.System.out.println (&quot;zahl = &quot; + zahl);
&lt;/syntaxhighlight&gt;

Diese Anweisungsfolge erzeugt die Ausgabe:

:zahl = 127
:zahl = -128

Wenn die größte mit dem Datentyp &quot;byte&quot; darstellbare Zahl 127 mit dem Inkrement-Operator ++ um eins erhöht wird, ergibt sich durch arithmetischen Überlauf als Ergebnis die kleinste darstellbare ganze Zahl 128.

Dass solche Nebeneffekte auch in Standard-Bibliotheken versteckt sein können, möge das folgende Beispiel in Java zeigen, bei dem die Dezimalzahl -1 (die hexadezimale Repräsentation dieses Zahlenwerts ist durch die acht Ziffern FFFFFFFF gegeben) mit zwei verschiedenen Unterprogrammen ausgegeben werden soll (Stand 2026):

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 long zahl = 0xFFFFFFFF;
 java.lang.System.out.println (&quot;dezimal: &quot; + zahl);
 java.lang.System.out.print (&quot;hexadezimal: &quot;);
 java.lang.System.out.printf (&quot;%h\n&quot;, zahl);
&lt;/syntaxhighlight&gt;

Diese Anweisungsfolge erzeugt die Ausgabe:

:dezimal: -1
:hexadezimal: 0

Die Methode &quot;printf&quot; für die Ausgabe im hexadezimalen Format (Steuersequenz h%), ruft die statische Methode &quot;formatUnsignedLong0&quot; aus der Klasse &quot;Long&quot; aus dem package &quot;java.lang&quot; im Modul &quot;java.base&quot; der Java-Standardbibliothek auf und gibt den Wert 0 aus, obwohl der korrekte hexadezimale Wert FFFFFFFF lautet. Der Fehler entsteht bei der internen Berechnung, bei der es einen arithmetischen Überlauf gibt, der nicht explizit abgefangen wird.

===Durch Rundung===
Manchmal ist es schwierig zu erkennen, dass das Ergebnis einer Operation nicht dem exakten Ergebnis entspricht, das mathematisch zu erwarten wäre, weil es Rundungsfehler gibt. Gleitkommazahlen können nicht mit beliebig hoher Präzision gespeichert werden, und daher können sich dadurch solche Rundungsfehler auch mit einer völlig unerwarteten Wirkung ergeben. Hier ein Beispiel in der Programmiersprache Java für ein System mit einer Speichertiefe von 64 Bit:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 double a = 4.4;
 double b = 3.3;
 java.lang.System.out.println (a - b);
&lt;/syntaxhighlight&gt;

Die Ausgabe lautet nicht &quot;1.1&quot; wie zu erwarten wäre, sondern:

:1.1000000000000005

Noch schwieriger ist es, wenn das Kommutativ-, das Distributiv- oder das Assoziativgesetz nicht zu gelten scheinen, wie in diesem Beispiel, bei dem die Variable &quot;b&quot; einmal zur Variable &quot;a&quot; und einmal zur Variable &quot;c&quot; assoziiert ist:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 double a = 4.4;
 double b = 3.3;
 double c = 1.1;
 java.lang.System.out.println ((a - b) - c);
 java.lang.System.out.println (a - (b + c));
&lt;/syntaxhighlight&gt;

Mathematisch kommt in beiden Fällen exakt der Wert null heraus, die Ausgabe lautet jedoch:

:4.440892098500626E-16
:0.0

Die Wirkung von derartigen Nebeneffekten sind nur sehr schwierig zu beherrschen, und daher sollte beim Vergleichen von Gleitkommawerten die Präzision respektive die Maschinengenauigkeit der gespeicherten Werte berücksichtigt werden. Manche Programmiersprachen stellen hierfür einen Wert für die kleineste relative Genauigkeit von Gleitkommazahlen &lt;math&gt;\epsilon&lt;/math&gt; (epsilon) zur Verfügung. Das folgende Beispiel für den Datentyp double mit 64 Bit Speichertiefe nach dem Standard IEEE 754 in der Programmiersprache Java mit einem Wert für &lt;math&gt;\epsilon = 10^{-15}&lt;/math&gt; nach der Formel:

:&lt;math&gt;\Bigg| {\frac {differenzBerechnet - differenzErwartet} {differenzErwartet}} \Bigg| &lt; \epsilon&lt;/math&gt;

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 double a = 4.4;
 double b = 3.3;
 double differenzBerechnet = a - b;
 double differenzErwartet = 1.1;

 boolean gleichheit1 = (differenzBerechnet == differenzErwartet);
 java.lang.System.out.println (gleichheit1);

 double epsilon = 1.0E-15;
 boolean gleichheit2 = java.lang.Math.abs ((differenzBerechnet - differenzErwartet) / differenzErwartet) &lt; epsilon;
 java.lang.System.out.println (gleichheit2);
&lt;/syntaxhighlight&gt;

Die Ausgabe lautet hier:

:false
:true

===Durch Reihenfolge===
In einigen Programmiersprachen ist die Reihenfolge der Abarbeitung von kombinierten Ausdrücken nicht explizit definiert und führt daher zu einem solchen Nebeneffekt.

Die Anweisungen

 h ← f (x) + g (x)

oder

 h ← g (x) + f (x)

können je nach Compiler zu unterschiedlichen Ergebnissen für die Summe h führen. Die Methodenaufrufe f oder g können nämlich unter Umständen die als Parameter verwendete (lokale) Variable x verändern und somit gegebenenfalls verschiedene Werte für h erzeugen, je nachdem, ob zuerst f&amp;nbsp;(x) oder g&amp;nbsp;(x) ausgewertet wird. In solchen Programmiersprachen sind sogenannte Durchgangsparameter in kombinierten Ausdrücken zu vermeiden.

Ferner ist es denkbar, dass durch den ersten Funktionsaufruf globale Variablen oder Instanzen verändert und beim zweiten Funktionsaufruf verwendet werden.

Die erwünschte Reihenfolge von Funktionsaufrufen kann leicht durch entsprechende Code-Sequenzen mit sequentiellen Anweisungen erzwungen werden:

 result_f ← f (x)
 result_g ← g (x)
 h ← result_f + result_g

Dieses Vorgehen erzeugt darüberhinaus den günstigen Umstand, dass die Zwischenergebnisse in lokalen Variablen gespeichert und somit abgefragt werden können. Diese sind nach einem Programmabbruch dann auch mit einem Post-Mortem-Debugger analysierbar.

===Durch Kombination von Operatoren===
Manche Programmiersprachen -&amp;nbsp;insbesondere in der C-Sprachfamilie&amp;nbsp;- erlauben die Kombination von Zuweisungsoperatoren und arithmetischen Operatoren.

 Zuweisungsoperator: =
 Arithmetische Operatoren: + - * /
 Kombinierte Operatoren: += -= *= /=

Die kombinierten Operatoren sollen für die scheinbar äquivalenten Formulierungen mit getrenntem Zuweisungsoperator und arithmetischem Operator stehen:

 a += 1; steht für a = a + 1;
 a -= 1; steht für a = a - 1;
 a *= 1; steht für a = a * 1;
 a /= 1; steht für a = a / 1;

Diese Schreibweisen sollen wohl vor allem ein wenig Schreibarbeit bei der Programmierung ersparen, können aber zu schwer zu identifizierenden Programmierfehlern führen, wie das folgende Java-Beispiel verdeutlichen soll:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
	long a = 1;
	double b = 1.5;
	a *= b;
	java.lang.System.out.println (a);
	a += b;
	java.lang.System.out.println (a);
	a -= b;
	java.lang.System.out.println (a);
&lt;/syntaxhighlight&gt;

Dieser Code erzeugt die Ausgabe:

 1
 2
 0

Die nur scheinbar äquivalenten Formulierungen für die kombinierten Operatoren

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
	a = a * b;
	a = a + b;
	a = a - b;
&lt;/syntaxhighlight&gt;

werden in Java wegen der mangelnden Zuweisungskompatibilität der arithmetischen Ausdrücke hinter dem Zuweisungsoperator vom Datentyp &quot;double&quot; zum Datentyp &quot;long&quot; der Variable &quot;a&quot; gar nicht übersetzt.

Die tatsächlichen äquivalenten Formulierungen für die kombinierten Operatoren lauten nämlich wie folgt:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
	a = (long) (a * b);
	a = (long) (a + b);
	a = (long) (a - b);
&lt;/syntaxhighlight&gt;

Durch die impliziten Datentypumwandlungen erklären sich auch die falschen numerischen und gegebenenfalls nicht erwarteten ganzzahligen Ergebnisse. Wenn bei der Programmierung diese Tatsachen nicht bewusst sind oder übersehen werden, ergeben sich numerische Fehler in den arithmetischen Berechnungen. Dies kann einfach vermieden werden, indem kombinierte Operatoren zugunsten der expliziten sowie transparenten Formulierungen mit separaten Operatoren nicht verwendet werden.

=== Durch Sprachdefinition ===
Als Beispiel dient hier die scheinbar falsche Ausgabe eines Java-Programms, weil die Definition der Programmiersprache der Intuition widerspricht:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long i = 01234567;
 java.lang.System.out.println (i);
&lt;/syntaxhighlight&gt;

Dieser Code erzeugt die Ausgabe:

 342391

Das Literal &quot;01234567&quot; wird trotz der ausschließlichen Verwendung von gültigen dezimalen Ziffern nicht als die Dezimalzahl 1234567&lt;sub&gt;10&lt;/sub&gt; interpretiert und ausgegeben, sondern entsprechend der Definition der Programmiersprache Java wegen der einleitenden Null als Oktalzahl zur Basis Acht, also als 1234567&lt;sub&gt;8&lt;/sub&gt; = 342391&lt;sub&gt;10&lt;/sub&gt;.

=== Durch Überladen ===
Eine Überladung liegt vor, wenn eine Operator oder ein Bezeichner mehrfach in verschiedenen Bedeutungen auftritt, die leicht zu Verwechslungen führen können. Streng strukturierte Programmiersprachen erlauben das polymorphe Überladen nicht, wenn es dadurch zu Programmierfehlern kommen kann.

Das '''Überladen''' muss in der objektorientierten Programmierung vom '''Überschreiben''' unterschieden werden, wobei auch überschriebene Methoden in weniger strukturierten Programmiersprachen überladen werden dürfen, was ebenfalls zu unübersichtlichem Programmcode und schnell zu übersehenden Programmierfehlern führen kann. Siehe hierzu unten unter [[Strukturierte Programmierung#Überladung|Überladung]].

==== Überladung von Divisionsoperatoren ====
Die Divisionsoperatoren sind in vielen Programmiersprachen leider überladen, wenn nämlich formal keine Unterscheidung zwischen Division mit ganzen Zahlen (Datentyp zum Beispiel &quot;long&quot; oder &quot;int&quot;) und Gleitkommazahlen (Datentyp zum Beispiel &quot;real&quot; oder &quot;double&quot;) gemacht wird. In diesen Fällen muss der Divisionsoperator sehr aufmerksam verwendet werden:

 int i ← 2;
 int j ← 1;
 real k ← j / i; /* Ueberladener Divisionsoperator mit zwei ganzzahligen Operanden */

Verwendet die Programmiersprache im arithmetischen Ausdruck die ganzzahlige Division, hat dies zur Folge, dass die Variable k den Wert '''0''' erhält. Verwendet die Programmiersprache stattdessen die reelwertige Division, bekommt die Variable k den Wert 0,5 zugewiesen.

Einige Programmiersprachen unterscheiden daher sinnvollerweise explizit zwischen einem Operator für die ganzzahlige Division (&quot;div&quot; oder &quot;DIV&quot;) und einem Operator für die Gleitkommadivision (&quot;/&quot;).

&lt;syntaxhighlight lang=&quot;pascal&quot;&gt;
(* Programmiersprache Pascal *)
 i, j : integer;
 k : real;
 i := 2;
 j := 1;
 k := j / i; (* Gleitkommazahliger Divisionsoperator mit zwei ganzzahligen Operanden *)
&lt;/syntaxhighlight&gt;

In der letzten Anweisung wird der Variablen &quot;k&quot; der Zahlenwert der reellwertigen Division '''0,5''' zugewiesen.

&lt;syntaxhighlight lang=&quot;pascal&quot;&gt;
(* Programmiersprache Pascal *)
 i, j, k : integer;
 i := 2;
 j := 1;
 k := j div i; (* Ganzzahliger Divisionsoperator mit zwei ganzzahligen Operanden *)
&lt;/syntaxhighlight&gt;

In der letzten Anweisung wird der Variablen &quot;k&quot; der Zahlenwert der ganzzahligen Division '''0''' zugewiesen.

Bei Programmiersprachen, die die Unterscheidung der Divisionsoperatoren nicht unterstützen, ist die Verwendung der expliziten und zuweisungskompatiblen Datentypumwandlung (englisch: ''type cast'') nicht nur sinnvoll, sondern sogar zwingend erforderlich:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long i = 2;
 long j = 1;
 double k = ((double) j) / ((double) i) /* Ueberladener Divisionsoperator mit zwei gleitkommazahligen Operanden */
&lt;/syntaxhighlight&gt;

In der Regel ist es für eine Gleitkommadivision hierbei ausreichend, wenn nur einer der beiden Operanden, also nur der Nenner (Dividend) oder der nur Zähler (Divisor) der Division, eine Gleitkommazahl darstellt.

Entsprechende Überlegungen gelten auch für alle '''Modulo-Operatoren''' (wie zum Beispiel &quot;%&quot;, &quot;mod&quot; oder &quot;MOD&quot;).

==== Überladung von Variablen ====
Oft ist es in einer Programmiersprache erlaubt, dieselben Bezeichner für Variablen mit verschiedenen Sichtbarkeitsbereichen zu verwenden. Dies kann sehr einfach zur Verwechslung dieser Variablen führen, wie im folgenden Java-Beispiel verdeutlicht wird, wo es sowohl eine globale Klassenvariable (Sichtbarkeit in der Klasse &quot;OverloadedVariables&quot;) als auch eine lokale Variable (Sichtbarkeit in der Methode &quot;main&quot;) mit dem Namen &quot;bezeichner&quot; gibt:&lt;syntaxhighlight lang=&quot;java&quot;&gt;
public class OverloadedVariables
{
	// globale Klassenvariable &quot;bezeichner&quot;
	private static long bezeichner = 1;

	// Hauptprogramm (Methode &quot;main&quot;)
	public static void main (java.lang.String [] argumente) 
	{
		// lokale Variable &quot;bezeichner&quot;
		long bezeichner = 2; 
		// Ausgabe der globalen Klassenvariable &quot;bezeichner&quot;
		java.lang.System.out.println (&quot;Wert der globalen Variable = &quot; + OverloadedVariables.bezeichner);
		// Ausgabe der lokalen Variable aus der Methode &quot;main&quot;
		java.lang.System.out.println (&quot;Wert der  lokalen Variable = &quot; + bezeichner);
	}
}
&lt;/syntaxhighlight&gt;Falls die Klassenvariable referenziert werden soll, muss sie in Java qualifiziert bezeichnet werden, indem der Name der Klasse vorangestellt wird.

==== Überladung von Methoden ====
Viele Programmiersprachen erlauben die Deklaration von mehreren Methoden mit gleichem Bezeichner, die sich in der Anzahl oder den Datentypen ihrer Parameter unterscheiden. Das folgende Java-Beispiel mit zwei Methoden demselben Namens, von denen die mit der passenden Datentyp des Parameters &quot;zahl&quot; aufgerufen wird, verdeutlicht dies:&lt;syntaxhighlight lang=&quot;java&quot;&gt;
	private static long kehrwert (long zahl)
	{
		long kehrwert = 1 / zahl;
		return kehrwert;
	}

	private static double kehrwert (double zahl)
	{
		double kehrwert = 1 / zahl;
		return kehrwert;
	}

	public static void main (java.lang.String [] argumente)
	{
		double kehrwert1 = kehrwert (2);
		double kehrwert2 = kehrwert (2.0);
		java.lang.System.out.println (&quot;Kehrwert 1 = &quot; + kehrwert1);
		java.lang.System.out.println (&quot;Kehrwert 2 = &quot; + kehrwert2);
	}
&lt;/syntaxhighlight&gt;Die Ausgabe ergibt zwei verschiedene Ergebnisse für den Kehrwert der Zahl Zwei:&lt;syntaxhighlight&gt;
Kehrwert 1 = 0.0
Kehrwert 2 = 0.5
&lt;/syntaxhighlight&gt;Durch die kategorische Verwendung verschiedener Bezeichner für verschiedene Methoden kann die Verwechslungsgefahr leicht und ohne Probleme verhindert werden, und die Erzeugung der beiden verschiedenen Ergebnisse wird transparent:&lt;syntaxhighlight lang=&quot;java&quot;&gt;private static long kehrwertLong (long zahl)
	{
		long kehrwert = 1 / zahl;
		return kehrwert;
	}

	private static double kehrwertDouble (double zahl)
	{
		double kehrwert = 1 / zahl;
		return kehrwert;
	}

	public static void main (java.lang.String [] argumente)
	{
		double kehrwert1 = kehrwertLong (2);
		double kehrwert2 = kehrwertDouble (2.0);
		java.lang.System.out.println (&quot;Kehrwert 1 = &quot; + kehrwert1);
		java.lang.System.out.println (&quot;Kehrwert 2 = &quot; + kehrwert2);
	}&lt;/syntaxhighlight&gt;

===Durch falsche Spezifikation===
In Programmiersprachen, die dynamische Variablen ausschließlich als Zeiger behandeln (wie zum Beispiel C oder C++), kann trotz exakter Übereinstimmung der referenzierten Datentypen bei einer Zuweisung des Ergebnisses einer Funktion ein Zeiger auf den lokalen Stapelspeicher der Funktion zurückgegeben werden, der nur während der Ausführung der Funktion, aber nicht mehr nach dem Rücksprung aus der Funktion gültig ist. Während der weiteren Programmausführung kann der Speicherbereich jederzeit überschrieben werden, ohne dass der Programmierer dies wünscht oder absehen kann.

Im folgenden Beispiel in der Programmiersprache C wird innerhalb der Funktion ''function'' der Wert 5 dem Datenfeld ''a'' der Variablen ''data'' zwar korrekt zugewiesen, kann aber nach dem Rücksprung aus der Funktion im Stapelspeicher jederzeit unbeabsichtigt verändert werden, wie zum Beispiel beim erneuten Aufruf einer Funktion oder anderen Operationen, die den Stapelspeicher verwenden:

&lt;syntaxhighlight lang=&quot;C&quot;&gt;
/* Programmiersprache C */

struct DataType { int a }; // Definition des Datentyps ''DataType'' mit einem ganzzahligen Datenfeld ''a''

// Deklaration der Funktion ''function'' mit einem Zeiger auf eine Variable vom Datentyp ''DataType'' als Speicheradresse für den Rückgabewert
DataType* function ()
{
  DataType data;           // Deklaration der lokalen Variable ''data'' vom Datentyp ''DataType''
  data.a = 5;              // Zuweisung des Wertes ''5'' zum Datenfeld ''a'' der Variablen ''data''
  return &amp;data;            // Rückgabe der lokalen, temporären Speicheradresse von ''data'', die nach der Beendigung des Funktionsaufrufs gar nicht mehr gültig ist.
}
&lt;/syntaxhighlight&gt;

Der Programmierer muss zur Abwendung dieses Übels darauf achten, dass Rückgabewerte durch Allokation einer entsprechenden Variablen in einem dauerhaft verfügbaren dynamischen Speicherbereich (also zum Beispiel im Heap-Speicher) auch nach dem Aufruf der Funktion noch gültig und korrekt aufrufbar sind.

Bei der Verwendung von vollständig typsicheren Programmiersprachen ist die Rückgabe von lokal definierten Adressen nicht zulässig, und die Übersetzung des entsprechenden Codes wird vom Complier von vornherein verweigert, so dass es gar nicht zu einem solchen Nebeneffekt kommen kann.

Alternativ kann der Datentyp ''DataType'' nicht direkt als Verbund, sondern als Zeiger auf einen entsprechenden Verbund deklariert werden. In diesem Fall muss in der Funktion zunächst eine Instanz erzeugt werden (beispielsweise mit dem Kommando ''new'' oder ''allocate''). Diese Instanz ist dann nicht mehr im lokalen Stapelspeicher (Stack) der Funktion gespeichert, sondern es kann im dynamischen Speicherbereich (Heap) global - also auch außerhalb der Funktion und nach Beendigung des Funktionsaufrufs - darauf zugegriffen werden.

===Durch Verwechslung von Speicherinhalt und Speicheradresse===
Die Werte von Variablen werden unter einer bestimmten Speicheradresse eines Computers gespeichert, wo vom Laufzeitsystem die für den entsprechenden Datentyp erforderliche Datenmenge der entsprechende Speicherplatz reserviert und bereitgehalten wird. Diese Speicheradresse wird in modernen Systemen in der Regel automatisch verwaltet, so dass sie im Allgemeinen gar nicht bekannt ist und auch gar nicht bekannt sein muss.

Daraus ergeben sich unter Umständen jedoch wichtige Implikationen. In manchen Programmiersprachen, wie zum Beispiel Java, ist nämlich nicht unmittelbar erkennbar, ob bei bestimmten Operationen der Speicherinhalt oder die Speicheradresse einer Variablen verwendet wird. So werden bei bei logischen Vergleichen mit Operanden, die aus Variablen mit einfachen Datentypen bestehen (etwa boolean, long oder double), die unter der Speicheradresse gespeicherten '''Werte''' verglichen, also die Inhalte. Bei Variablen mit komplexen Datentypen (beispielsweise eine abzählbare Liste von Daten eines Datentyps (array), ein Verbund (record / struct), der sich aus verschiedenen Datentypen zusammensetzen kann, oder allgemein in der objektorientierten Programmierung die Instanz eines Objekts) werden jedoch gar nicht unbedingt die gespeicherten Inhalte, sondern lediglich die Speicheradressen der beiden Operanden verglichen. Hier wird also beim Gleichheitsoperator nur geprüft, ob es sich um dasselbe Speicherobjekt (dieselbe Instanz) handelt, und nicht, ob zwei verschiedene Speicherobjekte den gleichen Inhalt haben. Bei strenger Strukturierung wird (hoffentlich schon vor der Ausführung bereits im Quelltext) zusätzlich geprüft, ob die zu vergleichenden komplexen Datentypen überhaupt zuweisungskompatibel und somit sinnvoll vergleichbar sind.

Unter welchen Umständen welche Speicheradressen für gleiche Speicherinhalte verwendet werden, ist insbesondere für unerfahrene Programmierer keineswegs immer naheliegend oder leicht nachzuvollziehen. Dies wird im Folgenden anhand des logischen Vergleichs auf Gleichheit von Zeichenketten (Java-Klasse java.lang.String) in der Programmiersprache Java verdeutlicht. Die Wirkungsweise des Gleichheitsoperators  == wird der Wirkungsweise des Funktionsaufrufs der Methode '''java.lang.String.equals''' gegenübergestellt, die einen booleschen Rückgabewert hat.

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
	boolean vergleich;

	// Die symbolische Konstante für die Zeichenkette &quot;abc&quot; wird in einer Variablen mit dem Bezeichner text verwaltet
	// Die Zeichenkette &quot;abc&quot; wird von Java unter der Speicheradresse #MEM1 abgelegt
	// Die Variable text und die symbolische konstante Zeichenkette &quot;abc&quot; haben dieselbe Speicheradresse #MEM1
	java.lang.String text = &quot;abc&quot;;

	// Vergleich der Speicheradresse #MEM1 mit der Speicheradresse #MEM1
	vergleich = (&quot;abc&quot; == &quot;abc&quot;);
	java.lang.System.out.println (&quot;1. Vergleich \&quot;abc\&quot; == \&quot;abc\&quot;: &quot; + vergleich);

	// Vergleich der Speicheradresse #MEM1 mit der Speicheradresse #MEM1 !!!
	vergleich = (text == &quot;abc&quot;);
	java.lang.System.out.println (&quot;2. Vergleich text == \&quot;abc\&quot;: &quot; + vergleich);

	// Vergleich des Inhalts bei der Speicheradresse #MEM1 mit dem Inhalt bei der Speicheradresse #MEM1
	vergleich = text.equals (&quot;abc&quot;);
	java.lang.System.out.println (&quot;3. Vergleich text.equals (\&quot;abc\&quot;): &quot; + vergleich);

	// Neue Instanz fuer die bereits oben deklarierte Zeichenkette text 
	// Die neue Instanz wird mit dem new-Operator unter der Speicheradresse #MEM2 erzeugt
	// Der Speicherinhalt wird mit dem Konstruktor java.lang.String und dem Wert &quot;abc&quot; initialisiert
	// Die Variable text bekommt durch die Zuweisung die Speicheradresse #MEM2
	text = new java.lang.String (&quot;abc&quot;);

	// Vergleich der Speicheradresse #MEM2 mit der Speicheradresse #MEM1 !!!
	vergleich = (text == &quot;abc&quot;);
	java.lang.System.out.println (&quot;4. Vergleich text == \&quot;abc\&quot;: &quot; + vergleich);

	// Vergleich des Inhalts bei der Speicheradresse #MEM2 mit dem Inhalt bei der Speicheradresse #MEM1
	vergleich = text.equals (&quot;abc&quot;);
	java.lang.System.out.println (&quot;5. Vergleich text.equals (\&quot;abc\&quot;): &quot; + vergleich);
&lt;/syntaxhighlight&gt;

Die Textausgabe dieses Programms sieht wie folgt aus:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
1. Vergleich &quot;abc&quot; == &quot;abc&quot;: true
2. Vergleich text == &quot;abc&quot;: true
3. Vergleich text.equals (&quot;abc&quot;): true
4. Vergleich text == &quot;abc&quot;: false
5. Vergleich text.equals (&quot;abc&quot;): true
&lt;/syntaxhighlight&gt;

Symbolisch konstante Zeichenketten, wie zum Beispiel der Ausdruck &quot;abc&quot;, werden unter einer verdeckten Speicheradresse abgelegt und von Java für gleichlautende Ausdrücke automatisch wiederverwendet. Wird jedoch mit dem new-Operator eine Instanz eines Objekts erzeugt, so bekommt diese unabhängig davon, welcher Inhalt dort gespeichert wird, stets eine andere neue Speicheradresse zugeordnet. Für den Vergleich des Inhalts von Zeichenketten auf Gleichheit ist in Java also immer die generische typengebundene Methode &quot;equals'' zu verwenden. Diese typengebundene Methode &quot;equals&quot; gibt es auch in vielen anderen Java-Klassen, um den Inhalt der entsprechenden Objektinstanzen auf Gleichheit vergleichen zu können.

==Strukturierte objektorientierte Programmierung==
===Vermeidung von Codewiederholung durch Vererbung===
Die Vermeidung von Codewiederholung durch Vererbung kann beispielsweise an den beiden graphischen Objekten '''Kreis''' und '''Dreieck''' deutlich gemacht werden. Diese beiden Objekte können unabhängig voneinander als Datentyp modelliert werden, wobei ihre gemeinsamen Eigenschaften '''Farbe''' und '''Strichstärke''', sowie die jeweilige Methode zum '''Zeichnen''' beide Male unabhängig behandelt werden (dies kann eindeutig durch '''Hat'''-Beziehungen ausgedrückt werden: ein Kreis oder ein Dreieck '''hat''' eine Farbe, eine Strickstärke sowie eine Methode zum Zeichnen), was eine Codewiederholung darstellt. Der '''Kreis''' hat zusätzlich das Attribut '''Radius''', und das '''Dreieck''' hat zusätzlich die drei Attribute '''SeiteA''', '''SeiteB''' und '''SeiteC''':

 Kreis   hat: Farbe, Strichstärke, Methode zum Zeichnen, Radius
 Dreieck hat: Farbe, Strichstärke, Methode zum Zeichnen, SeiteA, SeiteB, SeiteC

Mithilfe von Vererbung kann die Codewiederholung vermieden werden, indem die Attribute '''Farbe''' und '''Strichstärke''', sowie die Methode zum '''Zeichnen''' nur einmal mithilfe des abstrakten Objekts '''GraphischesObjekt''' deklariert werden. Die konkreten Objekte '''Kreis''' und '''Dreieck''' erben alle gemeinsamen Eigenschaften und Methoden (respektive typengebundenen Prozeduren) von '''GraphischesObjekt''' (dies kann eindeutig durch '''Ist'''-Beziehungen ausgedrückt werden: ein Kreis '''ist''' ein GraphischesObjekt, und ein Dreieck '''ist''' ein GraphischesObjekt) und werden nur durch die jeweils fehlenden Attribute ergänzt:

 GraphischesObjekt hat: Farbe, Strichstärke, Methode zum Zeichnen

 Kreis   ist GraphischesObjekt, hat zusätzlich: Radius
 Dreieck ist GraphischesObjekt, hat zusätzlich: SeiteA, SeiteB, SeiteC

===Überladung===
Das '''Überladen''' von Methoden, Konstruktoren oder Variablen ist auch bei objektorientierter Programmierung überflüssig, erschwert die Nachvollziehbarkeit vom Quellcode und birgt die Gefahr von Programmierfehlern, die unter Umständen erst lange nach der Entwicklung der Software bei deren Wartung entstehen. Das folgende Beispiel verdeutlicht einen leicht zu übersehenden Programmierfehler durch die Veränderung bei den überladenen Funktionen während der Programmentwicklung oder Programmwartung:

 double quotient (double a, double b)
 {
  return a / b; /* Gleitkommazahlige Division */
 }
 
 long i ← 1;
 long j ← 2;
 double q ← quotient (i, j); /* q ist 0,5 da die gleitkommazahlige Definition der Funktion 'quotient' verwendet wird */

Wird die Funktion 'quotient' später mit einer ganzzahligen Variante überladen, ergibt sich beim bestehenden Aufruf der Funktion unbeabsichtigt ein anderes Ergebnis für die Variable 'q':

 double quotient (long a, long b)
 {
  return a DIV b; /* Ganzzahlige Division */
 }
 
 double quotient (double a, double b)
 {
  return a / b; /* Gleitkommazahlige Division */
 }
 
 long i ← 1;
 long j ← 2;
 double q ← quotient (i, j); /* q ist 0 da die ganzzahlige Definition der Funktion 'quotient' verwendet wird */

Noch unübersichtlicher wird die Lage, wenn zusätzlich auch noch Überladungen mit gemischten Datentypen für die Funktionsparameter definiert werden:

 double quotient (long a, long b)
 
 double quotient (double a, long b)
 
 double quotient (long a, double b)
 
 double quotient (double a, double b)

Deswegen werden Methoden oder Attribute besser nicht überladen, auch nicht, wenn die Programmiersprache dies zulässt. Auch jede Klasse bekommt daher maximal einen einzigen '''Konstruktor''', der alle erforderlichen Parameter zur Initialisierung der Instanzvariablen enthält. Als günstige Nebeneffekte stellen sich kürzere Übersetzungszeiten ein.

Wenn die ursprünglichen Deklarationen in der Basisklasse oder einer der von ihr erbenden Klassen überladen werden, indem zum Beispiel weitere gleichnamige Methoden mit abweichenden Parametern definiert werden, dann kann es zu verändertem Verhalten von Software kommen. Ohne dass die Anwendung selbst geändert wurde, kann es allein durch die Aktualisierung einer verwendeten Klasse zu völlig anderen Rechenergebnissen kommen, weil automatisch eine andere, neu überladene Methode aufgerufen wird, ohne dass dies im Quelltext des Anwendungsprogramms sichtbar wird. Die Folge können schwerwiegende Programmierfehler sein, die schwierig zu analysieren sind.

Als ein Beispiel diene hier die Methode java.lang.Math.ulp zur Bestimmung der &quot;'''u'''nits in the '''l'''ast '''p'''lace&quot; (&quot;Einheiten in der letzten Stelle&quot;), die in der Klasse java.lang.Math aus historischen Gründen mit zwei Parametern deklariert und somit überladen ist:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 public class Math;
 {
    public static double ulp​ (double d)
    public static float  ulp​ (float f)
 }
&lt;/syntaxhighlight&gt;

Der folgende Java-Code

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 double zahl;
 zahl = java.lang.Math.ulp (1L); // Datentyp long
 java.lang.System.out.println (zahl);
 zahl = java.lang.Math.ulp (1F); // Datentyp float
 java.lang.System.out.println (zahl);
 zahl = java.lang.Math.ulp (1D); // Datentyp double
 java.lang.System.out.println (zahl);
&lt;/syntaxhighlight&gt;

erzeugt folgende Ausgabe, da die ganze Zahl Eins mit dem Datentyp long (64 Bit) in der Programmiersprache Java implizit offensichtlich nicht in den Datentyp double (64 Bit), sondern in den Datentyp float (32 Bit) umgewandelt wird, und somit die mit dem Parameter des Datentyps float deklarierte Methode aufgerufen wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 1.1920928955078125E-7
 1.1920928955078125E-7
 2.220446049250313E-16
&lt;/syntaxhighlight&gt;

Falls bei einer neueren Version der Klasse java.lang.Math die Methode ulp mit einem Parameter des Datentyps long überladen würde, wäre das Ergebnis mit dem ganzzahligen Parameter des Werts &quot;1L&quot; (long) nicht mehr vorhersagbar, obwohl der oben angegebene Methodenaufruf sich formal gar nicht geändert hätte.

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 public class Math;
 {
    public static double ulp ​(double d)
    public static float  ulp​ (float f)
    public static double ulp ​(long l)
 }
&lt;/syntaxhighlight&gt;

Das Ergebnis des Aufrufs 

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 double zahl = java.lang.Math.ulp (1L);
 java.lang.System.out.println (zahl);
&lt;/syntaxhighlight&gt;

würde dann allein von der tatsächlichen Implementierung der neuen überladenen Methode mit dem Parameter des Datentyps long abhängen, die mit den alten beiden ulp-Methoden nichts mehr zu tun hat, außer, dass sie den gleichen Namen hat.

===Überschreibung===
Das '''Überschreiben''' von geerbten Methoden oder Konstruktoren ist etwas völlig anderes als das Überladen und kann sehr sinnvoll sein.

Beim Überschreiben muss die Signatur der Methode (oder des Konstruktors) unter strikter Beachtung der Zuweisungskompatibilität, der Anzahl und der Reihenfolge aller Parameter sowie der Rückgabewerte berücksichtigt werden. Wenn die Programmiersprache dies nicht automatisch unterstützt, sind wenigstens entsprechend aufwendige Maßnahmen im Quelltext sicherzustellen, wie zum Beispiel explizite Typenprüfungen oder hinreichend ausführliche Hinweise in Kommentaren.

Wenn Methoden oder Konstruktoren einer Basisklasse von der überschreibenden Klasse aufgerufen werden (englisch ''super call'') kann es zum ''Fragile Base Class Problem'' (zu Deutsch ''Problem der anfälligen Basisklasse'') kommen, da bei der Implementierung der Basisklasse die möglichen Auswirkungen in den später implementierten, überschreibenden Klassen nicht berücksichtigt werden konnten. Zur Abwendung dieser Gefahr sind ein besonders sorgfältiger und strukturierter Programmierstil sowie eine lückenlose Dokumentation des Quelltextes sehr hilfreich.

Das fehlerfreie und robuste Überschreiben von Klassen beziehungsweise die Vererbung von implementierten Klassen erfordern eine hohe Fähigkeit zum abstrakten Denken und eine umfangreiche Programmiererfahrung.

===Mehrfachvererbung===
Durch [[w:Mehrfachvererbung|Mehrfachvererbung]], also das Erben von Methoden und Instanzvariablen aus mehreren Basisklassen, führt zu komplexen, und schwierig zu durchschauenden Abhängigkeiten, die im Rahmen des [[w:Diamond-Problem|Diamond-Problems]] sogar zu unerwünschten Mehrdeutigkeiten führen kann. Die Vererbung aus zwei Basisklassen kann bei Bedarf ohne weiteres durch die Verwendung von [[w:Zwillingsklasse|Zwillingsklassen]] vermieden werden, was den Programmieraufwand ein wenig erhöht, aber dafür solche Mehrdeutigkeiten verhindert und außerdem die Übersetzungszeiten der Quelltexte reduziert.

In der Programmiersprache Java ist es zum Beispiel möglich, mehrere Basisklassen zu erben. Dabei ist zwar nur eine konkrete Vererbung aus einer Basisklasse (in Java: class) zulässig, aber zusätzlich dürfen noch beliebig viele weitere Basisklassen (in Java: interface) abstrakt geerbt werden. Dabei werden alle Attribute und Methoden aller Basisklassen auf die erbende Klasse übertragen. Auch die konkret vererbte Basisklasse kann wiederum selber mehrere abstrakte Basisklassen implementieren. Falls es in mehreren Basisklassen gleichlautende öffentliche Bezeichner gibt, kommt es unweigerlich zu Konflikten. 

Es ist in der Implementierung insbesondere bei fehlenden entsprechenden Kommentaren nicht ohne Weiteres erkennbar, zu welchen Basisklassen die zu überschreibenden Instanzvariablen oder Methoden gehören.

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/**
 * Die Klasse Mehrfachvererbung erbt Attribute und Methoden aus drei Basisklassen:
 *    Sie ist eine Instanz der Klasse (class = konkrete Klasse) javax.swing.JFrame.
 *    Sie implementiert die Schnittstelle (interface = abstrakte Klasse) java.awt.event.KeyListener.
 *    Sie implementiert die Schnittstelle (interface = abstrakte Klasse) java.awt.event.ActionListener.
 */

public class Mehrfachvererbung
extends javax.swing.JFrame
implements java.awt.event.KeyListener, java.awt.event.ActionListener
{
	/**
	 *  Konstante serialVersionUID aus der Basisklasse java.io.Serialization fuer die Serialisation,
	 *  die in der Klasse javax.swing.JFrame implementiert ist
	 */
	private final static long serialVersionUID = 1L;

	/**
	 *  Instanzvariable fuer den zuletzt von einer Instanz der Klasse javax.swing.JFrame gesendeten Tastaturcode
	 */
	private int keyCode;

	/**
	 *  Zu ueberschreibende Methode aus der geerbten Klasse java.awt.event.KeyListener
	 *  Speichert den Tastaturcode der zuletzt betaetigten Taste fuer eine Instanz
	 *  @param event: aufgetretenes Tastaturereignis aus der Klasse java.awt.event.KeyEvent
	 */
	@Override
	public void keyPressed (java.awt.event.KeyEvent event)
	{
		this.keyCode = event.getKeyCode ();
	}

	/**
	 *  Zu ueberschreibende Methode aus der geerbten Klasse java.awt.event.KeyListener
	 *  Ungenutzt
	 *  @param event: aufgetretenes Tastaturereignis aus der Klasse java.awt.event.KeyEvent
	 */
	@Override
	public void keyReleased(java.awt.event.KeyEvent event)
	{
	}

	/**
	 *  Zu ueberschreibende Methode aus der geerbten Klasse java.awt.event.KeyListener
	 *  Ungenutzt
	 *  @param event: aufgetretenes Tastaturereignis aus der Klasse java.awt.event.KeyEvent
	 */
	@Override
	public void keyTyped (java.awt.event.KeyEvent event)
	{
	}

	/**
	 *  Zu ueberschreibende Methode aus der vererbten Klasse java.awt.event.ActionListener
	 *  Der Inhalt einer Instanz der Klasse javax.swing.JFrame wird erneut dargestellt,
	 *  wenn die Eingabetaste (Enter) betaetigt wurde.
	 *  @param event: aufgetretenes Aktionsereignis aus der Klasse java.awt.event.ActionEvent
	 */
	@Override
	public void actionPerformed (java.awt.event.ActionEvent event)
	{
		if (this.keyCode == java.awt.event.KeyEvent.VK_ENTER)
		{
			this.repaint ();
		}
	}
}
&lt;/syntaxhighlight&gt;

==Nachwort==
Ein sehr häufig auftretender „Programmierfehler“ - wiederum insbesondere bei Anfängern - ist das Unterlassen der Herstellung von Sicherungskopien der Quelltexte. Noch besser ist eventuell sogar eine Versionierung der Quelldateien, damit gegebenenfalls auf beliebige ältere Versionen zurückgegriffen werden kann. Die Auswirkungen dieses Fehlers sind hinreichend naheliegend, so dass hier nicht weiter darauf eingegangen werden muss.

Sollte der Leser nach der Lektüre dieser Beiträge zu dem verständlichen und naheliegenden Schluss gekommen sein, dass die Programmiersprachen C oder C++ ziemlich schlecht strukturiert sind, möge er sich auch einmal andere Programmiersprachen näher ansehen, wie zum Beispiel C#, Component Pascal oder auch Java.

Mit der Beherzigung der Vorschläge aus diesem Buch möge es dem Leser in seinem Programmier-Team in jeder Programmiersprache gelingen, in kürzerer Entwicklungszeit besser strukturierte und funktionierende Programme zu schreiben.

===Vergleich===
In der folgenden Tabelle werde einige imperative, objektorientierte Programmiersprachen hinsichtlich ihrer Strukturiertheit verglichen:

{| class=&quot;wikitable&quot;
|- class=&quot;hintergrundfarbe6&quot;
!Veröffentlichungsdatum!!1985!!1994!!1995!!2001
|-
!Programmiersprache!!C++!!Component&lt;br/&gt;Pascal!!Java!!C#
|-
| style=&quot;text-align:left&quot;| Vollständig strukturierte Syntax || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | nein
|-
| style=&quot;text-align:left&quot;| Datentypsicherheit bei Basistypen || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | ja
|-
| style=&quot;text-align:left&quot;| Datentypsicherheit bei komplexen Datentypen || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja
|-
| style=&quot;text-align:left&quot;| Modulsicherheit || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja
|-
| style=&quot;text-align:left&quot;| Keine zyklischen Importe || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | nein
|-
| style=&quot;text-align:left&quot;| Keine mehrfache Schnittstellenvererbung || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | nein
|-
| style=&quot;text-align:left&quot;| Keine mehrfache Implementationsvererbung || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja
|}

==Literatur==
* Niklaus Wirth:
** ''Programming in Modula 2'', Springer, 3. Auflage, 1985, ISBN 3-540-15078-1
** Mit Martin Reiser: ''Programming in Oberon – Steps beyond Pascal and Modula'', Addison-Wesley,1992, ISBN 0-201-56543-9
** ''Algorithmen und Datenstrukturen mit Modula - 2'', Teubner Leitfäden der Informatik, 5. Auflage, Teubner, Stuttgart, 1996, ISBN 9783519122609
* Herbert Schildt: ''Professionelles Modula-2'', McGraw-Hill, Hamburg, 1988, ISBN 3-89028-113-3
* Lászlo Böszörmény, Jürg Gutknecht, Gustav Pomberger: ''The School of Niklaus Wirth – The Art of Simplicity'', dpunkt, Heidelberg, 2000, ISBN 3-932588-85-1
* Hanspeter Mössenböck:
** ''Objektorientierte Programmierung in Oberon-2'', Springer, 1998, ISBN 9783540646495
** ''Sprechen Sie Java?: Eine Einführung in das systematische Programmieren'', dpunkt, Heidelberg, 2005, ISBN 9783898643627
** ''Kompaktkurs C# 4.0'', dpunkt, Heidelberg, 2009, ISBN 9783898646451

==Weblinks==
*{{w|Niklaus Wirth}}:
**Interessantes Interview: [http://www.simple-talk.com/opinion/geek-of-the-week/niklaus-wirth-geek-of-the-week/ Geek of the Week] vom 2. Juli 2009
**Ein noch interessanteres Interview (2009): [http://www.youtube.com/watch?v=wrGytM2YTQY An Interview with Niklaus Emil Wirth, Part 3]
*{{w|Frederick P. Brooks}}: [[w:en:The_Mythical_Man-Month|The Mythical Man-Month]]
*{{w|Benutzer:Bautsch|Markus Bautsch}}: [[:en:User:Bautsch/Capsula|Draft of the graphical programming language '''Capsula''']] (Wikibooks)

== Einzelnachweise ==
&lt;references&gt;&lt;/references&gt;

==Zusammenfassung des Projekts==
{{Vorlage:StatusBuch|10}}
* '''Zielgruppe:''' Programmierer, Software-Entwickler, Informatik-Lehrende
* '''Lernziele:''' Vermeidung von Fehlern, die leicht und unbemerkt zur unstrukturierten Programmierung führen können. Schnelle und sichere Erstellung leicht zu wartender Software.
* '''Buchpatenschaft/Ansprechperson:''' [[Benutzer:Bautsch]]
* '''Sind Co-Autoren gegenwärtig erwünscht?''' Ja, sehr gerne. Korrekturen von offensichtlichen Fehlern direkt im Text; Inhaltliches bitte per Diskussion.
* '''Richtlinien für Co-Autoren:''' Wikimedia-like.

[[Kategorie:Buch]]
[[Kategorie:Studium]]</text>
      <sha1>lj0y1zvs5sl6q0geene7xl3l71mgy4e</sha1>
    </revision>
    <revision>
      <id>1088582</id>
      <parentid>1088579</parentid>
      <timestamp>2026-07-03T12:33:33Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <comment>/* Kommentare */ aktualisiert</comment>
      <origin>1088582</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="180551" sha1="tcdn257ngz2rvhj6t2lp6oy0va41gb2" xml:space="preserve">{{Regal | ort=Programmierung}}
[[Datei:Programmierung.Java.Julia-Menge.png|mini|rechts|hochkant=2|Bildschirmaufnahme des mit Tastatursteuerung interaktiven Java-Programms [[Das Apfelmännchen/ FraktaleMengeAusgabe|FraktaleMengeAusgabe]] zur Berechnung und Darstellung von Julia-Mengen oder der Mandelbrot-Menge. Siehe auch '''Wikibook [[Das Apfelmännchen]]'''.]]
[[Datei:Programmierung.Java.Maze.png|mini|rechts|hochkant=2|Bildschirmaufnahme des Java-Programms [[Rekursive Labyrinthe/ MazeGraphs|Maze]] zur rekursiven Erstellung und Darstellung von Labyrinthen. Siehe auch '''Wikibook [[Rekursive Labyrinthe]]'''.]]
[[Datei:Programmierung.Java.SimForestFrame.png|mini|rechts|hochkant=2|Bildschirmaufnahme des Java-Programms [[Waldbrandsimulation/ SimForestFrame|SimForestFrame]] zur Simulation und Darstellung von sich ausbreitenden Waldbränden. Siehe auch '''Wikibook [[Waldbrandsimulation]]'''.]]
[[Datei:Programmierung.Java.Campingplatzraetsel.png|mini|rechts|hochkant=2|Bildschirmaufnahme des mit Maussteuerung interaktiven Java-Programms [[Campingplatzrätsel/ CampingplatzGraphs|CampingplatzGraphs]] zur Erstellung und Darstellung von Campingplatzrätseln. Siehe auch '''Wikibook [[Campingplatzrätsel]]'''.]]
[[Datei:Programmierung.Java.GameOfLife.png|mini|rechts|hochkant=2|Bildschirmaufnahme des Java-Programms &quot;GameOfLife&quot; zur Anzeige von Conways Spiel des Lebens. Siehe auch '''Wikibook [[Game of Life]]'''.]]

==Einleitung==
Das Buch '''Strukturierte Programmierung''' ist kein Lehrbuch zum Erlernen einer Programmiersprache, sondern soll als kleiner Leitfaden dazu dienen, besser strukturierte Programme erstellen zu können, selbst wenn die eingesetzten Programmiersprachen die strukturierte Programmierung weniger stark unterstützen.

&lt;big&gt;Warum lohnt es sich überhaupt, strukturiert zu programmieren&amp;nbsp;?&lt;/big&gt;

Es gibt eine ganze Reihe von naheliegenden Gründen, aber auch einige Vorteile, die nicht auf der Hand liegen oder jedermann sofort ersichtlich sind. Anfänger und Fortgeschrittene profitieren gleichermaßen von gut strukturierter Programmierung. Die Vorteile sind so erheblich, dass es unbedingt sinnvoll ist, gut strukturiert zu programmieren. Im Folgenden werden einige wichtige Vorteile aufgeführt und erläutert:

*'''Strukturierte Programme sind leichter nachvollziehbar.''' Dies erleichtert die Arbeit im Team und vereinfacht die Wartung, wenn der Quellcode ergänzt, geändert oder korrigiert werden muss.
*'''Strukturierte Programme haben weniger Programmierfehler.''' Dies reduziert die Entwicklungszeiten und erhöht die Akzeptanz bei den Auftraggebern und Nutzern der Software.
*'''Strukturierte Programme können ohne Laufzeit-Debugger erstellt werden.''' Dies spart enorm viel Zeit und Nerven bei der Entwicklung von Software.

Die geringen Laufzeiteinbußen, die bei hoch strukturierter Programmierung von Anwendungssoftware gegenüber laufzeitoptimiertem Code entstehen können, spielen –&amp;nbsp;sofern sie überhaupt existieren sollten&amp;nbsp;– bei den heutzutage zur Verfügung stehenden modernen und schnellen Rechenmaschinen praktisch keine Rolle mehr. Programmcode wegzulassen, der der inhärenten Betriebssicherheit von Software oder der inhärenten Datenintegrität dient, macht nur in sehr wenigen, extrem zeitkritischen Anwendungen Sinn, keineswegs jedoch bei herkömmlichen oder gar sicherheitskritischen Anwendungsprogrammen.

Die Ratschläge aus diesem Buch beruhen auf jahrzehntelanger Erfahrung mit der Softwareentwicklung komplexer Systeme und dem Hochschulunterricht im Fach Programmierung mit verschiedenen Programmiersprachen.

Die folgende Check-Liste enthalt eine Reihe von wichtigen Kriterien, die bei strukturierter Programmierung berücksichtigt werden sollten:

* &lt;big&gt;&lt;big&gt;'''[[Strukturierte Programmierung/ Checkliste|Checkliste]]'''&lt;/big&gt;&lt;/big&gt;

Übrigens: ''In der Kürze der Quelltextdatei liegt nicht die wahre Würze des Programmierens&amp;nbsp;!''

Und noch wichtiger:

:''So ists mit aller Bildung auch beschaffen:''
:''Vergebens werden ungebundne Geister''
:''Nach der Vollendung reiner Höhe streben.''

:''Wer Großes will, muß sich zusammenraffen;''
:''In der Beschränkung zeigt sich erst der Meister,''
:''Und das Gesetz nur kann uns Freiheit geben.''

::Johann Wolfgang von Goethe, Ende von ''Das Sonett''

Viel Erfolg beim strukturierten Programmieren wünscht [[Benutzer:Bautsch]]&amp;nbsp;!
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Quelltextgestaltung==
In diesem Abschnitt stehen einige Vorschläge zur allgemeinen Gestaltung der Quelltexte, die keine unmittelbare Auswirkung auf die Lauffähigkeit und die Funktion der Programme haben, aber dazu führen, dass der Quelltext besser verständlich und nachvollziehbar ist.

===Anweisungen===
Der Quelltext wird bei imperativen Programmiersprachen durch Anweisungen gestaltet, die ganz unterschiedlich geartet sein können. Zu den typischen und wichtigen Anweisungen gehören:

* Deklaration (declaration)
* Blockanweisung (block, begin / end)
* Zuweisung (assignment)
* Aufruf (call)
* Rücksprung (return)
* Verzweigung (branch)
* Schleife (loop)
* Sicherstellung (assertion)

Bei Kommentaren und Leerräumen (Leerzeichen, Tabulatoren, Zeilenumbrüche, ...) in Quelltexten handelt es sich nicht um Anweisungen, da sie vom Übersetzer (compiler) beziehungsweise Interpreter des Programmcodes ignoriert werden.

===Kommentare===
Jeder Quelltext sollte zu Beginn der Datei in einem von Compiler zu ignorierenden '''Kommentar''' für die Klarstellung des Inhalts einige Mindestangaben zum Inhalt und Ursprung machen. Dazu gehören beispielsweise die Autoren, Urheber oder Rechteinhaber, deren beabsichtigte Nutzungsarten/-rechte und Nutzungsbedingungen und weitere Angaben zur Lizenzierung, das Datum der Erstellung oder Veränderung, eine Versionsangabe und Angaben zur verwendeten Programmiersprache und gegebenenfalls zu den eingesetzten Programmbibliotheken (gegebenenfalls ebenfalls mit Versionsangaben). Ferner soll beschrieben werden, für welchen Zweck oder für welche Aufgabenstellungen das Programm eingesetzt werden kann. Darüber hinaus können und sollen auch weitere sinnvolle oder nützliche Angaben in diesem '''Kopfkommentar''' festgehalten werden.

Der Kommentartext wird bei vielen Programmiersprachen im Quelltext mit dem Symbolpaar &quot;/*&quot; und &quot;*/&quot; oder dem Symbolpaar &quot;(*&quot; und &quot;*)&quot; eingeschlossen.

Beispiel:

 /*
   Program: generation of pseudorandom numbers
   Author: Bautsch
   License: public domain
   Date: 7th January 2011
   Version: 1.0
   Programming language: Java
   Description: This program uses a primitive polynomial sequence with large prime coefficients to efficiently generate uniformly distributed pseudorandom numbers.
 */

Alle Methoden und Variablen werden ausreichend kommentiert, sofern sie nicht durch die Wahl „sprechender” Bezeichner selbsterklärend sind.

Bei Methoden werden insbesondere die Bedeutung aller Parameter und Rückgabewerte dokumentiert:

 /* The method &quot;add&quot; computes and returns the sum of &quot;summand1&quot; and &quot;summand2&quot; */
 double add (double summand1, double summand2)
 {
    double sum ← summand1 + summand2
    return sum
 }

Viele Entwicklungssysteme bieten Funktionen, die die Dokumentation der Quelltexte mit Kommentaren unterstützen.

Bei einigen Programmiersprachen ist Aufmerksamkeit geboten, wenn in der Sprachdefinition geschachtelte Kommentare nicht vorgesehen sind. Wird zum Beispiel während der Programmentwicklung Quelltext auskommentiert, um das Verhalten des modifizierten Programms zu überprüfen, und enthält dieser Quelltext einen Kommentar, ist dann nicht sofort erkennbar, welcher Abschnitt des Quelltextes tatsächlich auskommentiert werden soll. Dabei kann es auch vorkommen, dass einige Compiler die geschachtelten Kommentare erkennen und im eigentlichen Sinne des Programmierers berücksichtigen; andere Compiler, die sich streng an die standardisierten Sprachdefinitionen halten, jedoch nicht, so dass es bei der Portierung von Quellcode unweigerlich zu Übersetzungsfehlern kommt.

Das folgende Beispiel zeigt einen Programmabschnitt, bei dem hinter der letzten Anweisung zwischen den Zeichenfolgen &quot;/*&quot; und &quot;*/&quot; ein Textkommentar hinzugefügt wurde, der vom Compiler ignoriert werden soll.

 int i ← 1
 i ← i * i /* die Variable i wird quadriert. */

Wird zusätzlich mit den gleichen Zeichenfolgen &quot;/*&quot; und &quot;*/&quot; die gesamte Programmzeile auskommentiert, gibt es einen Übersetzungsfehler, wenn der Compiler die allerletzte Zeichenfolge &quot;*/&quot; als Kommentarende ohne Kommentaranfang interpretiert, sofern der zweite und nunmehr auskommentierte Kommentaranfang &quot;/*&quot; in der Zeile mit dem Textkommentar ignoriert wurde und die erste auftretende Zeichenfolge &quot;*/&quot; bereits als Kommentarende interpretiert wurde:

 int i ← 1
 /*
    i ← i * i /* die Variable i wird quadriert. */
 */

===Leerräume===
'''Leerräume''', also zum Beispiel Leerzeichen, Zeilen- und Seitenumbrüche oder Tabulatoren, werden - genauso wie Kommentare - von vielen Compilern überlesen und dienen in diesen Fällen ausschließlich zur Verbesserung der Lesbarkeit für die Programmierer. Daher sollten diese Leerräume sorgfältig eingesetzt werden, um die Nachvollziehbarkeit des Quellcodes für Programmierer zu erleichtern. Bei einigen Programmiersprachen werden allerdings bestimmte Formatierungen in der Sprachdefinition gefordert und müssen dann natürlich den Vorgaben entsprechend eingehalten werden.

Viele Entwicklungssysteme bieten sehr nützliche, unterstützende Funktionen zur einheitlichen Formatierung der Quelltexte, die sehr einfach anzuwenden sind und benutzt werden sollten. So ist es zum Beispiel allgemein üblich, Programmblöcke so zu formatieren, dass die Inhalte gegenüber dem Kopf und dem Fuß etwas eingerückt und durch Zeilenumbrüche voneinander getrennt werden:

 Blockkopf
    eingerückter Inhalt 1
    eingerückter Inhalt 2
 Blockfuß

Für die Einrückungen werden heute meist mehrere Leerzeichen oder ein Tabulatorzeichen verwendet. Neuerdings wird in manchen Programmiersprachen empfohlen, vier Leerzeichen zu verwenden. Manche Editoren fügen bei der Betätigung der Tabulatortaste eine gewünschte Anzahl von Leerzeichen ein. Das Mischen von mehreren Leerzeichen und Tabulatorzeichen für die Einrückungen kann nicht empfohlen werden, da dies bei der Bearbeitung mit verschiedenen Editoren zur uneinheitlichen Darstellung der Einrückungen führen kann. Moderne Editoren haben Funktionen, mit denen der gesamte Programmcode oder Teile davon einheitlich und korrekt eingerückt werden können (Englisch: &quot;correct indentation&quot;).

Siehe hierzu auch [[Strukturierte Programmierung#Blockanweisungen|Blockanweisungen]].

===Bezeichner===
In den meisten Programmiersprachen gibt es '''Bezeichner''' (oder '''Identifikatoren''', englisch: '''identifier''') für ganz unterschiedliche Dinge, wie für symbolische '''Konstanten''', für '''Variablen''', für '''Parameter''' oder '''Attribute''', für '''Methoden '''(respektive für '''Prozeduren''' oder für '''Funktionen'''), für '''Module''' (respektive für '''Klassen''') oder für '''Bibliotheken'''. Zur Strukturierung von Daten werden auch '''Pakete''' (englisch: '''packages''') eingesetzt.

In der Regel stehen alle Buchstaben ohne Diakritika zur Verfügung. Oft sind auch noch Ziffern und der Unterstrich &quot;_&quot; erlaubt. Das erste Zeichen muss üblicherweise immer ein Buchstabe sein. Leerzeichen sind innerhalb von Bezeichnern im Allgemeinen nicht zulässig.

Beim Lesen und Analysieren von Quelltexten ist es sehr hilfreich, wenn einem Bezeichner nicht nur beim ersten Auftauchen bei der Deklaration, sondern an jeder Stelle im Programm sofort angesehen werden kann, wofür er steht. Meist bildet sich für eine Gruppe von Programmiersprachen ein bestimmter Usus aus, wie die entsprechenden Bezeichner gestaltet werden sollen. Der Compiler stellt in der Regel keine Ansprüche an die Schreibweise von Bezeichnern, solange der definierte Zeichenvorrat verwendet wird. Eine Ausnahme stellen die vorgegebenen Schlüsselwörter dar, die häufig und je nach Programmiersprache nur aus Großbuchstaben oder nur aus Kleinbuchstaben bestehen, wie zum Beispiel:

* '''IMPORT''', '''CONST''', '''TYPE''', '''VAR''', '''PROCEDURE''', '''NIL''', '''LONG''', '''REAL''', '''BEGIN''', '''END''', '''WHILE'''
versus
* '''import''', '''final''', '''void''', '''static''', '''null''', '''long''', '''double''', '''while'''

In vielen Programmiersprachen haben sich für die frei definierbaren Bezeichner bestimmte Praktiken herausgebildet, damit die Bedeutung der Bezeichner im Quelltext von den beteiligten Programmierern leichter erkannt werden kann. Dieses Vorgehen ist allerdings nicht immer einheitlich gestaltet, wie anhand der folgenden, beispielhaften Liste gesehen werden kann:
* Die Bezeichner von übergeordnet verfügbaren Konstanten, Variablen, Datentypen, Klassen oder Modulen beginnen mit '''einem Großbuchstaben'''.
* Die Bezeichner von Konstanten werden '''vollständig mit Großbuchstaben''' geschrieben.
* Die Bezeichner von lokal verfügbaren Variablen, Attributen oder Parametern werden '''vollständig mit Kleinbuchstaben''' geschrieben.
* Die Bezeichner von Methoden werden '''vollständig mit Kleinbuchstaben''' geschrieben.

====Variablen und Methoden====
So ist es zum Beispiel üblich, Variablen und Methoden mit Kleinbuchstaben zu benennen. Dabei ist der Unterschied zwischen Variable und Methode immer und einfach anhand der obligatorischen Parameterliste von Methoden zu erkennen, die beim Fehlen von Parametern leer ist und in vielen Programmiersprachen durch runde Klammern begrenzt ist und direkt hinter dem Methodennamen steht:

 /* &quot;diameter&quot; is variable of the data type integer */
 int diameter
 
 /* &quot;radius&quot; is variable (parameter of the function &quot;calcDiameter&quot;) of the data type integer */
 /* &quot;calcDiameter&quot; is a function */
 /* the result of the function call has the data type integer */
 int calcDiameter (int radius)

&quot;calcDiameter&quot; ist hierbei mit dem Binnenmajuskel &quot;D&quot; versehen (umgangssprachlich auch &quot;Kamelhöcker-Notation&quot; genannt, englisch &quot;camel case&quot;), um den Anfang eines neuen Wortes ohne die Verwendung eines Leerzeichens erkennbar zu machen.

Es ist im Sinne der guten Lesbarkeit des Quelltextes allgemein hilfreich, in Bezeichnern immer passende grammatische Formen zu verwenden, wie zum Beispiel:
* für booleschen Variablen und Funktionen: Partizipien oder Adjektive
* für andere Variablen und Funktionen: Substantive
* für Methoden und Kommandos: Verben im Imperativ

In manchen Programmiersprachen ist es üblich, lokale Variablen mit einem Kleinbuchstaben zu beginnen und globale Variablen - also in mehreren Programmodulen, Klassen oder Methoden sichtbare Variablen - mit einem Großbuchstaben zu beginnen, um deren Sichtbarkeiten unmittelbar erkennbar zu machen.

====Konstanten====
Die Werte von Konstanten können zur Laufzeit nicht mehr verändert werden. Dieser Umstand wird dem Compiler bei der Deklaration der Konstanten durch entsprechende Deklarationen (wie zum Beispiel &quot;CONST&quot;) oder Modifikatoren (wie zum Beispiel &quot;final&quot;) mitgeteilt.

Damit an jeder Stelle des Quelltextes, also auch nach der Deklaration, erkannt werden kann, dass es sich um eine Konstante handelt, ist es hilfreich Konstanten mit einem '''Großbuchstaben''' beginnen zu lassen; manchmal werden für Konstanten sogar ausschließlich Großbuchstaben verwendet.

Es ist empfehlenswert, die Initialisierung einer Konstanten immer unmittelbar im Kontext der Deklaration vorzunehmen, damit es keine Mehrdeutigkeiten und somit auch keine Verwechslungen durch undefinierte Werte geben kann. Wenn dies nicht sinnvoll erscheint, sollte vorzugsweise keine Konstante verwendet werden. In vielen modernen Programmiersprachen ist es möglich, Klassenvariablen beziehungsweise globale Variablen zu schützen, indem diese nur innerhalb einer Klasse beziehungsweise innerhalb eines Moduls verändert werden dürfen. In diesem Fall gibt es von Außerhalb nur einen Lesezugriff auf den Wert der Variablen (&quot;read-only&quot;), oder der aktuelle Wert der Variablen kann durch den Aufruf eines Unterprogramms zurückgegeben werden (&quot;get&quot;-Methoden).

&lt;syntaxhighlight lang=&quot;Pascal&quot;&gt;
(* Programmiersprache Component Pascal *)

MODULE Zahlen;

(* Auf die globale ganzzahlige Konstante &quot;Konstante&quot; kann nur lesend zugegriffen werden. *)
(* Die globale Konstante &quot;Konstante&quot; ist durch Deklaration und Initialisierung vollständig definiert. *)
CONST
	Konstante = 7;

(* Auf die globale ganzzahlige Variable &quot;zahl&quot; kann von außerhalb des Moduls &quot;Zahlen&quot; nur lesend zugegriffen werden. *)
(* Die globale Variable &quot;zahl&quot; wird mit dem Zusatz &quot;-&quot; als &quot;read-only&quot; deklariert. *)
VAR
	zahl-: LONGINT;

BEGIN
	(* Die globale Variable &quot;zahl&quot; wird mit einem Wert initialisiert. *)
	zahl := 8;
END Zahlen.
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Zahlen;
{
	// Auf die öffentliche ganzzahlige Klassenkonstante &quot;Konstante&quot; kann nur lesend zugegriffen werden.
	// Die Klassenkonstante &quot;Konstante&quot; ist durch Deklaration und Initialisierung vollständig definiert.
	// Die Klassenkonstante &quot;Konstante&quot; wird mit dem Zusatz &quot;final&quot; deklariert.
	public static final long Konstante = 7;

	// Auf die nicht-öffentliche ganzzahlige Klassenvariable &quot;zahl&quot; kann von außerhalb der Klasse
	// nur über die öffentliche Methode &quot;getZahl ()&quot; lesend zugegriffen werden.
	// Die Klassenvariable &quot;zahl&quot; wird mit dem Zusatz &quot;private&quot; deklariert.
	private static long zahl = 8;

	public static long getZahl ()
	{
		return zahl;
	}
}
&lt;/syntaxhighlight&gt;

Im folgenden Java-Beispiel wird eine als konstant deklarierte lokale Variable erst innerhalb einer Fallunterscheidung (if-Anweisung) und zudem mit zwei verschiedenen optionalen Werten initialisiert. Wenn die Deklaration und die optionalen Initialisierungen im Quelltext weiter auseinanderliegen, ist es schwierig, den definierten Zustand der vermeintlich eindeutig definierten Variablen vollständig zu erfassen.

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
private static boolean boolescherAusdruck ()
{
	java.util.Random zufall = new java.util.Random ();
	boolean zufaelligerBoolescherWert = zufall.nextBoolean ();
	return zufaelligerBoolescherWert;
}

public static void main (java.lang.String [] arguments)
{
	// Deklaration der lokalen Konstante &quot;Zahl&quot;,
	// die wegen fehlender Initialisierung nicht definiert ist.
	final long Zahl;

	if (boolescherAusdruck ())
	{
		Zahl = 7;
	}
	else
	{
		Zahl = 8;
	}
	java.lang.System.out.println (&quot;Konstante Zahl = &quot; + Zahl);
}
&lt;/syntaxhighlight&gt;

====Klassen und Module====
Auch Unterprogrammeinheiten wie '''Module''' oder '''Klassen''' werden in der Regel mit eindeutigen Bezeichnern benannt, die üblicherweise mit einem '''Großbuchstaben''' beginnen.

Im Kontext eines Quellcodes ist es immer möglich, diese Unterprogrammeinheiten von anderen zu unterscheiden, die ebenfalls mit einem Großbuchstaben beginnen (beispielsweise Konstanten), weil die Bezeichner von Unterprogrammeinheiten von einer Blockanweisung (zum Beispiel geschweifte Klammern) für die Implementation von Programmcode oder von einem Separator (beispielsweise &quot;.&quot;) zur qualifizierten Bezeichnung von Teilen der Unterprogrammeinheiten gefolgt werden.

Das Konzept von Unterprogrammeinheiten ist, dass mehrere Unterprogramme (Methoden, Prozeduren, Funktionen, Kommandos) sowie mehrere Konstanten, Variablen oder Datenstrukturen (Verbunde (struct, record), Arrays) in einer speicherbaren Datei zusammengefasst werden. Insofern handelt es sich bei solchen Unterprogrammeinheiten um die '''kleinsten dauerhaft speicherbaren Einheiten''' in einem Software-Projekten.

Unterprogrammeinheiten werden in strukturierten Programmiersprachen unter der Verwendung von Schlüsselwörtern wie zum Beispiel &quot;program&quot;, &quot;MODULE&quot; oder &quot;class&quot; '''deklariert''':

&lt;syntaxhighlight lang=&quot;Pascal&quot;&gt;
(* Die Unterprogrammeinheit &quot;Programmeinheit&quot; in der Programmiersprache Pascal *)
program Programmeinheit;
begin
end.
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;modula2&quot;&gt;
(* Die Unterprogrammeinheit &quot;Programmeinheit&quot; in den Programmiersprachen Modula-2, Oberon oder Component Pascal *)
MODULE Programmeinheit;
BEGIN
END Programmeinheit.
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
// Die Unterprogrammeinheit &quot;Programmeinheit&quot; in der Programmiersprache Java
public class Programmeinheit;
{
}
&lt;/syntaxhighlight&gt;

====„Sprechende” Bezeichner====
Die Wahl '''„sprechender“ Bezeichner''' hilft beim Lesen, Verstehen und Nachvollziehen von Quelltext ungemein. Häufig erübrigt sich sogar ein erläuternder Kommentar, wenn mit hinreichend „sprechenden“ Variablen- beziehungsweise Methodennamen gearbeitet wird.

Also nicht eine solche Anweisung:

 h ← (t – b)

Sondern besser:

 height ← (top - bottom)

Die verpasste Chance, einen Bezeichner sprechend zu benennen, kann in vielen Entwicklungssystemen durch sogenanntes ''Refactoring'' zentral für den gesamten Quelltext durch Umbenennung geheilt werden.

====Parameter====
Bei Methodenaufrufen werden '''alle Parameter''' mit Variablen oder mit Konstanten übergeben, also nicht mit '''komplexen Ausdrücken''' (beispielsweise arithmetische Berechnungen und Aufrufe von Unterprogrammen) oder mit '''Literalen''' (also direkt eingegebene Werte, wie 100 oder &quot;Text&quot;).

Hier ein schlechtes Beispiel mit dem Aufruf des Java-Unterprogramms &quot;zeichneRechteck&quot; mit fünf kryptischen Parameterausdrücken in den runden Klammern. Jedes der fünf Literalen 50 hat eine eigene unabhängige Bedeutung, die bei dieser Schreibweise nicht unterschieden oder nachvollzogen werden können, was deswegen schnell zu Verwechslungen führen kann:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   zeichneRechteck (50, 50, 50, berechneHoehe (50), 50);
&lt;/syntaxhighlight&gt;

Ein strukturiertes Programm weist die Werte für alle fünf Parameter vor dem Aufruf des Unterprogramms an eigene Variablen mit sprechenden Bezeichnern zu:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   int x = 50;
   int y = 50;
   int breite = 50;
   int hoehe = berechneHoehe (breite);
   int helligkeitProzent = 50;
   zeichneRechteck (x, y, breite, hoehe, helligkeitProzent);
&lt;/syntaxhighlight&gt;

Diese Anweisungsfolge ist im Gegensatz zu der Anweisung darüber auch ohne die explizite Kenntnisnahme der '''Deklaration des Unterprogramms''' verständlich:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   /**
   * Zeichnet ein Rechteck in das Bildschirmfenster
   * @param x: x-Koordinate vom linken Bildschirmfensterrand nach rechts
   * @param y: y-Koordinate vom oberen Bildschirmfensterrand nach unten
   * @param breite: Breite des Rechtecks von x nach rechts
   * @param hoehe: Hoehe des Rechtecks von y nach unten
   * @param helligkeitProzent: Helligkeit des Rechtecks in Prozent (0 = schwarz, 100 = weiss)
   */
   public static void zeichneRechteck (int x, int y, int breite, int hoehe, int helligkeitProzent)
&lt;/syntaxhighlight&gt;

====Qualifizierte Bezeichner====
=====Programmeinheiten=====
Damit der sich hinter einem Bezeichner verborgene Inhalt eindeutig einer Programmeinheit zugeordnet werden kann, muss dieser '''qualifiziert bezeichnet''' werden.

In manchen Programmiersprachen geschieht dies für bestimmte Bezeichner inhärent, obwohl es eine explizite import-Anweisung für die entsprechenden Bezeichner gibt, so dass die Programmierer in diesen Sonderfällen also wissen müssen, worauf sich der unqualifizierte Bezeichner bezieht. In der Programmiersprache Java dürfen häufig verwendete Bezeichner wie beispielsweise die zur Textausgabe verwendete Methode &quot;print&quot; aus der Klasse &quot;System&quot; oder die für Zeichenketten verwendete Klasse &quot;String&quot; ohne eine vollständige und qualifizierte Bezeichnung in den Programmtext geschrieben werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   String text = &quot;Hallo Welt!&quot;;
   System.out.print (text);
&lt;/syntaxhighlight&gt;

In der Variablen &quot;text&quot; der Klasse &quot;String&quot; wird die Zeichenkette &quot;Hallo Welt!&quot; gespeichert und mit der klassengebundenen Methode &quot;print&quot; der Klassenvariablen &quot;out&quot; aus der Klasse &quot;System&quot; ausgegeben. Hier ist allerdings nicht ohne weiteres ersichtlich, wo sich die Deklarationen oder die Implementierungen beiden Klassen &quot;String&quot; und &quot;System&quot; befinden.

Die '''qualifizierte Bezeichnung''' dieser beiden Anweisungen hat folgendes Aussehen:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   java.lang.String text = &quot;Hallo Welt!&quot;;
   java.lang.System.out.print (text);
&lt;/syntaxhighlight&gt;

Durch die qualifizierte Bezeichnung wird klar, dass sich beide Klassen im Programmpaket &quot;java.lang&quot; des Programmmoduls &quot;java.base&quot; befinden. Jedes Modul (englisch &quot;module&quot;) und jedes Paket (englisch &quot;package&quot;) kann in der Systembibliothek der Programmiersprache beziehungsweise in der Programmbibliothek der Laufzeitumgebung eindeutig zugeordnet werden.

Alternativ wird die Qualifikation von bestimmten Bezeichnern durch eine Import-Anweisung zu Beginn des Programms vorgenommen:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   import java.lang.String;
   import java.lang.System;

//...

      String text = &quot;Hallo Welt!&quot;;
      System.out.print (text);
&lt;/syntaxhighlight&gt;

Dieses Vorgehen erlaubt innerhalb einer Programmdatei zwar grundsätzlich eine korrekte und eindeutige Zuordnung der weiter unten im Programmtext verwendeten '''unqualifizierten''' Bezeichner, bei der Analyse des Programmtextes sind sämtliche Import-Anweisungen jedoch stets und vollständig zu berücksichtigen, was die Sache für die Programmierer insbesondere bei langen oder komplexen Quelltexten sehr erschweren kann. Dies kann durch die ausschließliche und obligatorische Verwendung von qualifizierten Bezeichnern ausgeschlossen werden, und deswegen wird von streng strukturierten Programmiersprachen überall und immer eine qualifizierte Bezeichnung gefordert.

Leider dürfen diese qualifizierten Importe beziehungsweise Bezeichnungen in manchen Programmiersprachen für gängige Unterprogrammeinheiten weggelassen werden, wie im folgenden Beispiel in der Programmiersprache Java:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
public class Test
{
   public static void main (String [] args)
   {
   }
}
&lt;/syntaxhighlight&gt;

Ein Aufruf des formal korrekt deklarierten Hauptprogramms &quot;main&quot; kann zu folgender völlig irritierender Fehlermeldung führen, wenn gar nicht die dafür vorgesehene Standard-Java-Klasse &quot;java.lang.String&quot; referenziert wird, weil sich im Software-Projekt, in dem sich das Hauptprogramm befindet, eine gleichnamige Klasse &quot;String&quot; definiert ist, die durch die Regeln der Programmiersprache vorrangig referenziert wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
Error: Main method not found in class Test, please define the main method as: public static void main (String [] args)
&lt;/syntaxhighlight&gt;

=====Datenstrukturen=====
Auch bei Datenstrukturen müssen qualifizierte Bezeichner verwendet werden, damit eindeutig auf bestimmte Datenfelder zugegriffen werden kann. Im folgenden Beispiel in der Syntax der '''Pascal'''-Programmiersprachenfamilie wird dies anhand des komplexen Datentyps &quot;Postadresse&quot; mit den sechs Attributen &quot;vorname&quot;, &quot;nachname&quot;, &quot;strasse&quot;, &quot;hausnummer&quot;, &quot;postleitzahl&quot; und &quot;ort&quot; dargestellt:

&lt;syntaxhighlight lang=&quot;Pascal&quot;&gt;
   (* Datentyp &quot;Postadresse&quot; *)
   TYPE Postadresse =
      RECORD
         vorname: ARRAY OF CHAR;
         nachname: ARRAY OF CHAR;
         strasse: ARRAY OF CHAR;
         hausnummer: ARRAY OF CHAR;
         postleitzahl: LONGINT;
         ort: ARRAY OF CHAR;
      END;
&lt;/syntaxhighlight&gt;

In den Deklarationen der Attribute steht &quot;ARRAY OF CHAR&quot; für den Datentyp Zeichenkette, der zur Speicherung von Zeichenfolgen verwendet wird. Der Datentyp &quot;LONGINT&quot; dient zur Speicherung ganzer Zahlen.

Eine Instanz &quot;adresse&quot; dieses Datentyps &quot;Postadresse&quot; kann wie folgt mit der NEW-Prozedur erzeugt werden, wobei der dafür erforderliche Speicherplatz festgelegt und für andere Verwendungen gesperrt wird. Auf die sechs einzelnen Datenfelder der in &quot;adresse&quot; gespeicherten sechs Attribute des Datentyps &quot;Postadresse&quot; kann danach im Programm mit den entsprechenden qualifizierten Bezeichnern beispielsweise zugegriffen werden, indem die jeweiligen initialen Werte mithilfe des Zuweisungsoperators := zugewiesen werden. Auf die Prozeduren &quot;String&quot; und &quot;Int&quot; aus dem Modul &quot;Out&quot; wird über &quot;Out.String&quot; und &quot;Out.Int&quot; ebenfalls qualifiziert zugegriffen:

&lt;syntaxhighlight lang=&quot;Pascal&quot;&gt;
   IMPORT
      Out; (* Import des Moduls &quot;Out&quot; mit den Textausgabe-Prozeduren &quot;String&quot; für Zeichenketten und &quot;Int&quot; für ganze Zahlen *)
   VAR
      adresse: Postadresse; (* globale Variable &quot;adresse&quot; *)
   BEGIN
      NEW (adresse);  (* Speicherreservierung für den Bezeichner &quot;adresse&quot; *)
      adresse.vorname := &quot;Irgend&quot;;
      adresse.nachname := &quot;Jemand&quot;;
      adresse.strasse := &quot;Allee&quot;;
      adresse.hausnummer := &quot;100&quot;;
      adresse.postleitzahl := 10000;
      adresse.ort := &quot;Irgendwo&quot;;

      Out.String (adresse.vorname);
      Out.String (adresse.nachname);
      Out.String (adresse.strasse);
      Out.String (adresse.hausnummer);
      Out.Int (adresse.postleitzahl);
      Out.String (adresse.ort);
   END;
&lt;/syntaxhighlight&gt;

In einem weiteren Beispiel mit der Syntax der Programmiersprache '''Java''' wird die Datenstruktur dieses komplexen Datentyps als Klasse &quot;Postadresse&quot; mit den sechs Instanzvariablen &quot;vorname&quot;, &quot;nachname&quot;, &quot;strasse&quot;, &quot;hausnummer&quot;, &quot;postleitzahl&quot; und &quot;ort&quot; für diese sechs Attribute gebildet. Eine Instanz dieses Datentyps kann hier mit dem new-Operator erzeugt werden. Der öffentliche Konstruktor &quot;Postadresse ()&quot; ist eine Methode mit derselben Bezeichnung wie die Klasse selbst, die aufgerufen werden muss, um die sechs Datenfelder der jeweiligen Instanz &quot;this&quot; zu initialisieren. Auf die einzelnen Datenfelder der in der nicht-öffentlichen Klassenvariable &quot;adresse&quot; gespeicherten sechs Attribute des Datentyps &quot;Postadresse&quot; kann danach über die entsprechenden sechs qualifizierten Bezeichner zugegriffen werden. In der Methode &quot;main&quot; werden die Attribute zwischen den runden Klammern über die qualifizierten Bezeichner als Parameter bei den Aufrufen der allgemeinen Textausgabe-Methode &quot;println&quot; verwendet, die zur Klassenvariable &quot;out&quot; der Klasse &quot;System&quot; im Programmpaket &quot;java.lang&quot; gehört:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
public class Postadresse // Klasse &quot;Postadresse&quot;
{
   // Instanzvariablen
   java.lang.String vorname;
   java.lang.String nachname;
   java.lang.String strasse;
   java.lang.String hausnummer;
   long postleitzahl;
   java.lang.String ort;

   private static Postadresse adresse = new Postadresse (); // Klassenvariable &quot;adresse&quot;

   public Postadresse () // Konstruktor der Klasse &quot;Postadresse&quot;
   {
      this.vorname = &quot;Irgend&quot;;
      this.nachname = &quot;Jemand&quot;;
      this.strasse = &quot;Allee&quot;;
      this.hausnummer = &quot;100&quot;;
      this.postleitzahl = 10000;
      this.ort = &quot;Irgendwo&quot;;
   }

   public static void main (java.lang.String [] argumente) // main-Methode der Klasse &quot;Postadresse&quot;
   {
      java.lang.System.out.println (adresse.vorname);
      java.lang.System.out.println (adresse.nachname);
      java.lang.System.out.println (adresse.strasse);
      java.lang.System.out.println (adresse.hausnummer);
      java.lang.System.out.println (adresse.postleitzahl);
      java.lang.System.out.println (adresse.ort);
   }
}
&lt;/syntaxhighlight&gt;

====Komplexe Anweisungen====
In der Programmiersprache Java kann die Gestaltung eines softwaretechnischen Containers &quot;host&quot; beispielsweise mit der Variablen &quot;layout&quot; realisiert werden. Hierzu werden Instanzen von Objekten der Klassen &quot;Container&quot; und &quot;GroupLayout&quot; erzeugt:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   java.awt.Container host = new java.awt.Container ();
   javax.swing.GroupLayout layout = new javax.swing.GroupLayout (host);
&lt;/syntaxhighlight&gt;

Eine multiple qualifizierte Bezeichnung zur Referenzierung von Datenfeldern mit diversen Aufrufen typengebundener Methoden (Unterprogramme) kann dann mit einer einzigen hyperkomplexen Anweisung in einer Zeile zusammengefasst werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   layout.setVerticalGroup (layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING).addGroup (layout.createSequentialGroup ().addContainerGap ().addGroup(layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING).addGroup (layout.createSequentialGroup().addGroup (layout.createParallelGroup (javax.swing.GroupLayout.Alignment.BASELINE))))));
&lt;/syntaxhighlight&gt;

Mit Zeilenumbrüchen wird der inhaltlich identische Quelltext schon besser nachvollziehbar:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   layout.setVerticalGroup
   (
      layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING)
      .addGroup (layout.createSequentialGroup ()
      .addContainerGap ()
      .addGroup (layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING)
      .addGroup (layout.createSequentialGroup()
      .addGroup (layout.createParallelGroup (javax.swing.GroupLayout.Alignment.BASELINE)))))
   );
&lt;/syntaxhighlight&gt;

Durch Verwendung von Hilfsvariablen mit sprechenden Bezeichnern wird der Quelltext zwar etwas länger, aber noch verständlicher. Die Komplexität ist deutlich reduziert, und die Anweisungsfolge kann viel einfacher nachvollzogen, überprüft oder angepasst werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
      javax.swing.GroupLayout.SequentialGroup sequentialGroup2 = layout.createSequentialGroup ();
      javax.swing.GroupLayout.ParallelGroup parallelBaselineGroup = layout.createParallelGroup (javax.swing.GroupLayout.Alignment.BASELINE);
      sequentialGroup2 = sequentialGroup2.addGroup (parallelBaselineGroup);

      javax.swing.GroupLayout.ParallelGroup parallelLeadingGroup2 = layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING);
      parallelLeadingGroup2 = parallelLeadingGroup2.addGroup (sequentialGroup2);

      javax.swing.GroupLayout.SequentialGroup sequentialGroup1 = layout.createSequentialGroup ();
      sequentialGroup1 = sequentialGroup1.addContainerGap ();
      sequentialGroup1 = sequentialGroup1.addGroup (parallelLeadingGroup2);

      javax.swing.GroupLayout.ParallelGroup parallelLeadingGroup1 = layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING);
      parallelLeadingGroup1 = parallelLeadingGroup1.addGroup (sequentialGroup1);

      layout.setVerticalGroup (parallelLeadingGroup1);
&lt;/syntaxhighlight&gt;

==Programmgestaltung==
Idealerweise kann die kontextfreie Grammatik der verwendeten Programmiersprache mit einer strukturierten Metasprache, wie zum Beispiel der '''Erweiterten Backus-Naur-Form''' ('''EBNF''') nach der Norm ISO/IEC 14977 dargestellt werden. Jedes strukturierte Programm und jede Datenstruktur kann damit eindeutig definiert werden. Leider trifft dies für viele Programmiersprachen nicht zu. Die Darstellung beliebiger ganzer Zahlen (sowohl negative, als auch positive und die Null) mit Zeichen kann in der Erweiterten Backus-Naur-Form zum Beispiel schrittweise so definiert werden:

&lt;syntaxhighlight lang=&quot;ebnf&quot;&gt;
 NatuerlicheZiffer = &quot;1&quot; | &quot;2&quot; | &quot;3&quot; | &quot;4&quot; | &quot;5&quot; | &quot;6&quot; | &quot;7&quot; | &quot;8&quot; | &quot;9&quot;;
 Ziffer = &quot;0&quot; | NatuerlicheZiffer;
 NatuerlicheZahl = NatuerlicheZiffer{Ziffer};
 GanzeZahl = &quot;0&quot; | [&quot;-&quot;]NatuerlicheZahl;
&lt;/syntaxhighlight&gt;

[[Datei:Nassi-Shneiderman diagram - InsertionSort.svg|mini|rechts|hochkant=2|Beispiel für einen Algorithmus mit zwei geschachtelten, kopfgesteuerten Schleifen in der Darstellung als Nassi-Shneidermann-Diagramm.]]

Programme können als '''Struktogramm''' (auch '''Nassi-Shneidermann-Diagramm genannt''') nach Norm DIN 66261 notiert werden. Alle Teilprogramme sind dabei so geartet, dass sie ausgehend von einem einfachen Hauptblock, der für das gesamte Programm und somit für mindestens einen Unterprogrammaufruf steht, durch schrittweise Verfeinerung hierarchisch zusammengesetzt werden können. Am Ende der Hierarchie stehen dann elementare Teilprogramme, die nicht weiter zerlegt werden können.

Die zyklomatische Komplexität der Software kann zum Beispiel mit der '''McCabe-Metrik''' untersucht und analysiert werden. Hierbei sollte darauf geachtet werden, dass die Komplexität beschränkt bleibt, damit der Quelltext überschaubar bleibt und gut nachvollzogen werden kann. Durch geeignete Strukturierung ist dies in modernen Programmiersprachen immer möglich, und mit einer McCabe-Metrik bis maximal 10 ist die Komplexität meist hinreichend niedrig.

Dies gilt nicht nur für den prozeduralen Programmablauf, sondern gleichermaßen für Datenstrukturen, bei denen komplexe Datentypen aus elementaren Datentypen übersichtlich und hierarchisch zusammengesetzt werden können.

Wichtig ist, dass die Anzahl der Programmzeilen ('''lines of code''') zwar gut als Maß für das zeitliche Wachstum einer bestimmten Software herangezogen werden kann, dies jedoch nicht geeignet ist, um eine Aussage über die Qualität oder Strukturiertheit des Programmcodes zu treffen. Weder eine besonders kleine noch eine besonders große Anzahl von Programmzeilen sind ein Garant für guten oder strukturierten Code.

Das Optimum ist nicht erreicht, wenn nichts mehr hinzugefügt werden kann, weil schon alles implementiert ist, sondern wenn nichts mehr entfernt werden kann, ohne dass die Implementierung hiervon beeinträchtigt wird (frei nach Antoine de Saint-Exupéry in ''Wind, Sand und Sterne - Terre des Hommes'' (1939)).

Programmieren ist nicht nur ein einfaches Handwerk, sondern eine anspruchsvolle Kunstfertigkeit (vergleiche auch Donald E. Knuth: ''The Art of Computer Programming'').
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

===Sichtbarkeiten===
Grundsätzlich gilt immer das '''Prinzip der Lokalität'''. Dies bedeutet, dass auf Programmkonstrukte nur dort zugegriffen werden kann und darf, wo es unbedingt erforderlich ist. Zum Datenaustausch zwischen verschiedenen Programmteilen dienen unter diesen Voraussetzungen Schnittstellen, die in der strukturierten Programmierung exakt definiert sein müssen.

Alle Klassenvariablen, Instanzvariablen und Parametervariablen sowie Rückgabewerte werden in Bezug auf ihre Teilprogramme zum Beispiel als '''lokale Variablen''' behandelt, so dass sie nur innerhalb dieser Teilprogramme aufgerufen und verändert werden können. Auf diese Weise können unbeabsichtigte und unerwünschte Seiteneffekte nachhaltig vermieden werden.

Je weniger lokal eine Variable definiert ist, desto größer ist die Gefahr, dass diese unbeabsichtigt oder sogar zuwider den Absichten des Programmierers verändert werden kann, was dann zu entsprechend dramatischen und schwer identifizierbaren Programmfehlern führen kann, die zudem erst zur Laufzeit auftreten und oft nur zufällig und somit umso schwerer zu entdecken sind. Variablen sollen also immer so '''lokal''' wie möglich definiert werden. Am besten sind Variablen lokalisiert, wenn sie innerhalb der Teilstruktur definiert werden, wo die Variablen üblicherweise „sichtbar” (und demzufolge verwendbar) sind. Außerhalb der Blöcke sind diese Variablen dann „unsichtbar” und somit auch nicht benutzbar.

Für Programmiersprachen die keine explizite Blockanweisung für Teilprogramme haben, ist die am stärksten lokalisierte Definition in der Regel innerhalb einer Methode respektive einer Prozedur oder einer Funktion. Die nächsthöhere Strukturebene ist dann - sofern möglich - das Modul beziehungsweise die Klasse (dies ist zwar häufig eine vom Compiler zu übersetzende Einheit, ist jedoch nicht unbedingt identisch mit einer Quelltextdatei). Innerhalb von Programmstrukturen sollten Variablen möglichst mit dem Sichtbarkeitsmodifikator für die ausschließlich interne Verwendbarkeit (zum Beispiel mit dem Modifikator ''private'' oder ''limited'') deklariert werden. Solche internen Variablen können dann gegebenenfalls mit entsprechend zu implementierenden Konstruktoren initialisiert, mit sogenannten Getter-Methoden abgefragt und mit Setter-Methoden verändert werden. Falls diese exportiert werden (beispielsweise mit dem Modifikator ''public'' oder ''export''), ist auch außerhalb der Deklarationsstruktur ein definierter indirekter Zugriff auf die internen Variablen möglich.

Manche Programmiersprachen erlauben eine Deklaration, die außerhalb des Deklarationsbereiches nur gesehen respektive gelesen werden können (zum Beispiel mit dem Modifikator ''read-only'' für Variablen oder ''implement-only'' für Methoden). In diesem Fall können die entsprechenden Variablen oder Methoden außerhalb der Deklarationsstruktur also nicht verändert, aber zumindest abgefragt oder aufgerufen werden.

'''Globale Variablen''', die überall innerhalb von großen Programmeinheiten verändert werden können, sind immer vermeidbar, erhöhen die Gefahr von Programmfehlern und erleichtern unter Umständen Cyber-Attacken.

Besondere Probleme ergeben sich, wenn innerhalb eines Sichtbarkeitsbereiches für verschiedene Dinge gleichlautende '''Bezeichner''' verwendet werden dürfen. Dies kann wegen der Wahlfreiheit bei der Benennung sehr leicht vermieden werden, indem einfach keine gleichlautenden Bezeichner benutzt werden. Im folgenden Beispiel wird verdeutlicht, wie in einem Java-Programm zwischen den Bezeichnern von lokalen und globalen Variablen sowie von Methoden formal dennoch eindeutig unterschieden werden kann:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
public class Bezeichner
{
	// globale Variable &quot;bezeichner&quot; (Klassenvariable)
	private static long bezeichner = 1;

	// Methode &quot;bezeichner&quot; (Unterprogramm)
	private static long bezeichner ()
	{
		// lokale Variable &quot;bezeichner&quot; in der Methode &quot;bezeichner&quot;
		long bezeichner = 3;
		return bezeichner;
	}

	// Hauptprogramm (Methode &quot;main&quot;)
	public static void main (java.lang.String [] argumente)
	{
		// Ausgabe der globalen Variable aus der Klasse &quot;Bezeichner&quot;
		java.lang.System.out.println (&quot;Wert der globalen Variable = &quot; + Bezeichner.bezeichner);

		// lokale Variable &quot;bezeichner&quot; in der Methode &quot;main&quot;
		long bezeichner = 2;
		// Ausgabe der lokalen Variable aus der Methode &quot;main&quot;
		java.lang.System.out.println (&quot;Wert der lokalen Variable = &quot; + bezeichner);

		// Ausgabe des Ergebnisses des Aufrufs der Methode &quot;bezeichner&quot;
		java.lang.System.out.println (&quot;Wert des Unterprogramms = &quot; + bezeichner ());
	}
}
&lt;/syntaxhighlight&gt;

In dieser Java-Klasse &quot;Bezeichner&quot; gibt es vier gleichlautende Bezeichner &quot;bezeichner&quot;:

* Der Name einer '''globalen Klassenvariable'''.
* Der Name einer '''Methode'''.
* Der Name einer '''lokalen Variable''' in der Methode &quot;bezeichner&quot;.
* Der Name einer '''lokalen Variable''' in der Methode &quot;main&quot;.

Nach den Regeln der Programmiersprache Java haben lokale Bezeichner bei der Referenzierung innerhalb einer Blockanweisung Vorrang, so dass bei der Verwendung dieser Bezeichner immer auf die lokale Variable zugegriffen wird. Im obigen Beispiel haben die beiden lokalen Variablen &quot;'''bezeichner'''&quot; nichts miteinander zu tun und können nur in ihrer entsprechenden Methode referenziert werden. Soll in einem lokalen Sichtbarkeitsbereich auf die globale Klassenvariable referenziert werden, so kann dies durch einen expliziten und '''qualifizierten Bezeichner''' erwirkt und sichergestellt werden, im obigen Beispiel mit &quot;'''Bezeichner.bezeichner'''&quot;. Der Bezeichner einer Methode kann durch das stets folgende runde Klammerpaar identifiziert werden, im obigen Beispiel &quot;'''bezeichner ()'''&quot;.

===Modularisierung===
Teilprogramme können Methoden oder ganze Sammlungen von Datenstrukturen und Methoden sein. Diese werden oft '''Klassen''' oder '''Module''' genannt und können in '''Paketen''' gruppiert werden. Alle Teilprogramme sollen eindeutige und sprechende Bezeichner und streng definierte Signaturen und Schnittstellen für die Namen und die Datentypen aller Parameter beziehungsweise Klassen- und Instanzvariablen haben. Bei diesen Teilprogrammen handelt es sich in der Regel um die kleinsten dauerhaft speicherbaren Programmeinheiten, die zum Beispiel in einer Datenbank oder einem Dateisystem zu größeren Einheiten wie Verzeichnissen, Paketen oder Bibliotheken zusammengefasst werden.

Solche Programmeinheiten werden durch ihre '''Signatur''' eindeutig gekennzeichnet. Die Signatur besteht zunächst aus dem '''Namen''' der Programmeinheit. Ferner kann mit einem Modifikator explizit definiert werden, dass diese Programmeinheit allgemein, also von allen und beliebigen anderen Programmeinheiten, verfügbar sein soll (Modifikator ''public'' / ''öffentlich''). Für eine Beschränkung nur auf die nächst höhere Programmeinheit, wie beispielsweise einem Paket (englisch &quot;package&quot;), kann der Modifikator ''private'' verwendet werden.

Eine typische Programmbibliothek hat in der Programmiersprache Java am Beispiel des Moduls &quot;java.base&quot; und der beiden Pakete &quot;java.io&quot; und &quot;java.lang&quot; folgende ausschnittsweise Struktur und Hierarchie:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
module java.base;

   package java.io;

      class Reader;
      {
         // Implementation der Klasse Reader
      }

      class Writer;
      {
         // Implementation der Klasse Writer
      }

   package java.lang;

      class String;
      {
         // Implementation der Klasse String
      }

      class System;
      {
         // Implementation der Klasse System
      }
&lt;/syntaxhighlight&gt;

===Methoden===
'''Methoden''' beziehungsweise '''Prozeduren''' werden ebenfalls durch ihre '''Signatur''' eindeutig deklariert, und alle Methodenaufrufe müssen sich streng an diese Deklaration halten. Die Signatur besteht zunächst aus dem '''Namen''' der Methode.

Methoden haben optional einen '''Rückgabewert''', für die der Datentyp ebenfalls festgelegt werden muss und der in streng strukturierten Programmiersprachen ebenfalls zur Signatur der Methode gehört und verwendet werden muss. Solche Methoden werden auch '''Funktionen''' genannt. Leider ist es in manchen Programmiersprachen erlaubt, Rückgabewerte von Funktionen einfach zu ignorieren und diese nicht in einer Variablen zu speichern oder im Rahmen eines Ausdrucks auszuwerten, da dies zu leicht zu übersehenden Programmierfehlern führen kann.

Ferner gibt es innerhalb der Signatur optionale '''Modifikatoren''', die die Regeln für die Sichtbarkeit (zum Beispiel ''öffentlich'' / ''privat'' / ''eingeschränkt'', englisch: ''public'' / ''private'' / ''limited'') festlegen.

Die Überschreibbarkeit einer Methode wird mit einem weiteren Modifikator festgelegt (wie zum Beispiel mit ''statisch'' / ''erweiterbar'' / ''abstrakt'' / ''abgeschlossen'', englisch: ''static'' / ''extensible'' / ''abstract'' / ''final'').

Methoden haben keinen, einen oder mehrere '''Parameter'''. Methoden ohne Parameter werden auch parameterlose Methoden genannt. Parameter sind innerhalb der Methode lokale Variablen, die beim Aufruf der Methode angegeben werden müssen und gegebenenfalls zusammen mit dem Rückgabewert die Schnittstelle für den Datenaustausch zum aufrufenden Programm darstellen. Die Anzahl, die Namen, die Datentypen und die Reihenfolge der '''Parameter''' gehören ebenfalls zur Signatur einer Methode. Beim Aufruf einer Methode müssen alle Parameter in der richtigen Reihenfolge und zuweisungskompatibel angegeben werden. Parameter können unterschieden werden in:

* '''Eingangsparameter''' ('''in'''), die als Wert (englisch ''value'') übergeben und nur innerhalb der Methode verwendet werden. Nach Beendigung des Methodenaufrufs sind sie ungültig und dürfen nicht weiterhin referenziert werden.
* '''Ausgangsparameter''' ('''out'''), die als Referenzen (Zeiger auf einen Speicherbereich, englisch ''pointer'') übergeben und deren Werte erst innerhalb der Methode ermittelt und zugewiesen werden. Nach Beendigung des Methodenaufrufs sind ihre Werte über die Referenzen abrufbar. Die referenzierten Speicherbereiche müssen vor dem Methodenaufruf allokiert worden sein, aber die Speicherinhalte müssen nicht festgelegt werden, da sie innerhalb der Methode nicht verwendet, sondern bestimmt und zugewiesen werden. Beim Programmieren ist große Sorgfalt darauf zu legen, dass die entsprechenden Zuweisungen innerhalb der Methode in jedem Fall erfolgen, falls die verwendete Programmiersprache dies nicht sowieso vorschreibt und erzwingt.
* '''Durchgangsparameter''' ('''var'''iable), die als Referenzen mit definierten Speicherinhalten übergeben, innerhalb der Methode verwendet und nach einer möglichen Veränderung (respektive '''Var'''iation) während des Methodenaufrufs weiterverwendet werden können. Nach Beendigung des Methodenaufrufs sind ihre aktuellen Werte in den aufrufenden Programmteilen über die Referenzen abrufbar.

===Grundlegende Anweisungen===
Grundsätzlich kommt die strukturierte Programmierung in imperativen Programmiersprachen mit folgenden grundlegenden Anweisungen aus:

* '''Deklaration''', zum Beispiel bei Klassen, Methoden, Variablen oder Konstanten mit einer eindeutigen Signatur:
** '''Modifikatoren''' für die Sichtbarkeit, Verwendbarkeit oder Veränderbarkeit
** '''Bezeichner'''
** Optional (bei Methoden, Funktionen, Prozeduren): '''Parameter''' mit Deklaration der Bezeichner, der Veränderbarkeiten und der Datentypen
** Optional (bei Funktionen): Datentyp des '''Rückgabewertes'''
* '''Blockanweisung''', zum Beispiel BEGIN ... END oder { ... }
* '''Zuweisung''', zum Beispiel a := b - c; (das Gleichheitseichen ist nicht zu verwechseln mit einem Vergleichsoperator)
* '''Aufruf von Unterprogrammen''':
** '''Kommandos''' (ohne Parameter und ohne Rückgabewert)
** '''Prozeduren''' oder Methoden (ohne Rückgabewert)
** '''Funktionen''' (mit Rückgabewert)
* '''Rückgabe''' bei Funktionen, zum Beispiel return x;

Anweisungen werden häufig durch ein reserviertes Zeichen abgeschlossen, wie zum Beispiel mit einem Semikolon.

Das folgende Beispiel zeigt eine Java-Klasse mit 15 grundlegenden Anweisungen:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
// Deklaration der oeffentlichen Klasse &quot;Anweisungen&quot;
public class Anweisungen
// Implementation der Klasse mit einer Blockanweisung &quot;{}&quot;
{	
	// Deklaration der privaten, globalen Klassenvariable &quot;flaeche&quot; vom Datentyp &quot;double&quot;
	private static double flaeche;

	// Deklaration der privaten statischen Methode &quot;kreisflaeche&quot; (Unterprogramm) zur Berechnung der Flaeche eines Kreises mit dem Radius &quot;radius&quot;
	// mit dem Parameter &quot;radius&quot; vom Datentyp &quot;double&quot;
	// und mit einer Gleitkommazahl vom Datentyp &quot;double&quot; als Rueckgabewert
	private static double kreisflaeche (double radius)
	// Implementation der Methode &quot;kreisflaeche&quot; mit einer Blockanweisung &quot;{}&quot;
	{
		// Deklaration der lokalen Variable &quot;ergebnis&quot; vom Datentyp &quot;double&quot;
		double ergebnis;

		// Zuweisung eines Ausdrucks an die Variable &quot;ergebnis&quot; mit dem Zuweisungsoperator &quot;=&quot;
		// Syntax: &quot;Variablenname Zuweisungsoperator Ausdruck Semikolon&quot;
		// Der arithmetische Ausdruck verwendet zwei Multiplikationsoperatoren &quot;*&quot;
		// Die Kreiszahl pi aus der Klasse &quot;java.lang.Math&quot; wird qualifiziert bezeichnet: &quot;java.lang.Math.PI&quot;
		ergebnis = java.lang.Math.PI * radius * radius;

		// Ruecksprunganweisung &quot;return&quot; mit der Rueckgabe der Gleitkommazahl &quot;ergebnis&quot;
		return ergebnis;
	}

	// Deklaration der oeffentlichen statischen Methode main (Hauptprogramm)
	public static void main (java.lang.String [] arguments)
	// Implementation der Methode &quot;main&quot; mit einer Blockanweisung &quot;{}&quot;
	{
		// Deklaration der lokalen Variable &quot;raddurchmesser&quot; vom Datentyp double
		double raddurchmesser;

		// Initialisierung der lokalen Variable &quot;raddurchmesser&quot; durch Zuweisung des konstanten arithmetischen Zahlenausdrucks &quot;1.5&quot;
		raddurchmesser = 1.5;

		// Aufruf der Methode &quot;kreisflaeche&quot; mit dem arithmetischen Ausdruck &quot;raddurchmesser / 2&quot; als Parameter
		// Der Rueckgabewert des Methodenaufrufs ist ein Ausdruck und wird der globalen Klassenvariablen &quot;flaeche&quot; zugewiesen
		flaeche = kreisflaeche (raddurchmesser / 2);

		// Aufruf der Methode &quot;println&quot; mit dem Parameter &quot;flaeche&quot; zur Ausgabe der berechneten Kreisflaeche
		// Die Methode aus der Klasse &quot;java.lang.System&quot; wird qualifiziert bezeichnet: &quot;java.lang.System.out.println&quot;
		java.lang.System.out.println (flaeche);
	}
}
&lt;/syntaxhighlight&gt;

Diese Anweisungen sind in der Reihenfolge des Auftretens:
# '''Deklaration''' der Klasse &quot;Anweisungen&quot;
# '''Blockanweisung''' zur Implementation der Klasse &quot;Anweisungen&quot;
# '''Deklaration''' der Klassenvariable &quot;flaeche&quot;
# '''Deklaration''' der Methode &quot;kreisflaeche&quot; (Unterprogramm)
# '''Blockanweisung''' zur Implementation der Methode &quot;kreisflaeche&quot;
# '''Deklaration''' einer lokalen Variable &quot;ergebnis&quot; in der Methode &quot;kreisflaeche&quot; 
# '''Zuweisung''' an die lokale Variable &quot;ergebnis&quot; in der Methode &quot;kreisflaeche&quot;
# '''Rücksprung''' vom Unterprogramm &quot;kreisflaeche&quot; zum Hauptprogramm &quot;main&quot;
# '''Deklaration''' der Methode &quot;main&quot; (Hauptprogramm)
# '''Blockanweisung''' zur Implementation der Methode &quot;main&quot;
# '''Deklaration''' der lokalen Variable &quot;raddurchmesser&quot;
# '''Zuweisung''' an die lokale Variable &quot;raddurchmesser&quot;
# '''Aufruf''' des Unterprogramms &quot;kreisflaeche&quot;
# '''Zuweisung''' an die globale Klassenvariable &quot;flaeche&quot;
# '''Aufruf''' des Unterprogramms &quot;println&quot;

===Anweisungsstrukturen===
Anweisungesstrukturen setzen sich aus mehreren Anweisungen zusammen. Eine Methode besteht zum Beispiel aus einer Deklaration mit der Definition der Schnittstelle, der unmittelbar eine Blockanweisung mit der Implementierung folgt.

Zu den weiteren elementaren Anweisungsstrukturen für Teilprogramme gehören:

* '''Anweisungsfolgen'''
* '''Kontrollstrukturen'''
** '''Fallunterscheidungen'''
*** bedingte Anweisungen (if - then)
*** einfache Verzweigungen (if - then - else)
*** mehrfache Verzweigungen (switch - case - else)
** '''Wiederholungen (Schleifen)'''
*** kopfgesteuerte Schleifen (while-Schleifen, for-Anweisungen)
*** fußgesteuerte Schleifen (repeat - until, do - while)

Bei jedem elementaren Teilprogramm (respektive jeder Methode, Prozedur oder Funktion, aber auch bei jeder Definition von Datenstrukturen) sollte der Quelltext bequem und vollständig auf einer Bildschirmseite gelesen werden können, ohne dass der Text im Betrachtungsfenster verschoben werden muss. Dabei empfiehlt es sich, Methodenaufrufe und übersichtliche Blockanweisungen zu verwenden, mit denen der Quellcode in Unterabschnitte gegliedert werden kann (Verfeinerung).

Im folgenden Beispiel werden drei geschachtelte Blockanweisungen durch jeweils ein Paar geschweifter Klammern begrenzt. Die äußersten Klammern dienen zur Begrenzung der Implementation der Methode &quot;printMonth&quot;, die inneren Blockanweisungen sind ebenso wie alle anderen Anweisungen nach rechts eingerückt:

 printMonth ()
 {
    const int NumberOfWeekdays ← 7
    const int LastDay ← 31
 
    int column
    int day ← 1
 
    while (day &lt;= LastDay)
    {
       printInt (day)
       column ← day modulo NumberOfWeekdays
       if (column = 0)
       {
          printLine ()
       }
       day ← day + 1
    }
 }

Wächst die Länge einer Methode zu sehr an, können und sollen einzelne Blockanweisungen unter Berücksichtigung der entsprechenden Übergabeparameter in eigene, aufzurufende Methoden ausgelagert werden, wodurch der Code geringfügig länger, aber wesentlich besser verständlich wird:

 optionalNewLine (int day)
 {
    const int NumberOfWeekdays ← 7
 
    int column ← day modulo NumberOfWeekdays
 
    if (column = 0)
    {
       printLine ()
    }
 }
 
 void printMonth ()
 {
    const int LastDay ← 31
    int day ← 1
 
    while (day &lt;= LastDay)
    {
       printInt (day)
       optionalNewLine (day)
       day ← day + 1
    }
 }

Hierbei ist es hilfreich, wenn die aufzurufenden Programmteile vor ihrer ersten Verwendung implementiert werden, im Quelltext also zuerst definiert (also deklariert und implementiert) und erst weiter unten benutzt (respektive aufgerufen oder referenziert) werden.

Häufig wird behauptet, dass die Performanz der ausgeführten Programme durch die Aufteilung in solche Unterprogramme leiden würde, da die zahlreichen Aufrufe und Rücksprünge Rechenzeit und Speicherressourcen kosten. In den allermeisten Fällen ist dies auf modernen Rechenmaschinen jedoch zu vernachlässigen. Bei den meisten Anwendungen wird am Speicherbedarf und an der Rechenzeit nicht bemerkt werden können, ob ein strukturiertes oder ein unstrukturiertes Programm vorliegt. Bestenfalls bei extrem rechenintensiven Aufgaben (wie zum Beispiel beim sogenannten &quot;number crunching&quot; (&quot;Zahlenfressen&quot;), bei Monte-Carlo-Simulationen oder Big-Data-Analysen) kann dies bei den extrem häufig aufgerufenen Unterprogrammen einen nennenswerten Effekt haben. Hierbei kann eine wohlstrukturierte Parallelisierung von Programmen oder die Ausgliederung von Rechenaufgaben in spezialisierte Hardware (Graphikprozessoren, digitale Signalprozessoren (DSP), Field Programmable Gate Arrays (FPGA) oder Quantencomputer) wesentlich zu einer Beschleunigung der Programmabläufe beitragen.

Eine Software, die von den Anwendern als zu langsam empfunden wird, ist meist nur schlecht programmiert. Ferner kann gar nicht häufig genug betont werden, dass die Entwicklung und Wartung unstrukturierter Programme erheblich länger dauert und wesentlich fehleranfälliger ist.

=== Schrittweise Verfeinerung ===
Die Implementierung von Software geschieht in der Regel vom Großen ins Kleine. Grob entworfene Anweisungsfolgen und Datenstrukturen werden dabei im Rahmen einer '''schrittweisen Verfeinerung''' immer genauer den Anforderungen angepasst.

Die folgenden Aspekte sind bei der schrittweisen Verfeinerung nach wie vor typisch:&lt;ref&gt;Niklaus Wirth: [http://sunnyday.mit.edu/16.355/wirth-refinement.html Program Development by Stepwise Refinement], Communications of the Association for Computing Machinery, Band 14, Nummer 4, April 1971, Seiten 221 bis 227&lt;/ref&gt;

* In jedem Schritt wird eine Aufgabe (ein Programmteil / ein Datensatz) in Unteraufgaben (in Unterprogramme / in Unterdatensätze) aufgeteilt.
* Der Grad der Abkapselung von Unteraufgaben bestimmt, wie leicht oder schwer Programme und Datenstrukturen angepasst oder übertragen werden können.
* Die Notation für Programme und Daten sollte stets so weit wie möglich sowohl der natürlichen Sprache und der Natur der Sache als auch der Hardware und den Software-Werkzeugen angepasst sein.
* Die Berücksichtigung der Kriterien Laufzeiteffizienz und Speichereffizienz sowie Klarheit und Regelmäßigkeit der Strukturen ist in allen Entwicklungsschritten bis zur Fertigstellung relevant.
* Es muss immer erwogen werden, dass ein korrekt funktionierendes Programm durch eine bessere Version ersetzt werden kann und dass frühere Entscheidungen aus allen Entwicklungsschritten revidiert werden können.
* Die Entwicklung und Wartung guter Programme ist alles andere als trivial, wird aber durch den Einsatz streng strukturierter Programmiersprachen deutlich erleichtert.

== Datenstrukturen ==
Nicht nur der Programmcode, sondern auch die zu verarbeitenden Daten müssen gut strukturiert werden, um die Entwicklungszeiten zu reduzieren, die Qualität der Programme zu erhöhen und die Wartung der Quelltexte zu erleichtern. Gehören zum Beispiel ganz verschiedene Attribute zu einer Sache, sollen diese Attribute zu einer Datenstruktur zusammengefasst werden. Datenstrukturen können auch geschachtelt eingesetzt werden, so dass sehr umfangreiche und komplexe Datenstrukturen abgebildet werden können.

===Aufzählungen===
Eine '''Aufzählung''' (englisch &quot;enumeration&quot;) wird verwendet, wenn bestimmte Eigenschaften von Datenstrukturen abzählbar und endlich sind. Mit diesen thematisch zusammengehörigen Aufzählungen können im Programmtext an allen entsprechenden Stellen statt abstrakt zugeordneter Zahlen konkret zugeordnete symbolische Konstanten mit sprechenden und selbsterklärenden Bezeichnern verwendet werden. Manche Programmiersprachen bieten dafür sogar die Möglichkeit an, dafür eigene Datentypen zu erstellen, in vielen Programmiersprachen wird das jedoch auf sehr simple Weise mit ganzzahligen Basisdaten nachgebildet.

Im folgenden Beispiel wird erläutert, wie verschiedene Kalendersysteme als Aufzählung behandelt werden können. Hierbei werden die folgenden vier Kalendersysteme zu Auswahl:
* Jüdisches Kalendersystem, Kennzahl = 1
* Julianisches Kalendersystem, Kennzahl = 2
* Gregorianisches Kalendersystem, Kennzahl = 3
* Islamisches Kalendersystem, Kennzahl = 4

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Kalendersystem
{
   public final static long JUEDISCH = 1; // Lunisolarkalender
   public final static long JULIANISCH = 2; // Solarkalender bis 4. Oktober 1582 (Donnerstag)
   public final static long GREGORIANISCH = 3; // Solarkalender seit 15. Oktober 1582 (Freitag)
   public final static long ISLAMISCH = 4; // Lunarkalender
}
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;oberon2&quot;&gt;
(* Programmiersprache Oberon *)

MODULE Kalendersystem;

   CONST
      JUEDISCH = 1; (* Lunisolarkalender *)
      JULIANISCH = 2; (* Solarkalender bis 4. Oktober 1582 (Donnerstag) *)
      GREGORIANISCH = 3; (* Solarkalender seit 15. Oktober 1582 (Freitag) *)
      ISLAMISCH = 4; (* Lunarkalender *)
&lt;/syntaxhighlight&gt;

In manchen, meist älteren Programmiersprachen gibt es explizite Aufzählungstypen, bei denen der Compiler automatisch die dazugehörigen ganzen Kennzahlen festlegt, ohne dass diese im Quelltext auftauchen, weil ausschließlich die symbolischen Konstanten aus der Deklaration des Aufzählungstyps verwendet werden. Variablen des Datentyps &quot;Kalendersystem&quot; im folgenden Beispiel dürfen nur die vier zwischen den runden Klammern explizit angegebenen respektive aufgezählten symbolischen Konstanten und keine beliebigen ganzen Zahlen verwenden:

&lt;syntaxhighlight lang=&quot;modula2&quot;&gt;
(* Programmiersprache Modula-2 *)

   TYPE Kalendersystem = (JUEDISCH, JULIANISCH, GREGORIANISCH, ISLAMISCH);
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;cpp&quot;&gt;
/* Programmiersprache C++ */

   enum Kalendersystem = {JUEDISCH, JULIANISCH, GREGORIANISCH, ISLAMISCH};
&lt;/syntaxhighlight&gt;

===Verbunde===
Gehören mehrere verschiede Attribute zu einer Datenstruktur, spricht man auch von einem '''Verbund'''. Diese Datenstrukturen werden je nach Programmiersprache häufig &quot;struct&quot; oder &quot;record&quot; genannt. Alle Attribute können und müssen über einen zentralen Zugang adressiert werden. Dies soll im Folgenden anhand der Datenstruktur &quot;Kalenderdatum&quot; beispielhaft erläutert werden.

Ein Kalenderdatum möge aus einem '''Tag''', einem '''Monat''', einem '''Jahr''' und einem '''Kalendersystem''' bestehen:

Alle vier Attribute werden in vier unabhängigen Datenfeldern gespeichert. Im vorliegenden Beispiel sind zwar alle vier Datenfelder vom Basisdatentyp &quot;ganze Zahl&quot; (&quot;long&quot; oder &quot;INTEGER&quot;), die Bedeutung und die gültige Zahlenbereiche unterscheiden sich jedoch:
* Tag: ganze Zahl im Intervall [1..31]
* Monat: ganze Zahl im Intervall [1..12]
* Jahr: ganze Zahl
* Kalendersystem. ganze Zahl des Aufzählungstyps &quot;Kalendersystem&quot; mit den vier Optionen (JUEDISCH, JULIANISCH, GREGORIANISCH, ISLAMISCH)

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Kalenderdatum
{
   // Instanzvariablen
   private long tag;
   private long monat;
   private long jahr;
   private long kalendersystem;

   public Kalenderdatum (long tag, long monat, long jahr, long kalendersystem) // Konstruktor zur Initialisierung von Instanzvariablen der Klasse Kalenderdatum
   {
      this.tag = tag;
      this.monat = monat;
      this.jahr = jahr;
      this.kalendersystem = kalendersystem;
   }

   public static void main (java.lang.String [] argumente) // main-Methode der Klasse &quot;Kalenderdatum&quot;
   {
      Kalenderdatum kalenderdatum = new Kalenderdatum (10, 4, 2023, Kalendersystem.GREGORIANISCH); // Eine neue Instanz wird erzeugt und durch den Aufruf des Konstruktors initialisiert
      java.lang.System.out.print (kalenderdatum.tag);
      java.lang.System.out.print (&quot;.&quot;);
      java.lang.System.out.print (kalendekalenderdatum.monat);
      java.lang.System.out.print (&quot;.&quot;);
      java.lang.System.out.print (kalenderdatum.jahr);
      java.lang.System.out.println (); // Zeilenumbruch
   }
}
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;oberon2&quot;&gt;
(* Programmiersprache Oberon *)

   IMPORT Out; (* Import des Moduls &quot;Out&quot; für die Textausgabe *)

   TYPE Kalenderdatum =
   RECORD
      tag: INTEGER;
      monat: INTEGER;
      jahr: INTEGER;
      kalendersystem: INTEGER;
   END;

   VAR kalenderdatum; (* Variable *)

   BEGIN
      kalenderdatum.tag = 10;
      kalenderdatum.monat = 4;
      kalenderdatum.jahr = 2023;
      kalenderdatum.kalendersystem = Kalendersystem.GREGORIANISCH;

      Out.Int (kalenderdatum.tag);
      Out.String (&quot;.&quot;);
      Out.Int (kalenderdatum.monat);
      Out.String (&quot;.&quot;);
      Out.Int (kalenderdatum.jahr);
      Out.Ln; (* Zeilenumbruch *)
   END;
&lt;/syntaxhighlight&gt;

Die Textausgabe lautet jeweils:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
23.4.2023
&lt;/syntaxhighlight&gt;

===Arrays===
In Arrays werden endlich viele und abzählbare Elemente eines bestimmten Datentyps in einer geordneten Reihe gespeichert. Die einzelnen Elemente können über einen ganzzahligen Index angesprochen werden. Der niedrigste Index ist meistens der Index Null, und dieser zeigt auf die erste Speicheradresse des Arrays. Da alle Elemente vom gleichen Datentyp sind, wird für jedes Element immer der gleiche Speicherplatz benötigt. Elemente mit komplexen Datentypen, werden nicht direkt im Array gespeichert, sondern dieses enthält als Verweise Zeiger mit den Speicheradressen der Inhalte der Elemente. Wenn der Speicherbedarf für ein Element (oder dessen Zeiger) &lt;math&gt;S_E&lt;/math&gt; Bytes beträgt und das Array insgesamt &lt;math&gt;N&lt;/math&gt; Elemente hat, dann berechnet sich der Speicherbedarf &lt;math&gt;S&lt;/math&gt; für das ganze Array aus dem Produkt:

&lt;math&gt;S = S_E \cdot N&lt;/math&gt;

Die Speicheradresse &lt;math&gt;A_i&lt;/math&gt; des i-ten Elements des Arrays berechnet sich dann mit einfacher und effizient ausführbarer Arithmetik aus der Speicheradresse des Arrays &lt;math&gt;A&lt;/math&gt;, dem Speicherbedarf für ein Element (oder dessen Zeiger) &lt;math&gt;S_E&lt;/math&gt; und dem Index &lt;math&gt;i&lt;/math&gt; :

&lt;math&gt;A_i = A + S_E \cdot i&lt;/math&gt; mit &lt;math&gt;0 \le i &lt; N&lt;/math&gt;

Die Speicheradresse des ersten Elements mit dem Index Null &lt;math&gt;A_0&lt;/math&gt; ist also stets identisch mit der Speicheradresse des Arrays &lt;math&gt;A&lt;/math&gt;.

Im folgenden Beispiel wird ein Array mit acht zufällig verteilten Gleitkommazahlen dargestellt, bei denen jede Gleitkommazahl einen Speicherplatz von '''8&amp;nbsp;Bytes''' (Datentyp '''double''' mit 64&amp;nbsp;Bits) belegt:

{| class=&quot;wikitable&quot;
|'''Länge des Arrays &lt;math&gt;N&lt;/math&gt;'''
|'''Speicheradresse des Arrays (dezimal) &lt;math&gt;A&lt;/math&gt;'''
|'''Speicheradresse des Arrays (hexadezimal) &lt;math&gt;A&lt;/math&gt;'''
|'''Speicherbedarf für eine Gleitkommazahl in Bytes &lt;math&gt;S_E&lt;/math&gt;'''
|-
|8
|10000000
|98 96 80
|8
|-
|'''Index &lt;math&gt;i&lt;/math&gt;'''
|'''Speicheradresse des Elements im Array (dezimal) &lt;math&gt;A_i = A + S_E \cdot i&lt;/math&gt;'''
|'''Speicheradresse des Elements im Array (hexadezimal) &lt;math&gt;A_i = A + S_E \cdot i&lt;/math&gt;'''
|'''Gespeicherter Inhalt des Elements (Gleitkommazahl)'''
|-
|0
|10000000
|98 96 80
|678,1495238
|-
|1
|10000008
|98 96 88
|317,4610959
|-
|2
|10000016
|98 96 90
|574,3131347
|-
|3
|10000024
|98 96 98
|673,9323679
|-
|4
|10000032
|98 96 A0
|854,6637912
|-
|5
|10000040
|98 96 A8
|764,4845853
|-
|6
|10000048
|98 96 B0
|335,5146962
|-
|7
|10000056
|98 96 B8
|545,0787382
|}

Das folgende Java-Programm implementiert ein solches Array mit acht Gleitkommazahlen:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Array
{
	
	// Klassenvariable zufallszahlen als Array mit acht Gleitkommazahlen
   private static double zufallszahlen [] = new double [8];

   public static void setzeZufallszahlen (long startwert) // Methode zur Bestimmung aller Gleitkommazahlen
   {
	   // Variable zufallszahl
	   java.util.Random zufallszahl = new java.util.Random (startwert); // Startwert für erste Zufallszahl

	   long anzahl = zufallszahlen.length;
	   int zaehler = 0; // der Index von Arrays darf nicht vom Datentyp long sein
	   while (zaehler &lt; anzahl)
	   {
		   zufallszahlen [zaehler] = zufallszahl.nextDouble ();
		   zaehler++;
	   }
   }

   public static void ausgabeZufallszahlen () // Methode zur Ausgabe aller Gleitkommazahlen
   {
	   long anzahl = zufallszahlen.length;
	   int zaehler = 0; // der Index von Arrays darf nicht vom Datentyp long sein
	   while (zaehler &lt; anzahl)
	   {
		   java.lang.System.out.println (zufallszahlen [zaehler]);
		   zaehler++;
	   }
   }

   public static void main (java.lang.String [] argumente) // Hauptprogramm &quot;main&quot; zum Aufruf der beiden Unterprogramme
   {
	   setzeZufallszahlen (1000); // Aufruf des Unterprogramms setzeZufallszahlen mit dem Parameter 1000 als Startwert
	   ausgabeZufallszahlen (); // Aufruf des Unterprogramms ausgabeMonatsname ohne Parameter
   }
}&lt;/syntaxhighlight&gt;

Mit dem Aufruf des Hauptprogramms ''main'' erfolgt die Ausgabe von acht Pseudozufallszahlen:

&lt;syntaxhighlight&gt;
0.7101849056320707
0.574836350385667
0.9464192094792073
0.039405954311386604
0.4864098780914311
0.4457367367074283
0.6008140654988429
0.550376169584217
&lt;/syntaxhighlight&gt;

Im nächsten Beispiel mit einem Array für die zwölf Monatsnamen ist der Datentyp eines Arrayelements jeweils eine Zeichenkette, die je nach ihrer Länge verschieden große Speicherbereiche belegen:

{| class=&quot;wikitable&quot;
|'''Länge des  Arrays'''
|'''Speicheradresse des Arrays'''
|'''Speicherbedarf für eine Speicheradresse'''
|'''Speicherbedarf für ein Zeichen'''
|
|
|-
|13
|10000000
|4
|2
|
|
|-
|Index
|'''Speicheradresse des Elements im Array'''
|'''Gespeicherter Inhalt des Elements (Speicheradresse)'''
|'''Länge der Zeichenkette'''
|'''Speicherbedarf der Zeichenkette'''
|'''Gespeicherter Inhalt des Elements (Zeichenkette)'''
|-
|0
|10000000
|20000000
|8
|16
|&quot;deutsch&quot;
|-
|1
|10000004
|20000016
|7
|14
|&quot;Januar&quot;
|-
|2
|10000008
|20000030
|8
|16
|&quot;Februar&quot;
|-
|3
|10000012
|20000046
|5
|10
|&quot;März&quot;
|-
|4
|10000016
|20000056
|6
|12
|&quot;April&quot;
|-
|5
|10000020
|20000068
|4
|8
|&quot;Mai&quot;
|-
|6
|10000024
|20000076
|5
|10
|&quot;Juni&quot;
|-
|7
|10000028
|20000086
|5
|10
|&quot;Juli&quot;
|-
|8
|10000032
|20000096
|7
|14
|&quot;August&quot;
|-
|9
|10000036
|20000110
|10
|20
|&quot;September&quot;
|-
|10
|10000040
|20000130
|8
|16
|&quot;Oktober&quot;
|-
|11
|10000044
|20000146
|9
|18
|&quot;November&quot;
|-
|12
|10000048
|20000164
|9
|18
|&quot;Dezember&quot;
|}

In den folgenden Beispielen in der Programmiersprache werden die zwölf Monatsnamen in Arrays mit Zeichenketten gespeichert. Hierzu wird die Sprache der Monatsnamen im ersten Arrayfeld mit dem Index 0 und die zwölf Monatsnamen in den folgenden Arrayfeldern mit den Indizes 1 bis 12 gespeichert:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Monatsnamen
{
   // Klassenvariable
   private static java.lang.String monatsnamen [] = {&quot;deutsch&quot;,
      &quot;Januar&quot;, &quot;Februar&quot;, &quot;März&quot;, &quot;April&quot;, &quot;Mai&quot;, &quot;Juni&quot;, &quot;Juli&quot;, &quot;August&quot;, &quot;September&quot;, &quot;Oktober&quot;, &quot;November&quot;, &quot;Dezember&quot;};

   public static void ausgabeMonatsname (int monat) // Methode zur Textausgabe von Monatsnamen
   {
      java.lang.System.out.println (monatsnamen [monat]);
   }

   public static void main (java.lang.String [] argumente) // Hauptprogramm &quot;main&quot; zum Aufruf der Methode ausgabeMonatsname
   {
      ausgabeMonatsname (1); // Aufruf des Unterprogramms ausgabeMonatsname mit dem Parameter 1
   }
}
&lt;/syntaxhighlight&gt;

Mit dem Aufruf des Hauptprogramms ''main'' erfolgt die Ausgabe mit dem ersten Monatsnamen:

&lt;syntaxhighlight&gt;
Januar
&lt;/syntaxhighlight&gt;

In einigen Programmiersprachen muss die Größe der Array vor der Initialisierung festgelegt werden, und die Zuordnung zwischen den Indizes und den Arrayfeldern ist dann auch bei der Initialisierung explizit erkennbar:

&lt;syntaxhighlight lang=&quot;oberon2&quot;&gt;
(* Programmiersprache Component Pascal *)

MODULE Monatsnamen;

   IMPORT Out; (* Import des Moduls &quot;Out&quot; für die Textausgabe *)

   TYPE Monatsnamen = POINTER TO ARRAY OF ARRAY OF CHAR;

   VAR monatsnamen: Monatsnamen;

   PROCEDURE InittialisiereMonatsnamen (); (* Prozedur zur Initialisierung von Monatsnamen *)
   BEGIN
      NEW (monatsnamen, 13, 10); (* Reservierung von 13 Zeichenketten mit je 10 Zeichen) *)
      monatsnamen [0] := &quot;deutsch&quot;;
      monatsnamen [1] := &quot;Januar&quot;;
      monatsnamen [2] := &quot;Februar&quot;;
      monatsnamen [3] := &quot;März&quot;;
      monatsnamen [4] := &quot;April&quot;;
      monatsnamen [5] := &quot;Mai&quot;;
      monatsnamen [6] := &quot;Juni&quot;;
      monatsnamen [7] := &quot;Juli&quot;;
      monatsnamen [8] := &quot;August&quot;;
      monatsnamen [9] := &quot;September&quot;;
      monatsnamen [10] := &quot;Oktober&quot;;
      monatsnamen [11] := &quot;November&quot;;
      monatsnamen [12] := &quot;Dezember&quot;;
   END InittialisiereMonatsnamen;

   PROCEDURE AusgabeMonatsname (monat: INTEGER); (* Prozedur zur Textausgabe von Monatsnamen *)
   BEGIN
      Out.String (monatsnamen [monat]);
   END AusgabeMonatsname;

   PROCEDURE Hauptprogramm*;
   BEGIN
      InittialisiereMonatsnamen (); (* Initialisierung beim Laden des Moduls &quot;Monatsnamen&quot; *)
      AusgabeMonatsname (1); (* Aufruf des Unterprogramms AusgabeMonatsname mit dem Parameter 1 *)
   END Hauptprogramm;

END Monatsnamen.
&lt;/syntaxhighlight&gt;

Durch den Aufruf von ''Monatsnamen.Hauptprogramm'' erfolgt die Ausgabe mit dem ersten Monatsnamen:

&lt;syntaxhighlight&gt;
Januar
&lt;/syntaxhighlight&gt;

Arrays können mehrdimensional gestaltet werden. Um zum Beispiel zwei Sprachen mit Monatsnamen zu speichern, kann eine weitere Dimension mit einem Index für die gewünschte Sprache implementiert werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Monatsnamen
{
   // Konstanten für Sprachaufzählung
   public final static int DEUTSCH = 0;
   public final static int ENGLISCH = 1;

   // Klassenvariablen
   private static java.lang.String monatsnamen [] [] =
   {
      {&quot;deutsch&quot;, &quot;Januar&quot;, &quot;Februar&quot;, &quot;März&quot;, &quot;April&quot;, &quot;Mai&quot;, &quot;Juni&quot;, &quot;Juli&quot;, &quot;August&quot;, &quot;September&quot;, &quot;Oktober&quot;, &quot;November&quot;, &quot;Dezember&quot;},
      {&quot;english&quot;, &quot;January&quot;, &quot;February&quot;, &quot;March&quot;, &quot;April&quot;, &quot;May&quot;, &quot;June&quot;, &quot;July&quot;, &quot;August&quot;, &quot;September&quot;, &quot;October&quot;, &quot;November&quot;, &quot;December&quot;}
   };

   public static void ausgabeMonatsname (int monat) // Methode zur Textausgabe von Monatsnamen
   {
      java.lang.System.out.println (&quot;Deutschsprachiger Monatsname = &quot; + monatsnamen [DEUTSCH] [monat]);
      java.lang.System.out.println (&quot;Englischsprachiger Monatsname = &quot; + monatsnamen [ENGLISCH] [monat]);
   }

   public static void main (java.lang.String [] argumente) // Hauptprogramm &quot;main&quot; zum Aufruf der Methode ausgabeMonatsname
   {
      ausgabeMonatsname (2);
   }
}
&lt;/syntaxhighlight&gt;

Mit dem Aufruf des Hauptprogramms ''main'' erfolgt die Ausgabe mit den beiden zweiten Monatsnamen:

&lt;syntaxhighlight&gt;
Deutschsprachiger Monatsname = Februar
Englischsprachiger Monatsname = February
&lt;/syntaxhighlight&gt;

Bei anderen Programmiersprachen ist durch die obligatorische Verwendung von symbolischen Konstanten (im Beispiel unten &quot;DEUTSCH&quot; und &quot;ENGLISCH&quot;) bei jeder erforderlichen, also auch bei allen initialen Zuweisungen zu Array-Elementen übersichtlich und klar erkennbar, welches Feld angesprochen wird:

&lt;syntaxhighlight lang=&quot;oberon2&quot;&gt;
(* Programmiersprache Component Pascal *)

MODULE Monatsnamen;

   IMPORT Out; (* Import des Moduls &quot;Out&quot; für die Textausgabe *)

   CONST
      DEUTSCH = 0;
      ENGLISCH = 1;

   TYPE Monatsnamen = POINTER TO ARRAY OF ARRAY OF ARRAY OF CHAR;

   VAR monatsnamen: Monatsnamen;

   PROCEDURE InittialisiereMonatsnamen ();  (* Prozedur zur Initialisierung von Monatsnamen *)
   BEGIN
      NEW (monatsnamen, 2, 13, 10); (* Reservierung von 2 mal 13 Zeichenketten mit je 10 Zeichen) *)
      monatsnamen [DEUTSCH, 0] := &quot;deutsch&quot;;
      monatsnamen [DEUTSCH, 1] := &quot;Januar&quot;;
      monatsnamen [DEUTSCH, 2] := &quot;Februar&quot;;
      monatsnamen [DEUTSCH, 3] := &quot;März&quot;;
      monatsnamen [DEUTSCH, 4] := &quot;April&quot;;
      monatsnamen [DEUTSCH, 5] := &quot;Mai&quot;;
      monatsnamen [DEUTSCH, 6] := &quot;Juni&quot;;
      monatsnamen [DEUTSCH, 7] := &quot;Juli&quot;;
      monatsnamen [DEUTSCH, 8] := &quot;August&quot;;
      monatsnamen [DEUTSCH, 9] := &quot;September&quot;;
      monatsnamen [DEUTSCH, 10] := &quot;Oktober&quot;;
      monatsnamen [DEUTSCH, 11] := &quot;November&quot;;
      monatsnamen [DEUTSCH, 12] := &quot;Dezember&quot;;

      monatsnamen [ENGLISCH, 0] := &quot;english&quot;;
      monatsnamen [ENGLISCH, 1] := &quot;January&quot;;
      monatsnamen [ENGLISCH, 2] := &quot;February&quot;;
      monatsnamen [ENGLISCH, 3] := &quot;March&quot;;
      monatsnamen [ENGLISCH, 4] := &quot;April&quot;;
      monatsnamen [ENGLISCH, 5] := &quot;May&quot;;
      monatsnamen [ENGLISCH, 6] := &quot;June&quot;;
      monatsnamen [ENGLISCH, 7] := &quot;July&quot;;
      monatsnamen [ENGLISCH, 8] := &quot;August&quot;;
      monatsnamen [ENGLISCH, 9] := &quot;September&quot;;
      monatsnamen [ENGLISCH, 10] := &quot;October&quot;;
      monatsnamen [ENGLISCH, 11] := &quot;November&quot;;
      monatsnamen [ENGLISCH, 12] := &quot;December&quot;;
   END InittialisiereMonatsnamen;

   PROCEDURE AusgabeMonatsname (monat: INTEGER); (* Prozedur zur Textausgabe von Monatsnamen *)
   BEGIN
      Out.String (&quot;Sprache = &quot; + monatsnamen [DEUTSCH, 0] + &quot;: &quot; + monatsnamen [DEUTSCH, monat]);
      Out.Ln;
      Out.String (&quot;Sprache = &quot; + monatsnamen [ENGLISCH, 0] + &quot;: &quot; + monatsnamen [ENGLISCH, monat]);
      Out.Ln;
   END AusgabeMonatsname;

   PROCEDURE Hauptprogramm*;
   BEGIN
      InittialisiereMonatsnamen (); (* Initialisierung beim Laden des Moduls &quot;Monatsnamen&quot; *)
      AusgabeMonatsname (2);
   END Hauptprogramm;

END Monatsnamen.
&lt;/syntaxhighlight&gt;

Durch den Aufruf von ''Monatsnamen.Hauptprogramm'' erfolgt die Ausgabe mit den beiden zweiten Monatsnamen:

&lt;syntaxhighlight&gt;
Sprache = deutsch: Februar
Sprache = english: February
&lt;/syntaxhighlight&gt;

Die Verwendung von Indizes außerhalb der deklarierten oder angeforderten Array-Größen verursachen in streng strukturierten Programmiersprachen zur Laufzeit einen Programmabbruch. Bei sorgfältiger Programmierung ist deswegen darauf zu achten, dass nur gültige Indizes zur Anwendung kommen können. In schlecht strukturierten Programmiersprachen wie C oder C++ werden die Indizes von Arrays in der Regel nicht automatisch geprüft, so dass unbemerkt auf ungültige Speicheradressen zugegriffen werden kann und bei entsprechenden Angriffen Daten verfälscht und schadhafter Binärcode in die Programme eingeschleust sowie zur Ausführung gebracht werden kann.

==Kontrollstrukturen==
Kontrollstrukturen dienen dazu, den Programmablauf in wohlstrukturierter Weise im Sinne eines Algorithmus zu beeinflussen. Hierfür können '''Unterprogramme''' aufgerufen, '''Fallunterscheidungen''' vorgenommen oder Programmteile mehrfach durchlaufen werden ('''Schleifen''').

===Sprunganweisungen===
Sprünge an andere Programmstellen ergeben sich inhärent beim Aufruf von Unterprogrammen. Geschieht ein solcher Sprung durch eine explizite Sprunganweisung im Programmcode, wie zum Beispiel mit Goto-, Break- oder Continue-Anweisungen, ist dies unstrukturiert und im Übrigen auch völlig überflüssig, denn Programme mit Sprunganweisungen können immer und ohne großen Aufwand durch Kontrollstrukturen, also mit Hilfe von '''Unterprogrammen''', '''Schleifen''' oder '''Fallunterscheidungen''', gestaltet werden.

Explizite Sprunganweisungen stellen eine &quot;Programmiertechnik mit dem Holzhammer&quot; und wegen der daraus resultierenden verschlungenen Pfade während des Programmablaufs einen sogenannten '''Spaghetti-Code''' dar. Im Quellcode ist der Programmablauf nicht mehr ohne weiteres nachvollziehbar, beispielsweise bei der Untersuchung, von welchen Stellen des Programms an welche anderen Stellen gesprungen werden soll oder worden sein kann.

Im Falle der Switch-Case-Anweisung handelt es sich bei der in manchen Programmiersprachen verwendeten Break-Anweisung eigentlich nicht um eine Sprunganweisung, sondern um einen obligatorischen Begrenzer (englisch: ''delimiter''), der zur Herstellung der Programmstruktur erforderlich ist. In einigen Programmiersprachen darf dieser Begrenzer (''break'') jedoch weggelassen werden, um den Code in bestimmten aber vereinzelten Fällen etwas kürzer gestalten zu können, was aber gleichzeitig und unabdingbar zu unstrukturierter Programmierung führt, die Programmabläufe unübersichtlich macht und dazu führen kann, dass die Programme gegebenenfalls nur noch schwierig nachzuvollziehen und zu warten sind.

====Unterprogramme====
[[Datei:Unterprogrammaufruf.png|mini|rechts|hochkant=1|Von der Hauptroutine &quot;Procedure main&quot; eines gestarteten Programms wird nach Ausführung der Anweisungen &quot;Instructions&amp;nbsp;1&quot; ein Unterprogramm &quot;Procedure sub&quot; aufgerufen (&quot;Call sub&quot;), und der Programmablauf wird mit den dortigen Anweisungen &quot;Instructions&quot; fortgeführt. Wenn die letzte Anweisung &quot;Return&quot; des Unterprogramms erreicht worden ist, wird in das Hauptprogramm zurückgesprungen und der Programmablauf an der Stelle direkt hinter dem Aufruf des Unterprogramms mit den Anweisungen &quot;Instructions&amp;nbsp;2&quot; fortgesetzt.]]

Eine besonders häufig angewendete Programmiertechnik ist der Aufruf von Unterprogrammen. Unterprogramme stellen im Sinne des Quelltextes eines Programmes üblicherweise Prozeduren, Methoden oder Funktionen dar. Mit der Programmanweisung des Aufrufs kann der Programmablauf zum entsprechenden Unterprogramm verzweigt werden. Hierbei können in der Regel auch Parameter übergeben werden, um zwischen dem aufrufenden Programmteil und dem Unterprogramm Daten austauschen zu können. Ist das Unterprogramm vollständig abgearbeitet worden, wird der Programmablauf hinter der Stelle des Unterprogrammaufrufs fortgesetzt.

Unterprogramme können mehrfach und von allen Stellen des Programcodes aufgerufen werden, in dem das Unterprogramm sichtbar ist. Die Unterscheidung zwischen Prozeduren und Methoden ist nicht einheitlich. Etliche Programmiersprachen verwenden kategorisch nur einen der beiden Begriffe. Hierbei kann zwischen traditionellen (statischen) Prozeduren und objektorientierten (typengebunden oder dynamischen) Prozeduren unterschieden werden. Letztere werden als Methoden einer Klasse oder aber auch als typengebundene Prozeduren eines Programmoduls bezeichnet.

====Rücksprunganweisungen====
Nach Ablauf des Unterprogramms kann ein Rückgabewert an das aufrufende Programm zurückgegeben werden, der im aufrufenden Programmteil dann zur Verfügung steht und als Ausdruck zum Beispiel an eine Variable zugewiesen werden kann. In diesem Fall wird ein Unterprogramm auch '''Funktion''' genannt, da als Ergebnis des Unterprogrammaufrufs ein Funktionswert berechnet wurde und dann zurückgegeben wird.

Jedes Unterprogramm hat daher exakt eine Rücksprunganweisung (oft mit dem Schlüsselwort '''return''' gekennzeichnet), die logischerweise die letzte Anweisung sein muss, damit alle Anweisungen vorher durchgeführt werden können. Der Rücksprung erfolgt immer zur Stelle des Unterprogrammaufrufs, wo die Programmausführung anschließend fortgeführt wird.

Hat das Unterprogramm keinen Rückgabewert, der an den aufrufenden Programmteil zurückgegeben werden muss, wird in vielen Programmiersprachen auf eine explizite Rücksprunganweisung verzichtet; in diesem Fall wird sie also implizit ausgeführt. Ist das Hauptprogramm vollständig durchlaufen, wird das Programm nach dessen Rücksprunganweisung beendet, und die Kontrolle an das Laufzeitsystem oder das Betriebssystem zurückgegeben, von wo aus das Hauptprogramm aufgerufen worden war.

Mehrfache und insbesondere vorzeitige Rücksprunganweisungen in einem Unterprogramm sind unstrukturiert und daher zu unterlassen, auch wenn die Programmiersprache dies nicht zwingend fordert. Vorzeitige Unterprogrammabbrüche ('''Break'''-Anweisungen) verhindern, dass nachfolgende Programmsequenzen ausgeführt werden können, obwohl sie bei einer Ausführung das Ergebnis für den Rückgabewert beeinflussen würden. Dies kann zur Verwirrung führen, weil das Unterprogramm bei einer Überprüfung oder einer Analyse immer vollständig auf potentielle vorzeitige Unterprogrammabbrüche durchsucht werden muss.

Der folgende unstrukturierte Java-Code, der den in der Variablen '''ergebnis''' gespeicherten Wert vor dessen Rückgabe als Text ausgeben soll, verdeutlicht dies:

&lt;syntaxhighlight lang=&quot;java&quot;&gt;
private static double unterprogramm (double parameter)
{
   double ergebnis = parameter;
   boolean ganzzahlig = (parameter % 1 == 0);
   if (ganzzahlig) return ergebnis;
   ergebnis = ergebnis + 1;
   java.lang.System.out.println (&quot;Ergebnis = &quot; + ergebnis);
   return ergebnis;
}
&lt;/syntaxhighlight&gt;

Die Erhöhung des Wertes der Variablen '''ergebnis''' sowie die Textausgabe mit dem Aufruf der Methode '''println''' unmittelbar vor der Rücksprunganweisung erfolgen wegen der beiden vorhandenen Rücksprunganweisungen nur, wenn der Wert des Parameters '''parameter''' nicht ganzzahlig ist. Demzufolge erzeugen die folgenden beiden Unterprogrammaufrufe

&lt;syntaxhighlight lang=&quot;java&quot;&gt;
   unterprogramm (0);
   unterprogramm (0.5);
&lt;/syntaxhighlight&gt;

die Textausgabe:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
Ergebnis = 1.5
&lt;/syntaxhighlight&gt;

Dieses formal korrekte, aber unerwünschte Verhalten wird nur nachvollziehbar, wenn der gesamte Code des Unterprogramms analysiert wird, was bei komplexeren Unterprogrammen und beim Vorhandensein mehrerer Rücksprunganweisungen sehr aufwendig werden kann..

Das folgende Unterprogramm implementiert den eigentlich gewünschten Algorithmus in strukturierter Form mit einer einzigen Rücksprunganweisung am Ende des Unterprogramms:

&lt;syntaxhighlight lang=&quot;java&quot;&gt;
private static double unterprogramm (double parameter)
{
   double ergebnis = parameter;
   boolean ganzzahlig = (parameter % 1 == 0);
   if (! ganzzahlig)
   {
      ergebnis = ergebnis + 1;
   }
   java.lang.System.out.println (&quot;Ergebnis = &quot; + ergebnis);
   return ergebnis;
}
&lt;/syntaxhighlight&gt;

Die Textausgabe bei den oben angegebenen  Aufrufen des Unterprogramms erfolgt nun wie gewünscht:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
Ergebnis = 0.0
Ergebnis = 1.5
&lt;/syntaxhighlight&gt;

Es empfiehlt sich grundsätzlich ebenfalls immer, innerhalb von Rücksprunganweisungen keine komplexen Ausdrücke, Kontrollstrukturen oder Unterprogrammaufrufe zu verwenden, um einfache und eindeutige Rückgabewerte zu erhalten sowie diese gegebenenfalls mit einer Textausgabe oder einem Debugger kontrollieren zu können. Im Idealfall wird in der Rücksprunganweisung nur der Wert einer zuvor berechneten lokalen Variable mit einem sprechenden Bezeichner zurückgegeben:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
   ergebnis ← f (a, b, c);
   return ergebnis;
&lt;/syntaxhighlight&gt;

In der Regel ergeben sich durch die zusätzliche explizite Zuweisung an die lokale Variable '''ergebnis''' keine Laufzeiteinbußen, da im übersetzten Maschinencode implizit für den Rückgabewert sowieso eine Zuweisung ausgeführt werden muss. Moderne Übersetzer berücksichtigen diesen Kontext automatisch, so dass in beiden Fällen derselbe Maschinencode erzeugt wird.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

===Fallunterscheidungen===
Die einfachste Fallunterscheidung ist die bedingte Anweisung. Verzweigungen enthalten mindestens zwei alternative Programmpfade.

====Bedingte Anweisung====
[[Datei:einfAusw.png|mini|rechts|hochkant=2|Struktogramm einer bedingten Anweisung.]]

Im folgenden Beispiel mit einer bedingten Anweisung (zum Beispiel if - then - end) wird die Dekrement-Anweisung a-- (der Wert der numerischen Variablen a soll um eins erniedrigt werden) nur dann ausgeführt, falls der boolesche Ausdruck a &gt; b wahr ist, die entsprechende Bedingung also erfüllt ist:

 falls a &gt; b dann a-- ende

Hier wird der Wert der Variablen a also nur dann dekrementiert, wenn der Wert der Variablen a größer ist als der Wert der Variable b. Ansonsten wird der Programmablauf sofort hinter der ende-Marke fortgeführt.

====Einfache Verzweigung====
[[Datei:zweifAusw.png|mini|rechts|hochkant=2|Struktogramm einer einfachen Verzweigung.]]

Die einfachste Verzweigung (zum Beispiel if - then - else - end) enthält genau zwei alternative Pfade, von denen in Abhängigkeit eines booleschen Ausdrucks nur einer ausgeführt wird, wie in diesem Beispiel:

 falls a &gt; b dann a-- ansonsten b-- ende

Je nachdem die entsprechende Bedingung erfüllt ist oder nicht, wird die eine oder die andere Anweisung ausgeführt. Im obigen Beispiel wird der Wert der Variablen a nur dann dekrementiert, falls der Wert der Variablen a größer ist als der Wert der Variable b, ansonsten wird hier im Vergleich zur bedingten Anweisung allerdings der Wert der Variablen b um eins erniedrigt. In beiden Fällen wird das Programm anschließend hinter der ende-Marke fortgeführt.

====Mehrfache Verzweigung====
[[Datei:Mehrseitige Auswahl.png|mini|rechts|hochkant=2|Struktogramm einer mehrfachen Verzweigung.]]

Eine mehrfache Verzweigung (zum Beispiel switch - case - else - end) enthält mehr als zwei alternative Programmpfade, die meist, wie auch im folgenden Beispiel, von ganzzahligen Ausdrücken gesteuert werden:

 verzweige mit dem Wert von a
    falls 1 : unterprogramm_A ()
    falls 2 : unterprogramm_B ()
    falls 3 : unterprogramm_C ()
    ansonsten unterprogramm_D ()
 ende

In Abhängigkeit des in der ganzzahligen Variablen a gespeicherten Zahlenwertes wird genau eines der vier angegebenen Unterprogramme aufgerufen; beim Wert 1 unterprogramm_A, beim Wert 2 unterprogramm_B, beim Wert 3 unterprogramm_C und ansonsten unterprogramm_D. Danach wird der Programmablauf hinter den ende-Marke fortgeführt.

In manchen weniger stakt strukturierten Programmiersprachen wie C sind Vorsicht und Aufmerksamkeit geboten, weil beispielsweise dort die verschiedenen Fälle der entsprechenden switch-Anweisung nur optional mit einer break-Anweisung und nicht immer und obligatorisch abgeschlossen werden. Dies nutzen einige Programmierer, um in bestimmten Situationen mehrere Fälle hintereinander abarbeiten zu lassen. Dieses Vorgehen ist jedoch hochgradig unstrukturiert und führt sehr schnell und unübersichtlichem Programmcode und somit sehr leicht zu Programmierfehlern. Dies kann vermieden werden, wenn in diesen Programmiersprachen hinter jedem unterschiedenem Fall kategorisch die break-Anweisung implementiert wird, auch wenn die Programmiersprache oder der Übersetzer dies nicht fordern.

[[Datei:MehrfAusw.png|mini|rechts|hochkant=2|Struktogramm mit verschachtelten einfachen Verzweigungen, um eine mehrfache Verzweigung zu implementieren.]]

Mehrfache Verzweigungen mit aufeinanderfolgenden numerischen oder aufzählbaren Werten, wie im obigen Beispiel 1, 2 und 3, können rechnerintern unter Umständen effizient genutzt werden, weil die Sprungadressen arithmetisch berechnet werden können. Dies ist bei modernen Laufzeitsystemen in der Regel aber nicht mehr so relevant, und diese mehrfachen Verzweigungen können auch immer durch mehrfache Fallunterscheidungen programmiert werden. Durch eine eigene Anweisung für die mehrfache Verzweigung kann die Übersichtlichkeit des Quelltextes allerdings oft gesteigert werden. Auf der anderen Seite können die Übersichtlichkeit und die Nachvollziehbarkeit in der Regel auch hier mit entsprechenden Unterprogrammaufrufen gesteigert werden.

===Schleifen===
Bei Schleifen wird eine Anweisungsfolge nur dann ausgeführt, wenn die entsprechende boolesche, im Sinne der Schleife lokale Laufvariable den Wert &quot;wahr&quot; hat. Alle Schleifen können auf eine grundlegende Form zurückgeführt werden, bei der ein wesentliches Merkmal ist, ob die Laufvariable '''zu Beginn''' der Schleifenanweisungen den initialen Wert &quot;wahr&quot; erhält (fußgesteuert) oder in der Anfangsbedingung durch einen variablen booleschen Ausdruck bestimmt ist (kopfgesteuert). Es ist sinnvoll, dass diese Laufvariable nur zum Zwischenspeichern der Abbruchbedingung dient und ausschließlich im Zusammenhang mit der Schleife verwendet wird.

Bei wohlstrukturierter Programmierung mit zählenden Schleifen können numerische Laufvariablen verwendet werden, die innerhalb der Schleife vorzugsweise erst in der letzten Anweisung der Schleife aktualisiert werden, damit es innerhalb des Schleifendurchlaufs nicht zu Inkonsistenzen, Verwechslungen oder Mehrdeutigkeiten kommen kann.

Ferner gibt es in der strukturierten Programmierung keine expliziten Sprunganweisungen, die irgendwo innerhalb einer Schleife zum Beispiel mit dem Kommando '''continue''' den Rest der Schleife überspringen und sofort die nächstfolgende Abbruchbedingung der Schleife prüfen lassen. Innerhalb von Schleifen ist es ohne Weiteres möglich, alle Zwischenschritte mit Verzweigungen zu steuern beziehungsweise alle Zwischenergebnisse in lokalen Variablen zu speichern, ohne dass es in modernen Computersystemen zu längeren Ausführungszeiten kommt.

Im Folgenden soll dies mit der Programmiersprache Java an sehr einfachen Schleifen, die alle Zahlen außer der Fünf von Eins bis Zehn ausgeben sollen, erläutert werden.

Unstrukturiertes Beispiel:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
long i = 1;
do
{
  if (i == 5)
  {
    i++; // Die Schleifenendanweisung zum Hochzaehlen der Laufvariable muss hier dupliziert werden, damit es nicht zu einer Fehlfunktion kommt.
    continue; // Die Schleife wird durch diese explizite Sprunganweisung unstrukturiert abgebrochen.
  }
  java.lang.System.out.println (i);
  i++;
} while (i &lt;= 10);
&lt;/syntaxhighlight&gt;

Strukturiertes Beispiel:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
long i = 1;
do
{
  if (i != 5)
  {
     java.lang.System.out.println (i);
  }
  i++;
} while (i &lt;= 10);
&lt;/syntaxhighlight&gt;

====Kopfgesteuerte Schleifen====
[[Datei:KopfgesteuerteSchleife.png|mini|rechts|hochkant=2|Struktogramm einer kopfgesteuerten Schleife.]]

Kopfgesteuerte Schleifen werden auch als '''While'''-Anweisungen bezeichnet.

{| class=&quot;wikitable&quot; style=&quot;text-align:center&quot;
| rowspan=&quot;4&quot; | Kopfgesteuerte Schleife
| colspan=&quot;2&quot; | Setze Laufvariable auf boolesche Anfangsbedingung
|-
| rowspan=&quot;3&quot; | Solange wie die Laufvariable den Wert &quot;wahr&quot; hat führe aus
|-
|Anweisungsfolge
|-
| Setze Laufvariable auf boolesche Endbedingung
|}

Wenn die boolesche Anfangsbedingung zu Beginn den Wert &quot;falsch&quot; hat, wird die Schleife '''nicht durchlaufen'''.

====Fußgesteuerte Schleifen====
[[Datei:FussgesteuerteSchleife.png|mini|rechts|hochkant=2|Struktogramm einer fußgesteuerten Schleife.]]

Die fußgesteuerte Schleife, die auch '''Repeat'''-Anweisung genannt wird, ist ein Sonderfall der kopfgesteuerten Schleife, bei der die boolesche Anfangsbedingung immer auf &quot;wahr&quot; gesetzt wird. Daher wird eine fußgesteuerte Schleife '''immer mindestens einmal durchlaufen'''.

{| class=&quot;wikitable&quot; style=&quot;text-align:center&quot;
| rowspan=&quot;4&quot; | Fußgesteuerte Schleife
| colspan=&quot;2&quot; | Setze Laufvariable auf &quot;wahr&quot;
|-
| rowspan=&quot;3&quot; | Solange wie die Laufvariable den Wert &quot;wahr&quot; hat führe aus
|-
|Anweisungsfolge
|-
| Setze Laufvariable auf boolesche Endbedingung
|}

Da der Ausdruck der booleschen Anfangs- und Endbedingung oft identisch formuliert ist, bietet es sich an, dafür einen Funktionsaufruf zu verwenden, um eine Codewiederholung zu vermeiden.

Aus Gründen der Laufzeiteffizienz wird das Setzen der Laufvariablen zu Beginn und die erstmalige Überprüfung der Laufvariablen oft weggelassen, was für die allermeisten Anwendungen heute jedoch unwesentlich ist. Da die Laufvariable in diesem Fall zu Beginn jedoch nicht definiert werden muss und daher gegebenenfalls auch gar nicht definiert wird, birgt dieses Vorgehen die Gefahr in sich, dass die Laufvariable ihren undefinierten Zustand behält. Insbesondere tritt dies ein, wenn das Setzen der Laufvariable auf eine boolesche Endbedingung nicht erfolgt, weil dies in der verwendeten Programmiersprache nicht obligatorisch ist beziehungsweise vom Programmierer vergessen wurde, oder weil dies wegen eines zwangsläufig unstrukturierten Abbruchs innerhalb der Schleife (zum Beispiel mit einer Break-Anweisung) gar nicht erfolgen kann.

====Endlosschleifen====
'''Endlosschleifen''' sind unstrukturiert, da das Programm nicht regelgerecht beendet werden kann. Daher sind diese sogenannten Loop-Anweisungen, wie zum Beispiel

 for (;;)
 {
    ...
 }

 while (true)
 {
    ...
 }

 repeat
 {
    ...
 }
 until (false)

beziehungsweise

 do
 {
    ...
 }
 while (true)

oder

 loop
 {
    ...
 }

zu unterlassen. Insbesondere das Verlassen von Endlosschleifen mit einer '''Sprunganweisung''' oder gar mehreren potentiellen Sprunganweisungen, wie zum Beispiel ''break'' oder ''exit'', ist hochgradig unstrukturierte Programmierung, da der Ausstiegszeitpunkt oder die Stelle des Ausstiegs aus der Schleife (wenn überhaupt) nur schwierig nachzuvollziehen oder zu bestimmen ist.

====For-Schleifen====
Die For-Schleifen-Anweisung

 int i
 for (i ← 0; i &lt; max; i++)
 {
  ...
 }

ist identisch mit der kopfgesteuerten while-Anweisung:

 int i
 i ← 0
 while (i &lt; max)
 {
  ...
  i = i + 1
 }

Es ist im Sinne eines einfachen Sprachumfangs und eines einheitlichen Sprachstils unter Umständen nützlich, für kopfgesteuerte Schleifen keine For-Schleifen, sondern ausschließlich While-Schleifen zu benutzen.

Wenn die Programmiersprache es erlaubt, Zählvariablen ausschließlich für eine Schleife zu definieren, dann hat dies den Vorteil, dass das Prinzip der Lokalität für diese Zählvariablen sehr gut erfüllt ist, da die Zählvariable dann außerhalb der Schleife nicht sichtbar ist und somit auch nicht verwendet werden kann:

 for (int i ← 0; i &lt; max; i++)
 {
  ...
 }

Die äquivalente Schreibweise mit einer while-Schleife sieht wie folgt aus, wobei die äußere Blockanweisung dafür sorgt, dass die Zählvariable &quot;i&quot; innerhalb der Blockanweisung deklariert ist und nur in Verbindung mit der Schleife sichtbar respektive verwendbar ist:

 {
    int i
    i ← 0
    while (i &lt; max)
    {
     ...
     i++
    }
 }

Bei Algorithmen, die aus mehreren Kontrollstrukturen bestehen, ist es im Sinne der besseren Strukturierung vorzuziehen, alle Schleifen in eigene Methoden auszulagern, die aufgerufen werden und deren Schnittstellen über ihre Parameter eindeutig festgelegt sind. Hierbei können die Schleifen verschachtelt sein (innere und äußere Schleife) oder hintereinander ausgeführt werden. In jedem Fall sind alle Parameter und Variablen (also auch die jeweiligen Zählvariablen) innerhalb der entsprechenden Methoden lokal verfügbar.

==Codewiederholungen==
Codewiederholungen gehören insbesondere bei Anfängern sehr häufig zu den kapitalen Fehlern beim Softwareentwurf. Es ist nur scheinbar bequem, bereits vorhandenen Quelltext zu kopieren und für eine ähnliche Aufgabe geringfügig anzupassen. Es ist Größenordnungen besser, den bereits vorhandenen Quelltext so anzupassen, dass er für alle ähnlichen oder zumindest mehrere ähnliche Aufgabenstellungen eingesetzt werden kann. Erfahrene Programmierer wittern schon von Anfang an, dass eine bestimmte Methode auch in einem ähnlichen Kontext eingesetzt werden könnte und entwerfen den Code von vornherein so allgemein wie möglich.

===Symbolische Konstanten===
Konstante Ausdrücke werden in der Regel als '''symbolische Konstanten''' definiert, wie zum Beispiel mit der symbolischen Konstante &quot;Pi&quot; für die Kreiszahl oder die symbolische Konstante &quot;Title&quot; für den Text &quot;Programmierung&quot;:

 const double Pi ← 3.141592654
 const String Title ← &quot;Programmierung&quot;

Statt konstante Ausdrücke zu wiederholen – und sei es nur eine ganze Zahl – ist es erheblich besser, stattdessen eine symbolische Konstante mit einem „sprechenden“ Bezeichner zu verwenden.

Also nicht mit der ganzen Zahl 3:

 int inputNumber ← 3
 ...
 if (inputNumber = 3) ...

Sondern besser mit der symbolischen Konstante &quot;Exit&quot; mit dem unveränderlichen, ganzzahligen Wert 3:

 const int Exit ← 3
 
 int inputNumber ← Exit
 ...
 if (inputNumber = Exit) ...

Oder nicht zweimal mit derselben ganzen Zahl 3:

 if (a &gt; 3) and (b &gt; 3) ...

Sondern besser mit zwei verschiedenen symbolischen Konstanten &quot;Limit_a&quot; und &quot;Limit_b&quot;:

 const int Limit_a ← 3
 const int Limit_b ← 3
 
 if (a &gt; Limit_a) and (b &gt; Limit_b) ...

Auf diese Weise kann auch leicht vermieden werden, dass gleichlautende Ausdrücke mit unterschiedlicher Bedeutung verwechselt werden können, insbesondere wenn sie später einmal geändert werden müssen:

 if (numberOfConstellation &gt; 12)
 {
    Ausgabe (&quot;Diese Sternbildnummer ist ungültig.&quot;)
 }
 
 if (numberOfHalftones &gt; 12)
 {
    Ausgabe (&quot;Das Intervall ist größer als eine Oktave.&quot;)
 }

Die beiden konstanten Zahlensymbole &quot;12&quot; haben nichts außer ihrem Zahlenwert gemeinsam, und daher ist der folgende Code erheblich besser nachvollziehbar:

 const int Number_Of_Constellations ← 12
 const int Number_Of_Halftones_Per_Octave ← 12
 
 ...
 
 if (numberOfConstellation &gt; Number_Of_Constellations)
 {
    Ausgabe (&quot;Diese Sternbildnummer ist ungültig.&quot;)
 }
 
 if (numberOfHalftones &gt; Number_Of_Halftones_Per_Octave)
 {
    Ausgabe (&quot;Das Intervall ist größer als eine Oktave.&quot;)
 }

===Aufruf von Unterprogrammen===
[[Datei:Aufruf.png|mini|rechts|hochkant=2|Struktogramm eines Unterprogrammaufrufs.]]

Unterprogramme, die in vielen Programmiersprachen auch Methoden, Prozeduren oder Funktionen genannt werden, beinhalten sequenzielle Rechenvorschriften (Algorithmen) zum Bearbeiten von Daten, die zu einer Einheit zusammengefasst sind.

So kann zum Beispiel die Rechenvorschrift für die Berechnung des Kreisumfangs aus dem Kreisradius als Folge von Programmanweisungen formuliert werden, aber auch in eine Methode ausgelagert werden. Dieses Unterprogramm kann dann irgendwo im Programmcode aufgerufen werden. Dies gewinnt besonders dann Bedeutung, wenn das Unterprogramm an verschiedenen Stellen aufgerufen werden soll, so dass dann diese Programmanweisungen nicht mehrfach programmiert oder kopiert werden müssen.

Insbesondere wenn die ursprünglichen, an mehreren Stellen auftauchenden Programmanweisungen einen Fehler enthalten, muss dieser nach dem Entdecken des Fehlers - also möglicherweise zu einem viel späteren Zeitpunkt - zur Fehlerbehebung zwangsweise an mehreren Stellen im Programmcode korrigiert werden. Das ist nicht nur mühsam, sondern einzelne relevante Stellen können leicht übersehen werden, so dass der entdeckte Fehler gar nicht vollständig ausgemerzt wird.

Die mehrfach eingegebenen Programmanweisungen zur Berechnung des Kreisumfangs werden beim Auftreten von '''Codewiederholung''' an drei Stellen des Quelltextes programmiert:

 const double Pi ← 3.141592654
 
 double perimeter1 ← radius1 * 2 * Pi
 double perimeter2 ← radius2 * 2 * Pi
 double perimeter3 ← radius3 * 2 * Pi

Mithilfe des im Unterprogramm &quot;perimeter&quot; nur einmal implementierten Algorithmus' zur Ermittlung des Kreisumfangs und dessen dreimaligem Aufruf kann die Wiederholung der Implementierung der Rechenvorschrift leicht vermieden werden:

 /* &quot;perimeter&quot; computes and returns the perimeter of a circle with radius &quot;radius&quot; */
 double perimeter (radius)
 {
    const double Pi ← 3.141592654
    double perimeter ← radius * 2 * Pi
    return perimeter
 }
 
 double perimeter1 ← perimeter (radius1)
 double perimeter2 ← perimeter (radius2)
 double perimeter3 ← perimeter (radius3)

==Zuweisungskompatibilität==
'''Zuweisungskompatibilität''' liegt vor, wenn Ausdrücke und Variablen aufgrund hinreichend kompatibler Datentypen einander zugewiesen, miteinander verglichen oder eindeutig miteinander verknüpft werden können.

Es kann bereits im Quelltext überprüft werden, ob eine hinreichende Zuweisungskompatibilität vorliegt. Liegt diese nicht vor, handelt es sich um eine Typverletzung, und es muss eine explizite Typumwandlung programmiert werden. In diesem Fall kann es sehr leicht zu Programmfehlern kommen.

Programmiersprachen, die für die maschinennahe Programmierung konzipiert wurden, wie zum Beispiel Assemblersprachen oder die Programmiersprache C, haben oft gar keine oder nur eine sehr schwache Typprüfung, was sehr leicht zu Programmfehlern führen kann.

In manchen Programmiersprachen, wie zum Beispiel C, ist es sogar erlaubt, beliebige Zeiger einer Zeigervariablen zuzuweisen, ohne dass geprüft wird oder überhaupt geprüft werden kann, ob die Datentypen der referenzierten Daten kompatibel sind.

===Zeichenketten===
Ein weiteres schwerwiegendes Problem kann sich bei der Verwendung von Zeichenketten (englisch: string) ergeben, die in der Regel zum Speichern von Texten Verwendung finden und die aus einer Sequenz von einzelnen Zeichen respektive Buchstaben (englisch: character) bestehen.

Eine strukturierte Programmiersprache, die Zeichenkettenverarbeitung und einen entsprechenden Datentyp zur Verfügung stellt, sollte fordern, dass jede Zeichenkette mit einem Zeichen abgeschlossen wird, das das Ende der Zeichenkette markiert (englisch: string terminator). Hierfür wird allgemein das Zeichen mit dem numerischen Wert null verwendet, das keinen Buchstaben repräsentiert und in Quelltexten häufig mit den Symbolen NUL, 0X oder \0 kodiert wird.

Manche unstrukturierte Programmiersprachen fordern nicht, dass eine solche Kennzeichnung des Endes der Zeichenkette verwendet werden muss. Bei der Implementation von Zeichenkettenfunktionen in Programmbibliotheken, insbesondere wenn die dazugehörige Programmiersprache gar keinen Datentyp für Zeichenketten zur Verfügung stellt, ist auch bei strukturierten Programmiersprachen nicht unbedingt gewährleistet, dass eine entsprechende Kennzeichnung des Zeichenkettenendes obligatorisch ist. Bei der Implementierung von Vergleichsfunktionen oder Zeichenkettenmanipulationen in unstrukturierten Programmiersprachen oder Programmbibliotheken muss die Tatsache, ob das Nullzeichen vorhanden ist oder nicht, regelmäßig untersucht und berücksichtigt werden. Einfacher und sicherer ist es, mit einer strukturierten Programmiersprache oder einer entsprechenden Programmbibliothek zu arbeiten, bei der immer gewährleistet ist und vorausgesetzt werden kann, dass alle Zeichenketten mit einem Endezeichen abgeschlossen sind.

===Strenge Zuweisungskompatibilität===
Zuweisungen sind uneingeschränkt zulässig, wenn eine strenge Zuweisungskompatibilität gegeben ist. Dazu müssen die Datentypen eines zuzuweisenden Ausdrucks und einer Variable exakt übereinstimmen, wie in folgendem Beispiel mit dem Datentyp &quot;Mann&quot; und den beiden Instanzen &quot;otto&quot; und &quot;emil&quot;:

 TYPE Mann = Verbund von alter und groesse
 
 VARIABLE otto, emil: Mann
 
 otto.alter   ← 50
 otto.groesse ← 1.80
 
 emil ← otto

Alle Attribute von „otto“, nämlich „alter“ und „groesse“, können „emil“ eindeutig zugewiesen werden.

Zwei Instanzen sind streng zuweisungskompatibel, wenn sie derselben Klasse angehören, wie in diesem Beispiel die beiden Objekte &quot;fenster1&quot; und &quot;fenster2&quot; aus der Klasse &quot;Rechteck&quot;:

 TYPE Rechteck = Klasse mit breite, hoehe und mit Methode flaechenberechnung&amp;nbsp;()
 
 VARIABLE fenster1, fenster2: Rechteck
 
 fenster1.breite ← 200
 fenster1.hoehe  ← 100
 fenster1.flaechenberechnung&amp;nbsp;() (Flächenberechnung für „fenster1“ ausführen)
 
 fenster2 ← fenster1
 fenster2.flaechenberechnung&amp;nbsp;() (Flächenberechnung für „fenster2“ ausführen)

Die Zuweisung in der vorletzten Programmzeile ist möglich, da beide Instanzvariablen &quot;fenster1&quot; und &quot;fenster2&quot; derselben Klasse &quot;Rechteck&quot; angehören, und daher liefert auch der Methodenaufruf in der letzten Programmzeile ein korrektes Ergebnis.

====Logische Kompatibilität====
Zwei übereinstimmende Definitionen von zwei Datentypen sind nicht zuweisungskompatibel. Die Daten können zwar eindeutig überführt werden (technische Kompatibilität), es liegen zwei formal zwar identische, aber dennoch verschiedene Definitionen vor, so dass diese keine logische Kompatibilität aufweisen. Folgendes Beispiel wäre demzufolge formal korrekt, aber nicht logisch:

 TYPE Mann = Verbund von alter und groesse
 TYPE Frau = Verbund von alter und groesse
 
 VARIABLE otto: Mann
 VARIABLE anna: Frau
 
 otto.alter   ← 50
 otto.groesse ← 1.80
 
 anna ← otto

Die Zuweisung in der letzten Programmzeile ist technisch zwar ohne Probleme möglich, aber logisch nicht korrekt, und sie birgt daher die Gefahr der Entstehung von Programmierfehlern. Um solche Fehler zu vermeiden, sind Zuweisungen mit impliziter Typumwandlung in einigen Programmiersprachen mit starker Typisierung nicht zulässig, und der Compiler verweigert die Übersetzung dieser Zuweisung.

In der objektorientierten Programmierung kann durch die Vererbung der gemeinsamen Eigenschaften von Datentypen leicht eine logische Kompatibilität hergestellt werden:

 TYPE Mensch = Verbund von alter und groesse
 
 TYPE Mann = Mensch
 TYPE Frau = Mensch
 
 VARIABLE otto: Mann
 VARIABLE anna: Frau
 
 otto.alter   ← 50
 otto.groesse ← 1.80
 
 anna ← otto

Die Objekteigenschaften &quot;alter&quot; und &quot;groesse&quot; sind hierbei Eigenschaften von Objekten des Datentyps &quot;Mensch&quot; und daher sowohl zuweisungskompatibel, als auch logisch korrekt; bei der Zuweisung können und werden nur die Attribute &quot;alter&quot; und &quot;groesse&quot; der gemeinsamen Basisklasse &quot;Mensch&quot; übertragen.

====Wahrheitswerte====
In einigen älteren Programmiersprachen, wie zum Beispiel C, gibt es keinen eigenen Datentyp für zweiwertige boolesche Variablen. Zur Behandlung und Verarbeitung entsprechender Information wird dann häufig der ganzzahlige Datentyp mit dem kleinsten Speicherbedarf verwendet, wobei der Zahlenwert null für den Wahrheitswert „Falsch“ und alle anderen Zahlenwerte für den Wahrheitswert „Wahr“ Verwendung finden. Auch hier ergeben sich logische Inkompatibilitäten und somit ein gefährliches Potential für Komplikationen, da mit binären Werten keine Arithmetik und mit Zahlen keine logischen Verknüpfungen oder logischen Operationen durchgeführt werden können. Im folgenden Beispiel wird dieser Missbrauch verdeutlicht:

 VARIABLE schlechteWahrheit1, schlechteWahrheit2, ergebnisWahrheit: INTEGER
 
 schlechteWahrheit1 ← 0
 schlechteWahrheit2 ← 1
 
 ergebnisWahrheit ← (schlechteWahrheit1 + schlechteWahrheit2)
 
 ergebnisWahrheit ← (schlechteWahrheit2 + schlechteWahrheit2)

Das Ergebnis der ersten arithmetischen Addition ist 1, was fälschlich als der Wahrheitswert „Wahr“ missinterpretiert werden könnte, der nicht dem Ergebnis der logischen Und-Verknüpfung entspricht. Noch offensichtlicher ist das Problem in der zweiten arithmetischen Addition, wo das Ergebnis 2 erzielt wird. Somit existieren ohne Not mehr als zwei Zustände für die binären (also zweiwertigen) Variablen, was schnell zu Missverständnissen und Programmierfehlern führen kann.

Eine eindeutige und korrekte Implementierung wird erreicht, wenn die Programmiersprache oder eine dazugehörige Programmbibliothek einen zweiwertigen Datentyp, wie zum Beispiel „BOOLEAN“ oder „bool“, zwei entsprechende Ausprägungen, wie zum Beispiel &quot;false&quot; und &quot;true&quot;, und die dazugehörigen eindeutigen booleschen Operatoren und Funktionen (beispielsweise &quot;and&quot;, &quot;or&quot; oder &quot;not&quot;) anbietet.

 VARIABLE richtigeWahrheit1, richtigeWahrheit2, ergebnisWahrheit: BOOLEAN
 
 richtigeWahrheit1 ← falsch
 richtigeWahrheit2 ← wahr
 
 ergebnisWahrheit ← (richtigeWahrheit1 und richtigeWahrheit2)
 
 ergebnisWahrheit ← (richtigeWahrheit2 und richtigeWahrheit2)

Sinngemäß gilt das Gleiche für die Verknüpfungen von Mengen. Wenn hier bei den Datentypen und zulässigen Operatoren nicht zwischen Bitmengen (englisch: (bit) sets) und Zahlen unterschieden wird, kommt es wie zum Beispiel bei der Bestimmung von Vereinigungs- oder Differenzmengen zu Interpretationsproblemen. Eine eindeutige und korrekte Implementierung verwendet Datentypen, die für Mengen und Mengenoperationen definiert sind. In einigen Programmiersprachen werden solche Datentypen im Sprachumfang implizit angeboten, in anderen gibt es dafür standardisierte Programmbibliotheken, auf die über Unterprogrammaufrufe zugegriffen werden kann.

===Zuweisungskompatibilität ohne Informationsverlust===
In einigen Fällen kann die Information, die mit einem Datentyp dargestellt werden kann, eindeutig und ohne Informationsverlust in einen anderen Datentyp überführt werden. Typische Beispiele sind ganze Zahlen mit unterschiedlicher Speichergröße. So kann ein Integer mit 16&amp;nbsp;Bit Speichergröße eindeutig in einer vorzeichenbehafteten Integer-Variablen mit 32&amp;nbsp;Bit Speichergröße abgelegt werden, ohne dass die ursprünglich nur mit 16&amp;nbsp;Bit gespeicherte Zahl verändert wird. Umgekehrt ist dies jedoch nicht allgemein möglich, insbesondere unter der Beachtung von Vorzeichen und großen Zahlen. Der folgende Programmierabschnitt zeigt ein Beispiel ohne Zuweisungskompatibilität, da der Datentyp „BYTE“ nur 8&amp;nbsp;Bit Speichertiefe hat und nur Werte zwischen -128 bis +127 und somit nicht die Zahl 555 repräsentieren kann, wohingegen der Datentyp „SHORTINT“ eine Speichertiefe von 16&amp;nbsp;Bit hat und ganze Zahlen von -32768 bis +32767 repräsentieren kann:

 zahl1: BYTE
 zahl2: SHORTINT
 
 zahl2 ← 555
 zahl1 ← zahl2

Die letzte Programmzeile stellt einen ungültigen Versuch der Zuweisung der ganzen Zahl&amp;nbsp;555 aus der Variablen „zahl2“ an die Variable „zahl1“ dar.

Bei einer solchen Programmanweisung kann bei typsicheren Programmiersprachen bereits der Compiler verhindern, dass ausführbarer Maschinencode erzeugt wird. Bei fehlender Überprüfung durch den Compiler kann unbemerkt Information verloren gehen, so dass bei nachfolgenden Berechnungen unter Umständen grobe Berechnungsfehler auftreten, die relativ schwierig zu analysieren sind.

===Zuweisungskompatibilität mit geringem Informationsverlust===
Ein Sonderfall ist die Zuweisung von ganzen Zahlen an Variablen, die Gleitkommazahlen repräsentieren. In der Regel kann ohne die Gefahr von Programmfehlern toleriert werden, große ganze Zahlen implizit in Gleitkommazahlen umzuwandeln, da der Rechenfehler (wenn überhaupt vorhanden) hierbei sehr klein ist. Auch dies kann an einem Beispiel verdeutlicht werden: ein „LONGINT“ mit 64&amp;nbsp;Bit Speichergröße kann die Zahl 9223372036854775807 mit 19 Dezimalstellen speichern. Der folgende Programmierabschnitt zeigt ein Beispiel mit Zuweisungskompatibilität mit einem in der Regel zu vernachlässigenden Informationsverlust, da der Datentyp „REAL“ nach IEEE 754 mit 64&amp;nbsp;Bit nur Zahlen mit einer Mantisse mit maximal 14 Nachkommastellen speichern kann:

 zahl1: LONGINT
 zahl2: REAL
 
 zahl1 ← 9223372036854775807
 zahl2 ← zahl1

Die letzte Anweisung stellt in fast allen Programmiersprachen einen gültigen Versuch der Zuweisung der ganzen Zahl&amp;nbsp;&lt;math&gt;{2}^{63} - 1&lt;/math&gt; aus der Variablen „zahl1“ an die Variable „zahl2“ dar, da diese gerundeten Zahlenwert &lt;math&gt;9{,}22337203685478 \cdot {10}^{18}&lt;/math&gt; enthält, und der Fehler durch das Abschneiden der letzten Nachkommastellen hier nur in einer Größenordnung von &lt;math&gt;{10}^{-14}&lt;/math&gt; liegt und daher für praktisch alle Anwendungen vernachlässigt werden kann.

Bei einer erneuten Datentypkonvertierung zurück zu einem geeigneten ganzzahligen Datentyp kommt es dann aber zu einer Abweichung zu der ursprünglichen ganzen Zahl. In solchen Fällen ist es daher besser, vorsichtshalber und mit Inkaufnahme etwas längerer Programmlaufzeiten ausschließlich mit Gleitkommazahlen zu operieren.

===Zuweisungskompatibilität mit definiertem Informationsverlust===
Zwei Instanzen sind mit definiertem Informationsverlust zuweisungskompatibel, wenn die zuzuweisende Klasse einer Klasse angehört, die von der zugewiesenen Klasse abgeleitet wurde. Alle Daten die in der zugewiesenen Klasse deklariert und somit erforderlich sind, können dann zugewiesen werden, jedoch werden die in der zuzuweisenden abgeleiteten Klasse möglicherweise hinzugefügten Attribute ignoriert, wie das folgende Beispiel verdeutlichen soll, in welchem der Datentyp „Mensch“ alle Eigenschaften vom Datentyp „Lebewesen“ erbt und zusätzlich das Attribut „intelligenzquotient“ bekommt:

 TYPE Lebewesen = Verbund von alter und gewicht
 
 TYPE Mensch = Lebewesen mit intelligenzquotient
 
 VARIABLE     otto: Mensch
 VARIABLE eukaryot: Lebewesen
 
 otto.alter               ← 50
 otto.gewicht             ← 75
 otto.intelligenzquotient ← 100
 
 eukaryot ← otto

Die Zuweisung in der letzten Zeile ist korrekt, das Attribut „intelligenzquotient“ der Variable „otto“ vom Datentyp „Mensch“ wird jedoch nicht an die Variable „eukaryot“ zugewiesen, da es beim Datentyp „Lebewesen“ der Basisklasse nicht deklariert ist.

==Komplexe Ausdrücke==
Zusammengesetzte Ausdrücke mit verschiedenartigen Operatoren können sehr unübersichtlich und somit fehleranfällig sein. Manche Programmiersprachen haben sehr viele Hierarchieebenen für Operatoren, die auch durch erfahrene Programmierer kaum durchschaut werden können, oder sogar dafür sorgen, dass bestimmte Teile des Quellcodes zur Laufzeit gar nicht erreicht werden können. Daher ist es dringend empfehlenswert, Anweisungen in kleine, überschaubare Einheiten zu untergliedern. In einigen Programmiersprachen ist es sogar möglich, die Zuweisung in andere Anweisungen zu integrieren, da sie selber als ein Ergebniswert interpretiert werden darf. Ferner ist nicht immer offensichtlich welchen Datentyp ein Ergebnis hat, was insbesondere in Ermangelung eines zweiwertigen Datentyps ''Boolean'' zu Missverständnissen führen kann.

Also zum Beispiel nicht:

 if (a ← b – c = 0) ...

In dieser bedingten Anweisung (if) ist nicht klar, in welcher Reihenfolge der Zuweisungsoperator (←), der Differenzoperator (-) und der Vergleichsoperator (=) ausgeführt werden (sollen). 

Es ist erheblich besser, die Anweisungen klar zu trennen:

 a ← (b – c)
 if (a = 0) ...

Die folgenden beiden Beispiele mit dem Zuweisungsoperator &quot;=&quot; und dem Vergleichsoperator &quot;==&quot; zeigen Programmsequenzen in der Programmiersprache C, die zu sehr leicht zu übersehenden Programmierfehlern führen können:

&lt;syntaxhighlight lang=&quot;C&quot;&gt;
 /* Programmiersprache C */
 int i = 0;
 if (i = 1)
 {
    /*
       Dieser Block wird immer ausgeführt,
       weil die Zuweisung i = 1 immer das numerische Ergebnis 1 hat,
       was als der boolesche Wert &quot;wahr&quot; interpretiert wird.
    */
 }
 
 int i = 0;
 if (i == 1)
 {
    /*
       Dieser Block wird nie ausgeführt,
       weil die Vergleichsoperation i == 1 immer das numerische Ergebnis 0 hat,
       was als der boolesche Wert &quot;falsch&quot; interpretiert wird.
    */
 }
&lt;/syntaxhighlight&gt;

Die folgende Rückgabe-Anweisung (&quot;return&quot;) in der Programmiersprache Java ist nicht nur verwirrend, sondern sinnfrei:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 2;
 long y = 1;
 return y + x--;
&lt;/syntaxhighlight&gt;

Der Dekrement-Operator &quot;- -&quot; wird in vielen Programmiersprachen gar nicht ausgeführt, weil er hierarchisch erst nach einer Zuweisung ausgeführt wird oder nach einer die Code-Sequenz beendende Return-Anweisung noch ausgeführt werden müsste, aber de facto gar nicht mehr ausgeführt wird. Deswegen ist die folgende Anweisungsfolge nicht nur weniger komplex, gut strukturiert und korrekt, sondern auch sinnvoll und leicht sowie eindeutig nachvollziehbar:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 2;
 long y = 1;
 x--;
 long summe = y + x;
 return summe;
&lt;/syntaxhighlight&gt;

Beeindruckend sinnlos, verwirrend und komplex sind Monster-Ausdrücke (nach Niklaus Wirth: ''notational monsters''), die in einigen Programmiersprachen wie zum Beispiel C erlaubt sind, wie zum Beispiel bei der Kombination einer Rücksprunganweisung (&quot;return&quot;) mit einer Zuweisung (&quot;=&quot;), zwei verschiedenen Inkrement-Operatoren (&quot;++&quot;) und einem Additionsoperator (&quot;+&quot;). Es ist sehr schwierig durchschaubar, in welcher Reihenfolge diese fünf Anweisungen ausgeführt werden und ob diese überhaupt ausgeführt werden. Selbst wenn die Zuweisung oder die nachrangige Inkrementierung ausgeführt würden, wären sie völlig sinnlos, da auf die lokale Variable i nach der Return-Anweisung gar nicht mehr zugegriffen werden kann:

&lt;syntaxhighlight lang=&quot;C&quot;&gt;
/* Programmiersprache C */
int i = 0;
return i = ++i+i++;
&lt;/syntaxhighlight&gt;

Auch im folgenden Java-Beispiel ist die Sachlage nicht wesentlich besser. Das Ergebnis dieser Anweisungsfolge für die Variable y ergibt den Wert 2 + 2 = 4 , weil der letzte Inkrementoperator die Variable x vor der Ausführung aller anderen Operatoren auf den Wert 2 erhöht, und der erste Inkrementoperator die Variable x erst nach der Addition und der Zuweisung auf den Wert 3 erhöht:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 1;
 long y = x++ + ++x;
&lt;/syntaxhighlight&gt;

Es ist ebenfalls nicht leicht zu durchschauen, dass das Ergebnis dieser Anweisungsfolge in Java für die Variable y den Wert 2 + 3 = 5 ergibt, weil die Variable x vor der Auswertung des arithmetischen Summe zweimal inkrementiert wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 1;
 long y = ++x + ++x;
&lt;/syntaxhighlight&gt;

Ferner ist das Ergebnis der nächsten Anweisungsfolge in Java für die Variable y der Wert 2 + 2 = 4, weil die Variable x vor der Auswertung der arithmetischen Summe nur beim ersten Inkrementoperator für die Summenbildung wirksam verändert wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 1;
 long y = ++x + x++;
&lt;/syntaxhighlight&gt;

Auf der anderen Seite ist das Ergebnis der nächsten Anweisungsfolge in Java für die Variable y der Wert 1 + 2 = 3, weil die Variable x während der Auswertung des arithmetischen Ausdrucks nur beim ersten Inkrementoperator für die Summenbildung wirksam verändert wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 1;
 long y = x++ + x++;
&lt;/syntaxhighlight&gt;

Noch gefährlicher wird es, wenn die Reihenfolge der Auswertung von arithmetischen Ausdrücken mit gleichwertigen Operanden für den Compiler oder Interpreter nicht definiert ist:

&lt;syntaxhighlight lang=&quot;C&quot;&gt;
/* Programmiersprache C */
 int x = 1;
 long y = ++x * --x;
&lt;/syntaxhighlight&gt;

Wird die Multiplikation von links nach rechts ausgewertet, ergibt sich für die Variable y der Wert 2, wird die Multiplikation von rechts nach links ausgewertet, ergibt sich für die Variable y der Wert 0. Derselbe Quelltext kann auf zwei verschiedenen Systemen also völlig andere Rechenergebnisse hervorrufen.

In anderen Programmiersprachen werden die Inkremente und Dekremente von ganzzahligen Variablen daher mit Prozeduraufrufen bewerkstelligt (beispielsweise INC() und DEC()), die fester Bestandteil der Programmiersprache sind, wie zum Beispiel in Pascal, wo der Zuweisungsoperator aus zwei verschiedenen Zeichen besteht (&quot;:=&quot;), damit es keine Verwechslungen mit einem Identitätsoperator oder Vergleichsoperator geben kann:

&lt;syntaxhighlight lang=&quot;pascal&quot;&gt;
(* Programmiersprache Pascal *)
 VAR
    x, y, produkt: integer;
 BEGIN
    x := 1;
    INC (x);
    y := x;
    DEC (x);
    produkt := y * x;
 END;
&lt;/syntaxhighlight&gt;

Die Aufrufe der Inkrement- beziehungsweise Dekrementprozeduren dürfen und können –&amp;nbsp; genauso wie Zuweisungen&amp;nbsp;– in der Programmiersprache Pascal also gar nicht Bestandteil eines arithmetischen Ausdrucks sein, so dass der Zeitpunkt der Ausführung immer eindeutig aus der Reihenfolge der Anweisungen hervorgeht.

===Ternäre Operatoren===
Ein '''ternärer Operator''' hat als Ergebnis einen beliebigen Wert und verknüpft hierzu drei Ausdrücke:

* Der erste Ausdruck ein '''binärer Ausdruck''', der wahr oder falsch ist.
* Der zweite Ausdruck beschreibt den Ergebniswert, wenn der erste Ausdruck '''wahr''' ist.
* Der dritte Ausdruck beschreibt den Ergebniswert, wenn der erste Ausdruck '''falsch''' ist.

In vielen Programmiersprachen werden die drei Ausdrücke mit den Begrenzungszeichen ? und : voneinander getrennt, und der binäre Ausdruck wird eingebettet in runde Klammern vorangestellt:

 (binärer Ausdruck) ? zweiter Ausdruck : dritter Ausdruck

Jeder dieser drei Ausdrücke kann sich wiederum aus mehreren anderen Ausdrücken zusammensetzen, so dass der Überblick schnell verloren gehen kann.

Die Ergebniswerte von Ausdrücken mit ternären Operatoren sollten besser nicht in andere Ausdrücke eingesetzt werden, sondern in einer lokalen Variable zwischengespeichert und erst danach weiterverwendet werden:

 variable ergebnis;
 ergebnis ← (binärer Ausdruck) ? zweiter Ausdruck : dritter Ausdruck

Grundsätzlich ist es wegen der größeren Übersichtlichkeit, Transparenz und einfacheren Modifikation vorzuziehen, für das Ergebnis gar '''keine ternären Operatoren''' zu verwenden, sondern eine '''bedingte Anweisung mit Blockanweisungen''' zu verwenden:

 variable ergebnis;
 falls (binärer Ausdruck)
 dann
    Block für ergebnis ← zweiter Ausdruck
 ansonsten
    Block für ergebnis ← dritter Ausdruck
 ende

===Blockanweisungen===
'''Blockanweisungen''' sind ein elegantes Mittel, um Programmcode zu strukturieren sowie die Sichtbarkeit von lokalen Variablen zu begrenzen. In vielen Programmiersprachen werden eindeutige Symbole für die Kennzeichnung von Programmblöcken verwendet, wie zum Beispiel geschweifte Klammern:

 {
    ...
 }

Die drei Punkte stehen hierbei für beliebige Anweisungsfolgen.

In anderen Programmiersprachen werden Schlüsselwörter für die Begrenzung von Blockanweisungen verwendet, wie zum Beispiel &quot;BEGIN&quot; und &quot;END&quot;:

 BEGIN
    ...
 END

Der Blockinhalt mit Anweisungen -&amp;nbsp;in beiden obenstehenden Beispielen durch die drei aufeinanderfolgenden Punkte symbolisiert&amp;nbsp;-, wird in der Regel eingerückt, um die Lesbarkeit des Quelltextes für die Programmierer zu erleichtern.

Blockanweisungen können geschachtelt, dürfen -&amp;nbsp;sofern in der Syntax einer Programmiersprache überhaupt möglich&amp;nbsp;- jedoch nicht verschränkt werden. Dies bedeutet, dass bei geschachtelten Blöcken ein begonnener Block immer erst vollständig abgearbeitet werden muss, bevor der nächstäußere weitergeführt und abgeschlossen werden kann:

 {
    ... /* Äußerer Block */
    {
       ... /* Mittlerer Block */
       {
          ... /* Innerer Block */
       }
       ... /* Mittlerer Block */
    }
    ... /* Äußerer Block */
 }

Verschränkte Blockanweisungen sind unsinnig, unstrukturiert sowie überflüssig und daher in den meisten Programmiersprachen nicht zulässig:

 BEGIN1
    ...
    BEGIN2
       ...
    ...
 END1
 ...   ...
    END2

Die Implementationen von allen Modulen, Klassen und Unterprogrammen sowie auch von allen Kontrollstrukturen (also Fallunterscheidungen und Schleifen) sollten '''kategorisch mit Blockanweisungen''' strukturiert werden.

=== Blockanweisungen bei Kontrollstrukturen ===
[[Datei:lineareAnw.png|mini|rechts|hochkant=2|Struktogramm einer Anweisungsfolge.]]

Auch wenn die Programmiersprache die Verwendung von Blockanweisungen für Anweisungsfolgen in einer Kontrollstruktur nicht vorschreibt, ist es sehr ratsam, die Blockanweisung kategorisch einzusetzen, um Programmierfehler zu vermeiden. Wenn zum Beispiel eine if-Anweisung so wie in den Programmiersprachen C und Java so strukturiert ist, dass genau eine Folgeanweisung ausgeführt wird, wenn die Bedingung wahr ist, kann es ohne Blockanweisungen bei der Programmentwicklung oder -wartung leicht zu übersehenden Programmierfehlern kommen. Im folgenden korrekt formulierten Java-Programmbeispiel wird die Variable v1 auf den Wert null zurückgesetzt, falls sie den gleichen Zahlenwert wie max hat:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
    v1 = 0;
&lt;/syntaxhighlight&gt;

Soll zudem auch noch eine Textausgabe erfolgen, kann diese zusätzlich programmiert werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
    v1 = 0;
    java.lang.System.out.println (&quot;Der Maximalwert wurde erreicht.&quot;);
&lt;/syntaxhighlight&gt;

Die unterste Programmierzeile ist zwar eingerückt, was suggeriert, dass sie nur ausgeführt wird, wenn die darüberstehende Bedingung erfüllt ist. Ein Java-Interpreter führt jedoch nur eine einzige unmittelbar nach der Bedingung aufgeführte Anweisung aus, wenn die Bedingung wahr ist. Mit anderen Worten: die Textausgabe erfolgt im obigen Programmbeispiel immer, also insbesondere auch wenn die Variablen v1 und max nicht den gleichen Zahlenwert haben. Im Quelltext sollte das daher besser folgendermaßen formuliert werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
    v1 = 0;
 java.lang.System.out.println (&quot;Der Maximalwert wurde erreicht.&quot;);
&lt;/syntaxhighlight&gt;

Ähnlich tückisch ist die Tatsache, dass in manchen weniger streng strukturierten Programmiersprachen, auf die Bedingung der if-Anweisung eine beliebige Anweisung folgen darf, die nicht notwendigerweise eine Blockanweisung sein muss, sondern auch eine einzelne Anweisung sein darf, die zum Beispiel mit einem Semikolon abgeschlossen wird und auch eine '''leere Anweisung''' sein kann. Dies führt zu leicht zu übersehenden Programmierfehlern, wie im folgenden Beispiel:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max);
 {
    v1 = 0;
    java.lang.System.out.println (&quot;Der Maximalwert wurde erreicht.&quot;);
 }
&lt;/syntaxhighlight&gt;

Die Blockanweisung wird immer ausgeführt, obwohl ihre Darstellung mit korrekter Einrückung suggeriert, dass sie nur dann ausgeführt wird, wenn die boolesche Bedingung (v1 == max) erfüllt ist. Dies ist allerdings nicht der Fall, da direkt hinter den runden Klammern der if-Anweisung ein Semikolon steht, welches eine '''leere Anweisung''' implementiert, die bei der Erfüllung der Bedingung ausgeführt wird.

All diese Missverständnisse können leicht vermieden werden, indem bei der Programmierung von Kontrollstrukturen '''kategorisch Blockanweisungen''' verwendet werden, selbst wenn die Programmiersprache dies nicht fordert:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
 {
    v1 = 0;
 }
&lt;/syntaxhighlight&gt;

Beziehungsweise:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
 {
    v1 = 0;
    java.lang.System.out.println (&quot;Der Maximalwert wurde erreicht.&quot;);
 }
 else
 {
    java.lang.System.out.println (&quot;Der Maximalwert wurde nicht erreicht.&quot;);
 }
&lt;/syntaxhighlight&gt;

==== Verschachtelung ====
In noch stärkerem Maße leidet die Verständlichkeit von Quellcode, wenn mehrere Kontrollstrukturen ohne die Verwendung von Blockstrukturen verschachtelt werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long v1, v2, v3;
 v1 = 3;
 v2 = 3;
 v3 = 7;
 if ((v1 &gt; 0) &amp;&amp; (v2 &gt; 0))
    if (v1 &gt; v2)
       v3 = v1 - v2;
 else
    v3 = v2 - v1;
 java.lang.System.out.println (&quot;v3 = &quot; + v3);
&lt;/syntaxhighlight&gt;

Beim Lesen des Quellcodes mit einer solchen &quot;baumelnden&quot; ''else''-Anweisung (englisch: ''dangling else'') kann schnell der Eindruck entstehen, dass sie zur ersten ''if''-Anweisung gehört und das Ergebnis für die Variable ''v3'' 7 bleibt, da ''v1'' und ''v2'' positive Zahlen sind. Tatsächlich wird der Quellcode jedoch so ausgeführt, so dass die Variable ''v3'' den Wert 0 erhält.

Um solche Missverständnisse zu vermeiden, ist es -&amp;nbsp;wie oben bereits erwähnt&amp;nbsp;- dringend geboten, Blockanweisungen kategorisch einzusetzen, auch wenn sie durch die Definition der Programmiersprache nicht sowieso vorgeschrieben sind:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long v1, v2, v3;
 v1 = 3;
 v2 = 3;
 v3 = 7;
 if ((v1 &gt; 0) &amp;&amp; (v2 &gt; 0))
 {
    if (v1 &gt; v2)
    {
       v3 = v1 - v2;
    }
    else
    {
       v3 = v2 - v1;
    }
 }
 java.lang.System.out.println (&quot;v3 = &quot; + v3);
&lt;/syntaxhighlight&gt;

==Wertebereiche==
===Division durch null===
Im Zusammenhang mit dem '''Divisionsoperator''' gibt es in allen Programmiersprachen das Problem, dass der Divisor nicht null werden darf.

Die Division durch null kann und sollte kategorisch durch eine geeignete Kontrollstruktur mit dem Vergleichsoperator &quot;&lt;&gt;&quot; verhindert werden, der nur bei Ungleichheit der beiden Operanden den Ergebniswert &quot;wahr&quot; erzeugt:

 if (divisor &lt;&gt; 0)
 {
    quotient ← dividend / divisor
 }
 else
 {
    /* Ausnahmebehandlung / Fehlermeldung */
 }

===Wertebereichsprüfung===
Bei Parametern mit eingeschränktem zulässigen Wertebereich kann eine allgemeine und an allen entsprechenden Stellen verwendbare Funktion programmiert werden, die den gültigen Wertebereich überprüft und einen entsprechenden (häufig zweiwertigen respektive booleschen) Funktionswert zurückgibt, wie zum Beispiel die folgende Funktion &quot;waterIsLiquid &quot;, die überprüft, ob die Wassertemperatur zwischen 0° und 100° Celsius liegt, bevor das spezifische Gewicht des Wassers berechnet werden darf:

 boolean waterIsLiquid (double temperature) /* temperature in degrees Celsius */
 {
    final long freezingPoint ← 0;
    final long boilingPoint  ← 100;
    boolean waterIsLiquid ← (temperature &gt; freezingPoint) and (temperature &lt; boilingPoint);
    return waterIsLiquid;
 }
 
 ...
 
 double temperature, density;
 
 ...
 
 if waterIsLiquid (temperature)
 {
    /* function computes an approximation of the density of air-free liquid water in kilograms per cubic metre */
    density ←
       (    999.83952
          + (16.945176 * temperature)
          - (0.0079870401 * temperature * temperature)
          - (0.000046170461 * temperature * temperature * temperature)
          + (0.00000010556302 * temperature * temperature * temperature * temperature)
          - (0.00000000028054253 * temperature * temperature * temperature * temperature * temperature)
       ) / ((0.01689785 * temperature) + 1);
 }
 else
 {
    /* exception handling, because water is not liquid */
 }

===Parameterkombinationen===
Es ist wichtig, dass immer alle auftretenden Parameterkombinationen berücksichtigt und vom Programmcode verarbeitet werden, wenn aus diesen Parametern valide berechnete Werte abgeleitet werden sollen.

Um zum Beispiel das Argument (also den Phasenwinkel zwischen -180° und +180°) einer komplexwertigen Zahl mit den reellwertigen Komponenten x und y über den Arcustangens (&quot;arctan&quot;) zu berechnen, muss geprüft werden, ob der Parameter x gleich null ist, und welche Vorzeichen die Parameter x und y haben:

 double x
 double y
 
 ...
 
 double argument
 
 if (x = 0)
 {
    if (y &gt; 0)
    {
       argument ← 90
    }
    elseif (y &lt; 0)
    {
       argument ← -90
    }
    else /* y is equal to 0, too */
    {
       stop /* argument is not defined */
    }
 }
 else /* x is not equal to 0 */
 {
    argument ← arctan (y / x)
    if (x &lt; 0)
    {
       if (y &gt;= 0)
       {
          argument ← argument + 180
       }
       else /* both, x and y are less than 0 */
       {
          argument ← argument - 180
       }
    }
 }

==Schnittstellen==
Schnittstellen definieren die Sichtbarkeits- und Zugriffsregeln zwischen verschiedenen Bestandteilen eines Programms und ermöglichen so die Interaktion zwischen diesen. Dabei ist es keineswegs sinnvoll, alle Bezeichner überall sichtbar zu machen, da dadurch die Übersichtlichkeit und Nachvollziehbarkeit insgesamt drastisch eingeschränkt wird. Dies führt letztlich zu Programmfehlern, da der Programmierer wegen der großen zu berücksichtigenden Datenmenge nicht mehr in der Lage ist, alle Implikationen seiner Arbeit zu überschauen.

Alle Eigenschaften (Attribute) und Methoden (Werkzeuge), die zusammengehören (aber auch nur diese), sollen in jeweils einer Einheit zusammengefasst werden, wie zum Beispiel einer Klasse oder einem Modul. Oft wird eine solche Einheit in einer Quelltextdatei zusammengefasst, was sinnvoll ist und die Nachvollziehbarkeit erleichtert.

Nur diejenigen Eigenschaften und Methoden, die außerhalb dieser Einheiten benutzt werden sollen oder müssen, dürfen mit einem Modifikator versehen werden, der dies ermöglicht (zum Beispiel &quot;public&quot;). Alle anderen Eigenschaften und Methoden sollten explizit als intern (zum Beispiel &quot;private&quot;) deklariert sein. ''packages'' sind wegen der unübersichtlichen Sichtbarkeitsregeln (zum Beispiel durch den Modifikator &quot;protected&quot;) als Zwischenebene entbehrlich und eher zu vermeiden. Alternativ können ohne weiteres längere, zusammengesetzte Klassennamen verwendet werden, um die Zugehörigkeit zu einem bestimmten Themenbereich zu kennzeichnen, wie zum Beispiel mit einfachen Bezeichnern:

 StatisticsMyEvaluation
 StatisticsMyAssessment

Diese Bezeichner sind in der Regel unmittelbar mit den Programmdateien im Dateisystem korreliert. Hierbei sind also keine '''qualifizierten Bezeichner''' auf verschiedene Konstrukte erforderlich, die hier im Beispiel aus mehreren Bezeichnern mit zwischengestellten Punkten zusammengesetzt sind. Links vom Punkt steht der Bezeichner der Programmbibliothek (Modulsammlung, Paket), und rechts vom Punkt steht der Bezeichner für ein Programmbaustein (Modul, Klasse):

 package statistics
 
 statistics.MyEvaluation
 statistics.MyAssessment

===Importe===
====Import-Anweisungen====
'''Import-Anweisungen''' werden häufig nicht dazu benutzt anzumelden und anzuzeigen, welche externen Module (respektive Klassen) in einer Quelldatei verwendet werden, sondern werden als Möglichkeit missbraucht, den Quelltext möglichst kurz zu fassen.

Nicht:

 import MyModule
 ...
 drawLine ()
 ...

Sondern eindeutig mit qualifiziertem Bezeichner:

 ...
 MyModule.drawLine ()
 ...

Mit diesen qualifizierten Bezeichnern ist es dann auch einfach und eindeutig möglich, gleichnamige Bezeichner, wie zum Beispiel für die Methode ''drawLine'', aus verschiedenen Klassen zu benutzen:

 ...
 MyModule.drawLine ()
 YourModule.drawLine ()
 ...

Die Erkennbarkeit der Herkunft eines importierten Bezeichners an jeder Stelle des Auftretens in einem Quelltext ist in der Regel von großer Nützlichkeit, insbesondere wenn andere Programmierer den Quelltext nachvollziehen können sollen oder wenn der Quellcode nach längerer Zeit gewartet werden soll.

Insbesondere Import-Anweisungen mit Wildcards sind schlecht nachvollziehbar (auch wenn viele Entwicklungssysteme Funktionen für eine gewisse Transparenz bieten), so wie zum Beispiel:

 import myPackage.*
 import yourPackage.*
 
 drawLine () /* To which package does the method &quot;drawLine&quot; belong? */
 
 Class var ← new Class () /* To which package does the class &quot;Class&quot; belong? */

====Zyklische Importe====
[[Datei:Zyklischer.Import.png|mini|rechts|hochkant=2|Zyklische Importe durch Aufruf (&quot;call&quot;) des Unterprogramms (&quot;procedure&quot;) '''sum''' aus der Klasse '''B''' in das Unterprogramm '''add''' der Klasse A sowie Aufruf des Unterprogramms '''add''' aus der Klasse '''A''' in das Unterprogramm '''sum''' der Klasse '''B'''.]] 

'''Zyklische Importe''' beziehungsweise Zirkelbezüge sind nicht nur unübersichtlich, sondern auch unstrukturiert und können zu Speicherüberläufen führen, da sich Programmteile immer wieder gegenseitig aufrufen, ohne beendet zu werden. Ferner kann die Funktion des übersetzten Programms bei einer Optimierung des Codes von der Reihenfolge der Übersetzung der Quelltexte abhängen. Die Schnittstellen der Klassen und Module können im Allgemeinen weder unabhängig voneinander noch eindeutig überprüft werden.

'''Beispiel''': Die beiden Funktionen Funktionen ''add'' aus der Klasse ''A'' und ''sum'' aus der Klasse ''B'' rufen sich endlos gegenseitig auf, um die Summe zweier Zahlenwerte zu berechnen, bis der Speicher überlaufen würde und das Laufzeitsystem die Ausführung deswegen abbricht oder der Speicher überläuft, das Programm unkontrolliert und ohne (nachvollziehbare) Fehlermeldung abstürzt.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

 public class A
 {
    public int procedure add (int a, int b)
    {
       int result ← B.sum (a, b);
       return result;
    }
 }

 public class B
 {
    public int procedure sum (int x, int y)
    {
       int result ← A.add (x, y);
       return result;
    }
 }

[[Datei:Circular Reference.svg|mini|rechts|hochkant=1|Variante von Abhängigkeiten zwischen Modulen oder Klassen, in denen die zyklischen Bezüge weniger offensichtlich sind, wenn nur der nächste Nachbar betrachtet wird. Der dunkelrote Pfeil oben rechts zeigt nach unten auf ein bereits vorher definiertes Element, das sich rechts in der Mitte befindet. Die Definition dieses Elements darf bei einem strukturierten Aufbau der Programmteile allerdings nicht von dem Element ober rechts abhängig sein.]]

Solche zyklischen Abhängigkeiten können durch Verzweigungen und indirekte Aufrufe wesentlich weniger offensichtlich sein, und sind dann nur sehr schwierig zu erkennen und zu beheben. Sichere Programmiersprachen überprüfen solche zyklischen Zusammenhänge daher und lassen sie nicht zu.

In der Regel ist es bei der Anwendung von rekursiven Programmiertechniken mit wohldefinierten Abbruchbedingungen möglich, ohne zyklische Modulabhängigkeiten auszukommen. Ein Übersetzer kann in den Metadaten von Programm-Modulen Zeitstempel verwenden, um bei der Interpretation eines Programmteils herausfinden zu können, ob alle anderen importierten Programmteile bereits vorher gültig übersetzt wurden.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Nebeneffekte==
'''Nebeneffekte''' treten auf, wenn der Programmierer von naheliegenden, jedoch falschen Annahmen ausgeht, die die Programmiersprache betreffen. Solche Nebeneffekte sind unerwünscht und können durch ein strukturiertes Vorgehen oft leicht vermieden werden.

===Durch arithmetischen Überlauf===
Als Indiz für solche Nebeneffekte möge folgendes Beispiel in Java dienen, bei dem die Dezimalzahl 127 (die hexadezimale Repräsentation dieses Zahlenwerts ist durch die acht Ziffern 7F gegeben) um eins erhöht wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 byte zahl = 127;
 java.lang.System.out.println (&quot;zahl = &quot; + zahl);
 zahl++;
 java.lang.System.out.println (&quot;zahl = &quot; + zahl);
&lt;/syntaxhighlight&gt;

Diese Anweisungsfolge erzeugt die Ausgabe:

:zahl = 127
:zahl = -128

Wenn die größte mit dem Datentyp &quot;byte&quot; darstellbare Zahl 127 mit dem Inkrement-Operator ++ um eins erhöht wird, ergibt sich durch arithmetischen Überlauf als Ergebnis die kleinste darstellbare ganze Zahl 128.

Dass solche Nebeneffekte auch in Standard-Bibliotheken versteckt sein können, möge das folgende Beispiel in Java zeigen, bei dem die Dezimalzahl -1 (die hexadezimale Repräsentation dieses Zahlenwerts ist durch die acht Ziffern FFFFFFFF gegeben) mit zwei verschiedenen Unterprogrammen ausgegeben werden soll (Stand 2026):

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 long zahl = 0xFFFFFFFF;
 java.lang.System.out.println (&quot;dezimal: &quot; + zahl);
 java.lang.System.out.print (&quot;hexadezimal: &quot;);
 java.lang.System.out.printf (&quot;%h\n&quot;, zahl);
&lt;/syntaxhighlight&gt;

Diese Anweisungsfolge erzeugt die Ausgabe:

:dezimal: -1
:hexadezimal: 0

Die Methode &quot;printf&quot; für die Ausgabe im hexadezimalen Format (Steuersequenz h%), ruft die statische Methode &quot;formatUnsignedLong0&quot; aus der Klasse &quot;Long&quot; aus dem package &quot;java.lang&quot; im Modul &quot;java.base&quot; der Java-Standardbibliothek auf und gibt den Wert 0 aus, obwohl der korrekte hexadezimale Wert FFFFFFFF lautet. Der Fehler entsteht bei der internen Berechnung, bei der es einen arithmetischen Überlauf gibt, der nicht explizit abgefangen wird.

===Durch Rundung===
Manchmal ist es schwierig zu erkennen, dass das Ergebnis einer Operation nicht dem exakten Ergebnis entspricht, das mathematisch zu erwarten wäre, weil es Rundungsfehler gibt. Gleitkommazahlen können nicht mit beliebig hoher Präzision gespeichert werden, und daher können sich dadurch solche Rundungsfehler auch mit einer völlig unerwarteten Wirkung ergeben. Hier ein Beispiel in der Programmiersprache Java für ein System mit einer Speichertiefe von 64 Bit:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 double a = 4.4;
 double b = 3.3;
 java.lang.System.out.println (a - b);
&lt;/syntaxhighlight&gt;

Die Ausgabe lautet nicht &quot;1.1&quot; wie zu erwarten wäre, sondern:

:1.1000000000000005

Noch schwieriger ist es, wenn das Kommutativ-, das Distributiv- oder das Assoziativgesetz nicht zu gelten scheinen, wie in diesem Beispiel, bei dem die Variable &quot;b&quot; einmal zur Variable &quot;a&quot; und einmal zur Variable &quot;c&quot; assoziiert ist:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 double a = 4.4;
 double b = 3.3;
 double c = 1.1;
 java.lang.System.out.println ((a - b) - c);
 java.lang.System.out.println (a - (b + c));
&lt;/syntaxhighlight&gt;

Mathematisch kommt in beiden Fällen exakt der Wert null heraus, die Ausgabe lautet jedoch:

:4.440892098500626E-16
:0.0

Die Wirkung von derartigen Nebeneffekten sind nur sehr schwierig zu beherrschen, und daher sollte beim Vergleichen von Gleitkommawerten die Präzision respektive die Maschinengenauigkeit der gespeicherten Werte berücksichtigt werden. Manche Programmiersprachen stellen hierfür einen Wert für die kleineste relative Genauigkeit von Gleitkommazahlen &lt;math&gt;\epsilon&lt;/math&gt; (epsilon) zur Verfügung. Das folgende Beispiel für den Datentyp double mit 64 Bit Speichertiefe nach dem Standard IEEE 754 in der Programmiersprache Java mit einem Wert für &lt;math&gt;\epsilon = 10^{-15}&lt;/math&gt; nach der Formel:

:&lt;math&gt;\Bigg| {\frac {differenzBerechnet - differenzErwartet} {differenzErwartet}} \Bigg| &lt; \epsilon&lt;/math&gt;

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 double a = 4.4;
 double b = 3.3;
 double differenzBerechnet = a - b;
 double differenzErwartet = 1.1;

 boolean gleichheit1 = (differenzBerechnet == differenzErwartet);
 java.lang.System.out.println (gleichheit1);

 double epsilon = 1.0E-15;
 boolean gleichheit2 = java.lang.Math.abs ((differenzBerechnet - differenzErwartet) / differenzErwartet) &lt; epsilon;
 java.lang.System.out.println (gleichheit2);
&lt;/syntaxhighlight&gt;

Die Ausgabe lautet hier:

:false
:true

===Durch Reihenfolge===
In einigen Programmiersprachen ist die Reihenfolge der Abarbeitung von kombinierten Ausdrücken nicht explizit definiert und führt daher zu einem solchen Nebeneffekt.

Die Anweisungen

 h ← f (x) + g (x)

oder

 h ← g (x) + f (x)

können je nach Compiler zu unterschiedlichen Ergebnissen für die Summe h führen. Die Methodenaufrufe f oder g können nämlich unter Umständen die als Parameter verwendete (lokale) Variable x verändern und somit gegebenenfalls verschiedene Werte für h erzeugen, je nachdem, ob zuerst f&amp;nbsp;(x) oder g&amp;nbsp;(x) ausgewertet wird. In solchen Programmiersprachen sind sogenannte Durchgangsparameter in kombinierten Ausdrücken zu vermeiden.

Ferner ist es denkbar, dass durch den ersten Funktionsaufruf globale Variablen oder Instanzen verändert und beim zweiten Funktionsaufruf verwendet werden.

Die erwünschte Reihenfolge von Funktionsaufrufen kann leicht durch entsprechende Code-Sequenzen mit sequentiellen Anweisungen erzwungen werden:

 result_f ← f (x)
 result_g ← g (x)
 h ← result_f + result_g

Dieses Vorgehen erzeugt darüberhinaus den günstigen Umstand, dass die Zwischenergebnisse in lokalen Variablen gespeichert und somit abgefragt werden können. Diese sind nach einem Programmabbruch dann auch mit einem Post-Mortem-Debugger analysierbar.

===Durch Kombination von Operatoren===
Manche Programmiersprachen -&amp;nbsp;insbesondere in der C-Sprachfamilie&amp;nbsp;- erlauben die Kombination von Zuweisungsoperatoren und arithmetischen Operatoren.

 Zuweisungsoperator: =
 Arithmetische Operatoren: + - * /
 Kombinierte Operatoren: += -= *= /=

Die kombinierten Operatoren sollen für die scheinbar äquivalenten Formulierungen mit getrenntem Zuweisungsoperator und arithmetischem Operator stehen:

 a += 1; steht für a = a + 1;
 a -= 1; steht für a = a - 1;
 a *= 1; steht für a = a * 1;
 a /= 1; steht für a = a / 1;

Diese Schreibweisen sollen wohl vor allem ein wenig Schreibarbeit bei der Programmierung ersparen, können aber zu schwer zu identifizierenden Programmierfehlern führen, wie das folgende Java-Beispiel verdeutlichen soll:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
	long a = 1;
	double b = 1.5;
	a *= b;
	java.lang.System.out.println (a);
	a += b;
	java.lang.System.out.println (a);
	a -= b;
	java.lang.System.out.println (a);
&lt;/syntaxhighlight&gt;

Dieser Code erzeugt die Ausgabe:

 1
 2
 0

Die nur scheinbar äquivalenten Formulierungen für die kombinierten Operatoren

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
	a = a * b;
	a = a + b;
	a = a - b;
&lt;/syntaxhighlight&gt;

werden in Java wegen der mangelnden Zuweisungskompatibilität der arithmetischen Ausdrücke hinter dem Zuweisungsoperator vom Datentyp &quot;double&quot; zum Datentyp &quot;long&quot; der Variable &quot;a&quot; gar nicht übersetzt.

Die tatsächlichen äquivalenten Formulierungen für die kombinierten Operatoren lauten nämlich wie folgt:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
	a = (long) (a * b);
	a = (long) (a + b);
	a = (long) (a - b);
&lt;/syntaxhighlight&gt;

Durch die impliziten Datentypumwandlungen erklären sich auch die falschen numerischen und gegebenenfalls nicht erwarteten ganzzahligen Ergebnisse. Wenn bei der Programmierung diese Tatsachen nicht bewusst sind oder übersehen werden, ergeben sich numerische Fehler in den arithmetischen Berechnungen. Dies kann einfach vermieden werden, indem kombinierte Operatoren zugunsten der expliziten sowie transparenten Formulierungen mit separaten Operatoren nicht verwendet werden.

=== Durch Sprachdefinition ===
Als Beispiel dient hier die scheinbar falsche Ausgabe eines Java-Programms, weil die Definition der Programmiersprache der Intuition widerspricht:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long i = 01234567;
 java.lang.System.out.println (i);
&lt;/syntaxhighlight&gt;

Dieser Code erzeugt die Ausgabe:

 342391

Das Literal &quot;01234567&quot; wird trotz der ausschließlichen Verwendung von gültigen dezimalen Ziffern nicht als die Dezimalzahl 1234567&lt;sub&gt;10&lt;/sub&gt; interpretiert und ausgegeben, sondern entsprechend der Definition der Programmiersprache Java wegen der einleitenden Null als Oktalzahl zur Basis Acht, also als 1234567&lt;sub&gt;8&lt;/sub&gt; = 342391&lt;sub&gt;10&lt;/sub&gt;.

=== Durch Überladen ===
Eine Überladung liegt vor, wenn eine Operator oder ein Bezeichner mehrfach in verschiedenen Bedeutungen auftritt, die leicht zu Verwechslungen führen können. Streng strukturierte Programmiersprachen erlauben das polymorphe Überladen nicht, wenn es dadurch zu Programmierfehlern kommen kann.

Das '''Überladen''' muss in der objektorientierten Programmierung vom '''Überschreiben''' unterschieden werden, wobei auch überschriebene Methoden in weniger strukturierten Programmiersprachen überladen werden dürfen, was ebenfalls zu unübersichtlichem Programmcode und schnell zu übersehenden Programmierfehlern führen kann. Siehe hierzu unten unter [[Strukturierte Programmierung#Überladung|Überladung]].

==== Überladung von Divisionsoperatoren ====
Die Divisionsoperatoren sind in vielen Programmiersprachen leider überladen, wenn nämlich formal keine Unterscheidung zwischen Division mit ganzen Zahlen (Datentyp zum Beispiel &quot;long&quot; oder &quot;int&quot;) und Gleitkommazahlen (Datentyp zum Beispiel &quot;real&quot; oder &quot;double&quot;) gemacht wird. In diesen Fällen muss der Divisionsoperator sehr aufmerksam verwendet werden:

 int i ← 2;
 int j ← 1;
 real k ← j / i; /* Ueberladener Divisionsoperator mit zwei ganzzahligen Operanden */

Verwendet die Programmiersprache im arithmetischen Ausdruck die ganzzahlige Division, hat dies zur Folge, dass die Variable k den Wert '''0''' erhält. Verwendet die Programmiersprache stattdessen die reelwertige Division, bekommt die Variable k den Wert 0,5 zugewiesen.

Einige Programmiersprachen unterscheiden daher sinnvollerweise explizit zwischen einem Operator für die ganzzahlige Division (&quot;div&quot; oder &quot;DIV&quot;) und einem Operator für die Gleitkommadivision (&quot;/&quot;).

&lt;syntaxhighlight lang=&quot;pascal&quot;&gt;
(* Programmiersprache Pascal *)
 i, j : integer;
 k : real;
 i := 2;
 j := 1;
 k := j / i; (* Gleitkommazahliger Divisionsoperator mit zwei ganzzahligen Operanden *)
&lt;/syntaxhighlight&gt;

In der letzten Anweisung wird der Variablen &quot;k&quot; der Zahlenwert der reellwertigen Division '''0,5''' zugewiesen.

&lt;syntaxhighlight lang=&quot;pascal&quot;&gt;
(* Programmiersprache Pascal *)
 i, j, k : integer;
 i := 2;
 j := 1;
 k := j div i; (* Ganzzahliger Divisionsoperator mit zwei ganzzahligen Operanden *)
&lt;/syntaxhighlight&gt;

In der letzten Anweisung wird der Variablen &quot;k&quot; der Zahlenwert der ganzzahligen Division '''0''' zugewiesen.

Bei Programmiersprachen, die die Unterscheidung der Divisionsoperatoren nicht unterstützen, ist die Verwendung der expliziten und zuweisungskompatiblen Datentypumwandlung (englisch: ''type cast'') nicht nur sinnvoll, sondern sogar zwingend erforderlich:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long i = 2;
 long j = 1;
 double k = ((double) j) / ((double) i) /* Ueberladener Divisionsoperator mit zwei gleitkommazahligen Operanden */
&lt;/syntaxhighlight&gt;

In der Regel ist es für eine Gleitkommadivision hierbei ausreichend, wenn nur einer der beiden Operanden, also nur der Nenner (Dividend) oder der nur Zähler (Divisor) der Division, eine Gleitkommazahl darstellt.

Entsprechende Überlegungen gelten auch für alle '''Modulo-Operatoren''' (wie zum Beispiel &quot;%&quot;, &quot;mod&quot; oder &quot;MOD&quot;).

==== Überladung von Variablen ====
Oft ist es in einer Programmiersprache erlaubt, dieselben Bezeichner für Variablen mit verschiedenen Sichtbarkeitsbereichen zu verwenden. Dies kann sehr einfach zur Verwechslung dieser Variablen führen, wie im folgenden Java-Beispiel verdeutlicht wird, wo es sowohl eine globale Klassenvariable (Sichtbarkeit in der Klasse &quot;OverloadedVariables&quot;) als auch eine lokale Variable (Sichtbarkeit in der Methode &quot;main&quot;) mit dem Namen &quot;bezeichner&quot; gibt:&lt;syntaxhighlight lang=&quot;java&quot;&gt;
public class OverloadedVariables
{
	// globale Klassenvariable &quot;bezeichner&quot;
	private static long bezeichner = 1;

	// Hauptprogramm (Methode &quot;main&quot;)
	public static void main (java.lang.String [] argumente) 
	{
		// lokale Variable &quot;bezeichner&quot;
		long bezeichner = 2; 
		// Ausgabe der globalen Klassenvariable &quot;bezeichner&quot;
		java.lang.System.out.println (&quot;Wert der globalen Variable = &quot; + OverloadedVariables.bezeichner);
		// Ausgabe der lokalen Variable aus der Methode &quot;main&quot;
		java.lang.System.out.println (&quot;Wert der  lokalen Variable = &quot; + bezeichner);
	}
}
&lt;/syntaxhighlight&gt;Falls die Klassenvariable referenziert werden soll, muss sie in Java qualifiziert bezeichnet werden, indem der Name der Klasse vorangestellt wird.

==== Überladung von Methoden ====
Viele Programmiersprachen erlauben die Deklaration von mehreren Methoden mit gleichem Bezeichner, die sich in der Anzahl oder den Datentypen ihrer Parameter unterscheiden. Das folgende Java-Beispiel mit zwei Methoden demselben Namens, von denen die mit der passenden Datentyp des Parameters &quot;zahl&quot; aufgerufen wird, verdeutlicht dies:&lt;syntaxhighlight lang=&quot;java&quot;&gt;
	private static long kehrwert (long zahl)
	{
		long kehrwert = 1 / zahl;
		return kehrwert;
	}

	private static double kehrwert (double zahl)
	{
		double kehrwert = 1 / zahl;
		return kehrwert;
	}

	public static void main (java.lang.String [] argumente)
	{
		double kehrwert1 = kehrwert (2);
		double kehrwert2 = kehrwert (2.0);
		java.lang.System.out.println (&quot;Kehrwert 1 = &quot; + kehrwert1);
		java.lang.System.out.println (&quot;Kehrwert 2 = &quot; + kehrwert2);
	}
&lt;/syntaxhighlight&gt;Die Ausgabe ergibt zwei verschiedene Ergebnisse für den Kehrwert der Zahl Zwei:&lt;syntaxhighlight&gt;
Kehrwert 1 = 0.0
Kehrwert 2 = 0.5
&lt;/syntaxhighlight&gt;Durch die kategorische Verwendung verschiedener Bezeichner für verschiedene Methoden kann die Verwechslungsgefahr leicht und ohne Probleme verhindert werden, und die Erzeugung der beiden verschiedenen Ergebnisse wird transparent:&lt;syntaxhighlight lang=&quot;java&quot;&gt;private static long kehrwertLong (long zahl)
	{
		long kehrwert = 1 / zahl;
		return kehrwert;
	}

	private static double kehrwertDouble (double zahl)
	{
		double kehrwert = 1 / zahl;
		return kehrwert;
	}

	public static void main (java.lang.String [] argumente)
	{
		double kehrwert1 = kehrwertLong (2);
		double kehrwert2 = kehrwertDouble (2.0);
		java.lang.System.out.println (&quot;Kehrwert 1 = &quot; + kehrwert1);
		java.lang.System.out.println (&quot;Kehrwert 2 = &quot; + kehrwert2);
	}&lt;/syntaxhighlight&gt;

===Durch falsche Spezifikation===
In Programmiersprachen, die dynamische Variablen ausschließlich als Zeiger behandeln (wie zum Beispiel C oder C++), kann trotz exakter Übereinstimmung der referenzierten Datentypen bei einer Zuweisung des Ergebnisses einer Funktion ein Zeiger auf den lokalen Stapelspeicher der Funktion zurückgegeben werden, der nur während der Ausführung der Funktion, aber nicht mehr nach dem Rücksprung aus der Funktion gültig ist. Während der weiteren Programmausführung kann der Speicherbereich jederzeit überschrieben werden, ohne dass der Programmierer dies wünscht oder absehen kann.

Im folgenden Beispiel in der Programmiersprache C wird innerhalb der Funktion ''function'' der Wert 5 dem Datenfeld ''a'' der Variablen ''data'' zwar korrekt zugewiesen, kann aber nach dem Rücksprung aus der Funktion im Stapelspeicher jederzeit unbeabsichtigt verändert werden, wie zum Beispiel beim erneuten Aufruf einer Funktion oder anderen Operationen, die den Stapelspeicher verwenden:

&lt;syntaxhighlight lang=&quot;C&quot;&gt;
/* Programmiersprache C */

struct DataType { int a }; // Definition des Datentyps ''DataType'' mit einem ganzzahligen Datenfeld ''a''

// Deklaration der Funktion ''function'' mit einem Zeiger auf eine Variable vom Datentyp ''DataType'' als Speicheradresse für den Rückgabewert
DataType* function ()
{
  DataType data;           // Deklaration der lokalen Variable ''data'' vom Datentyp ''DataType''
  data.a = 5;              // Zuweisung des Wertes ''5'' zum Datenfeld ''a'' der Variablen ''data''
  return &amp;data;            // Rückgabe der lokalen, temporären Speicheradresse von ''data'', die nach der Beendigung des Funktionsaufrufs gar nicht mehr gültig ist.
}
&lt;/syntaxhighlight&gt;

Der Programmierer muss zur Abwendung dieses Übels darauf achten, dass Rückgabewerte durch Allokation einer entsprechenden Variablen in einem dauerhaft verfügbaren dynamischen Speicherbereich (also zum Beispiel im Heap-Speicher) auch nach dem Aufruf der Funktion noch gültig und korrekt aufrufbar sind.

Bei der Verwendung von vollständig typsicheren Programmiersprachen ist die Rückgabe von lokal definierten Adressen nicht zulässig, und die Übersetzung des entsprechenden Codes wird vom Complier von vornherein verweigert, so dass es gar nicht zu einem solchen Nebeneffekt kommen kann.

Alternativ kann der Datentyp ''DataType'' nicht direkt als Verbund, sondern als Zeiger auf einen entsprechenden Verbund deklariert werden. In diesem Fall muss in der Funktion zunächst eine Instanz erzeugt werden (beispielsweise mit dem Kommando ''new'' oder ''allocate''). Diese Instanz ist dann nicht mehr im lokalen Stapelspeicher (Stack) der Funktion gespeichert, sondern es kann im dynamischen Speicherbereich (Heap) global - also auch außerhalb der Funktion und nach Beendigung des Funktionsaufrufs - darauf zugegriffen werden.

===Durch Verwechslung von Speicherinhalt und Speicheradresse===
Die Werte von Variablen werden unter einer bestimmten Speicheradresse eines Computers gespeichert, wo vom Laufzeitsystem die für den entsprechenden Datentyp erforderliche Datenmenge der entsprechende Speicherplatz reserviert und bereitgehalten wird. Diese Speicheradresse wird in modernen Systemen in der Regel automatisch verwaltet, so dass sie im Allgemeinen gar nicht bekannt ist und auch gar nicht bekannt sein muss.

Daraus ergeben sich unter Umständen jedoch wichtige Implikationen. In manchen Programmiersprachen, wie zum Beispiel Java, ist nämlich nicht unmittelbar erkennbar, ob bei bestimmten Operationen der Speicherinhalt oder die Speicheradresse einer Variablen verwendet wird. So werden bei bei logischen Vergleichen mit Operanden, die aus Variablen mit einfachen Datentypen bestehen (etwa boolean, long oder double), die unter der Speicheradresse gespeicherten '''Werte''' verglichen, also die Inhalte. Bei Variablen mit komplexen Datentypen (beispielsweise eine abzählbare Liste von Daten eines Datentyps (array), ein Verbund (record / struct), der sich aus verschiedenen Datentypen zusammensetzen kann, oder allgemein in der objektorientierten Programmierung die Instanz eines Objekts) werden jedoch gar nicht unbedingt die gespeicherten Inhalte, sondern lediglich die Speicheradressen der beiden Operanden verglichen. Hier wird also beim Gleichheitsoperator nur geprüft, ob es sich um dasselbe Speicherobjekt (dieselbe Instanz) handelt, und nicht, ob zwei verschiedene Speicherobjekte den gleichen Inhalt haben. Bei strenger Strukturierung wird (hoffentlich schon vor der Ausführung bereits im Quelltext) zusätzlich geprüft, ob die zu vergleichenden komplexen Datentypen überhaupt zuweisungskompatibel und somit sinnvoll vergleichbar sind.

Unter welchen Umständen welche Speicheradressen für gleiche Speicherinhalte verwendet werden, ist insbesondere für unerfahrene Programmierer keineswegs immer naheliegend oder leicht nachzuvollziehen. Dies wird im Folgenden anhand des logischen Vergleichs auf Gleichheit von Zeichenketten (Java-Klasse java.lang.String) in der Programmiersprache Java verdeutlicht. Die Wirkungsweise des Gleichheitsoperators  == wird der Wirkungsweise des Funktionsaufrufs der Methode '''java.lang.String.equals''' gegenübergestellt, die einen booleschen Rückgabewert hat.

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
	boolean vergleich;

	// Die symbolische Konstante für die Zeichenkette &quot;abc&quot; wird in einer Variablen mit dem Bezeichner text verwaltet
	// Die Zeichenkette &quot;abc&quot; wird von Java unter der Speicheradresse #MEM1 abgelegt
	// Die Variable text und die symbolische konstante Zeichenkette &quot;abc&quot; haben dieselbe Speicheradresse #MEM1
	java.lang.String text = &quot;abc&quot;;

	// Vergleich der Speicheradresse #MEM1 mit der Speicheradresse #MEM1
	vergleich = (&quot;abc&quot; == &quot;abc&quot;);
	java.lang.System.out.println (&quot;1. Vergleich \&quot;abc\&quot; == \&quot;abc\&quot;: &quot; + vergleich);

	// Vergleich der Speicheradresse #MEM1 mit der Speicheradresse #MEM1 !!!
	vergleich = (text == &quot;abc&quot;);
	java.lang.System.out.println (&quot;2. Vergleich text == \&quot;abc\&quot;: &quot; + vergleich);

	// Vergleich des Inhalts bei der Speicheradresse #MEM1 mit dem Inhalt bei der Speicheradresse #MEM1
	vergleich = text.equals (&quot;abc&quot;);
	java.lang.System.out.println (&quot;3. Vergleich text.equals (\&quot;abc\&quot;): &quot; + vergleich);

	// Neue Instanz fuer die bereits oben deklarierte Zeichenkette text 
	// Die neue Instanz wird mit dem new-Operator unter der Speicheradresse #MEM2 erzeugt
	// Der Speicherinhalt wird mit dem Konstruktor java.lang.String und dem Wert &quot;abc&quot; initialisiert
	// Die Variable text bekommt durch die Zuweisung die Speicheradresse #MEM2
	text = new java.lang.String (&quot;abc&quot;);

	// Vergleich der Speicheradresse #MEM2 mit der Speicheradresse #MEM1 !!!
	vergleich = (text == &quot;abc&quot;);
	java.lang.System.out.println (&quot;4. Vergleich text == \&quot;abc\&quot;: &quot; + vergleich);

	// Vergleich des Inhalts bei der Speicheradresse #MEM2 mit dem Inhalt bei der Speicheradresse #MEM1
	vergleich = text.equals (&quot;abc&quot;);
	java.lang.System.out.println (&quot;5. Vergleich text.equals (\&quot;abc\&quot;): &quot; + vergleich);
&lt;/syntaxhighlight&gt;

Die Textausgabe dieses Programms sieht wie folgt aus:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
1. Vergleich &quot;abc&quot; == &quot;abc&quot;: true
2. Vergleich text == &quot;abc&quot;: true
3. Vergleich text.equals (&quot;abc&quot;): true
4. Vergleich text == &quot;abc&quot;: false
5. Vergleich text.equals (&quot;abc&quot;): true
&lt;/syntaxhighlight&gt;

Symbolisch konstante Zeichenketten, wie zum Beispiel der Ausdruck &quot;abc&quot;, werden unter einer verdeckten Speicheradresse abgelegt und von Java für gleichlautende Ausdrücke automatisch wiederverwendet. Wird jedoch mit dem new-Operator eine Instanz eines Objekts erzeugt, so bekommt diese unabhängig davon, welcher Inhalt dort gespeichert wird, stets eine andere neue Speicheradresse zugeordnet. Für den Vergleich des Inhalts von Zeichenketten auf Gleichheit ist in Java also immer die generische typengebundene Methode &quot;equals'' zu verwenden. Diese typengebundene Methode &quot;equals&quot; gibt es auch in vielen anderen Java-Klassen, um den Inhalt der entsprechenden Objektinstanzen auf Gleichheit vergleichen zu können.

==Strukturierte objektorientierte Programmierung==
===Vermeidung von Codewiederholung durch Vererbung===
Die Vermeidung von Codewiederholung durch Vererbung kann beispielsweise an den beiden graphischen Objekten '''Kreis''' und '''Dreieck''' deutlich gemacht werden. Diese beiden Objekte können unabhängig voneinander als Datentyp modelliert werden, wobei ihre gemeinsamen Eigenschaften '''Farbe''' und '''Strichstärke''', sowie die jeweilige Methode zum '''Zeichnen''' beide Male unabhängig behandelt werden (dies kann eindeutig durch '''Hat'''-Beziehungen ausgedrückt werden: ein Kreis oder ein Dreieck '''hat''' eine Farbe, eine Strickstärke sowie eine Methode zum Zeichnen), was eine Codewiederholung darstellt. Der '''Kreis''' hat zusätzlich das Attribut '''Radius''', und das '''Dreieck''' hat zusätzlich die drei Attribute '''SeiteA''', '''SeiteB''' und '''SeiteC''':

 Kreis   hat: Farbe, Strichstärke, Methode zum Zeichnen, Radius
 Dreieck hat: Farbe, Strichstärke, Methode zum Zeichnen, SeiteA, SeiteB, SeiteC

Mithilfe von Vererbung kann die Codewiederholung vermieden werden, indem die Attribute '''Farbe''' und '''Strichstärke''', sowie die Methode zum '''Zeichnen''' nur einmal mithilfe des abstrakten Objekts '''GraphischesObjekt''' deklariert werden. Die konkreten Objekte '''Kreis''' und '''Dreieck''' erben alle gemeinsamen Eigenschaften und Methoden (respektive typengebundenen Prozeduren) von '''GraphischesObjekt''' (dies kann eindeutig durch '''Ist'''-Beziehungen ausgedrückt werden: ein Kreis '''ist''' ein GraphischesObjekt, und ein Dreieck '''ist''' ein GraphischesObjekt) und werden nur durch die jeweils fehlenden Attribute ergänzt:

 GraphischesObjekt hat: Farbe, Strichstärke, Methode zum Zeichnen

 Kreis   ist GraphischesObjekt, hat zusätzlich: Radius
 Dreieck ist GraphischesObjekt, hat zusätzlich: SeiteA, SeiteB, SeiteC

===Überladung===
Das '''Überladen''' von Methoden, Konstruktoren oder Variablen ist auch bei objektorientierter Programmierung überflüssig, erschwert die Nachvollziehbarkeit vom Quellcode und birgt die Gefahr von Programmierfehlern, die unter Umständen erst lange nach der Entwicklung der Software bei deren Wartung entstehen. Das folgende Beispiel verdeutlicht einen leicht zu übersehenden Programmierfehler durch die Veränderung bei den überladenen Funktionen während der Programmentwicklung oder Programmwartung:

 double quotient (double a, double b)
 {
  return a / b; /* Gleitkommazahlige Division */
 }
 
 long i ← 1;
 long j ← 2;
 double q ← quotient (i, j); /* q ist 0,5 da die gleitkommazahlige Definition der Funktion 'quotient' verwendet wird */

Wird die Funktion 'quotient' später mit einer ganzzahligen Variante überladen, ergibt sich beim bestehenden Aufruf der Funktion unbeabsichtigt ein anderes Ergebnis für die Variable 'q':

 double quotient (long a, long b)
 {
  return a DIV b; /* Ganzzahlige Division */
 }
 
 double quotient (double a, double b)
 {
  return a / b; /* Gleitkommazahlige Division */
 }
 
 long i ← 1;
 long j ← 2;
 double q ← quotient (i, j); /* q ist 0 da die ganzzahlige Definition der Funktion 'quotient' verwendet wird */

Noch unübersichtlicher wird die Lage, wenn zusätzlich auch noch Überladungen mit gemischten Datentypen für die Funktionsparameter definiert werden:

 double quotient (long a, long b)
 
 double quotient (double a, long b)
 
 double quotient (long a, double b)
 
 double quotient (double a, double b)

Deswegen werden Methoden oder Attribute besser nicht überladen, auch nicht, wenn die Programmiersprache dies zulässt. Auch jede Klasse bekommt daher maximal einen einzigen '''Konstruktor''', der alle erforderlichen Parameter zur Initialisierung der Instanzvariablen enthält. Als günstige Nebeneffekte stellen sich kürzere Übersetzungszeiten ein.

Wenn die ursprünglichen Deklarationen in der Basisklasse oder einer der von ihr erbenden Klassen überladen werden, indem zum Beispiel weitere gleichnamige Methoden mit abweichenden Parametern definiert werden, dann kann es zu verändertem Verhalten von Software kommen. Ohne dass die Anwendung selbst geändert wurde, kann es allein durch die Aktualisierung einer verwendeten Klasse zu völlig anderen Rechenergebnissen kommen, weil automatisch eine andere, neu überladene Methode aufgerufen wird, ohne dass dies im Quelltext des Anwendungsprogramms sichtbar wird. Die Folge können schwerwiegende Programmierfehler sein, die schwierig zu analysieren sind.

Als ein Beispiel diene hier die Methode java.lang.Math.ulp zur Bestimmung der &quot;'''u'''nits in the '''l'''ast '''p'''lace&quot; (&quot;Einheiten in der letzten Stelle&quot;), die in der Klasse java.lang.Math aus historischen Gründen mit zwei Parametern deklariert und somit überladen ist:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 public class Math;
 {
    public static double ulp​ (double d)
    public static float  ulp​ (float f)
 }
&lt;/syntaxhighlight&gt;

Der folgende Java-Code

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 double zahl;
 zahl = java.lang.Math.ulp (1L); // Datentyp long
 java.lang.System.out.println (zahl);
 zahl = java.lang.Math.ulp (1F); // Datentyp float
 java.lang.System.out.println (zahl);
 zahl = java.lang.Math.ulp (1D); // Datentyp double
 java.lang.System.out.println (zahl);
&lt;/syntaxhighlight&gt;

erzeugt folgende Ausgabe, da die ganze Zahl Eins mit dem Datentyp long (64 Bit) in der Programmiersprache Java implizit offensichtlich nicht in den Datentyp double (64 Bit), sondern in den Datentyp float (32 Bit) umgewandelt wird, und somit die mit dem Parameter des Datentyps float deklarierte Methode aufgerufen wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 1.1920928955078125E-7
 1.1920928955078125E-7
 2.220446049250313E-16
&lt;/syntaxhighlight&gt;

Falls bei einer neueren Version der Klasse java.lang.Math die Methode ulp mit einem Parameter des Datentyps long überladen würde, wäre das Ergebnis mit dem ganzzahligen Parameter des Werts &quot;1L&quot; (long) nicht mehr vorhersagbar, obwohl der oben angegebene Methodenaufruf sich formal gar nicht geändert hätte.

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 public class Math;
 {
    public static double ulp ​(double d)
    public static float  ulp​ (float f)
    public static double ulp ​(long l)
 }
&lt;/syntaxhighlight&gt;

Das Ergebnis des Aufrufs 

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 double zahl = java.lang.Math.ulp (1L);
 java.lang.System.out.println (zahl);
&lt;/syntaxhighlight&gt;

würde dann allein von der tatsächlichen Implementierung der neuen überladenen Methode mit dem Parameter des Datentyps long abhängen, die mit den alten beiden ulp-Methoden nichts mehr zu tun hat, außer, dass sie den gleichen Namen hat.

===Überschreibung===
Das '''Überschreiben''' von geerbten Methoden oder Konstruktoren ist etwas völlig anderes als das Überladen und kann sehr sinnvoll sein.

Beim Überschreiben muss die Signatur der Methode (oder des Konstruktors) unter strikter Beachtung der Zuweisungskompatibilität, der Anzahl und der Reihenfolge aller Parameter sowie der Rückgabewerte berücksichtigt werden. Wenn die Programmiersprache dies nicht automatisch unterstützt, sind wenigstens entsprechend aufwendige Maßnahmen im Quelltext sicherzustellen, wie zum Beispiel explizite Typenprüfungen oder hinreichend ausführliche Hinweise in Kommentaren.

Wenn Methoden oder Konstruktoren einer Basisklasse von der überschreibenden Klasse aufgerufen werden (englisch ''super call'') kann es zum ''Fragile Base Class Problem'' (zu Deutsch ''Problem der anfälligen Basisklasse'') kommen, da bei der Implementierung der Basisklasse die möglichen Auswirkungen in den später implementierten, überschreibenden Klassen nicht berücksichtigt werden konnten. Zur Abwendung dieser Gefahr sind ein besonders sorgfältiger und strukturierter Programmierstil sowie eine lückenlose Dokumentation des Quelltextes sehr hilfreich.

Das fehlerfreie und robuste Überschreiben von Klassen beziehungsweise die Vererbung von implementierten Klassen erfordern eine hohe Fähigkeit zum abstrakten Denken und eine umfangreiche Programmiererfahrung.

===Mehrfachvererbung===
Durch [[w:Mehrfachvererbung|Mehrfachvererbung]], also das Erben von Methoden und Instanzvariablen aus mehreren Basisklassen, führt zu komplexen, und schwierig zu durchschauenden Abhängigkeiten, die im Rahmen des [[w:Diamond-Problem|Diamond-Problems]] sogar zu unerwünschten Mehrdeutigkeiten führen kann. Die Vererbung aus zwei Basisklassen kann bei Bedarf ohne weiteres durch die Verwendung von [[w:Zwillingsklasse|Zwillingsklassen]] vermieden werden, was den Programmieraufwand ein wenig erhöht, aber dafür solche Mehrdeutigkeiten verhindert und außerdem die Übersetzungszeiten der Quelltexte reduziert.

In der Programmiersprache Java ist es zum Beispiel möglich, mehrere Basisklassen zu erben. Dabei ist zwar nur eine konkrete Vererbung aus einer Basisklasse (in Java: class) zulässig, aber zusätzlich dürfen noch beliebig viele weitere Basisklassen (in Java: interface) abstrakt geerbt werden. Dabei werden alle Attribute und Methoden aller Basisklassen auf die erbende Klasse übertragen. Auch die konkret vererbte Basisklasse kann wiederum selber mehrere abstrakte Basisklassen implementieren. Falls es in mehreren Basisklassen gleichlautende öffentliche Bezeichner gibt, kommt es unweigerlich zu Konflikten. 

Es ist in der Implementierung insbesondere bei fehlenden entsprechenden Kommentaren nicht ohne Weiteres erkennbar, zu welchen Basisklassen die zu überschreibenden Instanzvariablen oder Methoden gehören.

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/**
 * Die Klasse Mehrfachvererbung erbt Attribute und Methoden aus drei Basisklassen:
 *    Sie ist eine Instanz der Klasse (class = konkrete Klasse) javax.swing.JFrame.
 *    Sie implementiert die Schnittstelle (interface = abstrakte Klasse) java.awt.event.KeyListener.
 *    Sie implementiert die Schnittstelle (interface = abstrakte Klasse) java.awt.event.ActionListener.
 */

public class Mehrfachvererbung
extends javax.swing.JFrame
implements java.awt.event.KeyListener, java.awt.event.ActionListener
{
	/**
	 *  Konstante serialVersionUID aus der Basisklasse java.io.Serialization fuer die Serialisation,
	 *  die in der Klasse javax.swing.JFrame implementiert ist
	 */
	private final static long serialVersionUID = 1L;

	/**
	 *  Instanzvariable fuer den zuletzt von einer Instanz der Klasse javax.swing.JFrame gesendeten Tastaturcode
	 */
	private int keyCode;

	/**
	 *  Zu ueberschreibende Methode aus der geerbten Klasse java.awt.event.KeyListener
	 *  Speichert den Tastaturcode der zuletzt betaetigten Taste fuer eine Instanz
	 *  @param event: aufgetretenes Tastaturereignis aus der Klasse java.awt.event.KeyEvent
	 */
	@Override
	public void keyPressed (java.awt.event.KeyEvent event)
	{
		this.keyCode = event.getKeyCode ();
	}

	/**
	 *  Zu ueberschreibende Methode aus der geerbten Klasse java.awt.event.KeyListener
	 *  Ungenutzt
	 *  @param event: aufgetretenes Tastaturereignis aus der Klasse java.awt.event.KeyEvent
	 */
	@Override
	public void keyReleased(java.awt.event.KeyEvent event)
	{
	}

	/**
	 *  Zu ueberschreibende Methode aus der geerbten Klasse java.awt.event.KeyListener
	 *  Ungenutzt
	 *  @param event: aufgetretenes Tastaturereignis aus der Klasse java.awt.event.KeyEvent
	 */
	@Override
	public void keyTyped (java.awt.event.KeyEvent event)
	{
	}

	/**
	 *  Zu ueberschreibende Methode aus der vererbten Klasse java.awt.event.ActionListener
	 *  Der Inhalt einer Instanz der Klasse javax.swing.JFrame wird erneut dargestellt,
	 *  wenn die Eingabetaste (Enter) betaetigt wurde.
	 *  @param event: aufgetretenes Aktionsereignis aus der Klasse java.awt.event.ActionEvent
	 */
	@Override
	public void actionPerformed (java.awt.event.ActionEvent event)
	{
		if (this.keyCode == java.awt.event.KeyEvent.VK_ENTER)
		{
			this.repaint ();
		}
	}
}
&lt;/syntaxhighlight&gt;

==Nachwort==
Ein sehr häufig auftretender „Programmierfehler“ - wiederum insbesondere bei Anfängern - ist das Unterlassen der Herstellung von Sicherungskopien der Quelltexte. Noch besser ist eventuell sogar eine Versionierung der Quelldateien, damit gegebenenfalls auf beliebige ältere Versionen zurückgegriffen werden kann. Die Auswirkungen dieses Fehlers sind hinreichend naheliegend, so dass hier nicht weiter darauf eingegangen werden muss.

Sollte der Leser nach der Lektüre dieser Beiträge zu dem verständlichen und naheliegenden Schluss gekommen sein, dass die Programmiersprachen C oder C++ ziemlich schlecht strukturiert sind, möge er sich auch einmal andere Programmiersprachen näher ansehen, wie zum Beispiel C#, Component Pascal oder auch Java.

Mit der Beherzigung der Vorschläge aus diesem Buch möge es dem Leser in seinem Programmier-Team in jeder Programmiersprache gelingen, in kürzerer Entwicklungszeit besser strukturierte und funktionierende Programme zu schreiben.

===Vergleich===
In der folgenden Tabelle werde einige imperative, objektorientierte Programmiersprachen hinsichtlich ihrer Strukturiertheit verglichen:

{| class=&quot;wikitable&quot;
|- class=&quot;hintergrundfarbe6&quot;
!Veröffentlichungsdatum!!1985!!1994!!1995!!2001
|-
!Programmiersprache!!C++!!Component&lt;br/&gt;Pascal!!Java!!C#
|-
| style=&quot;text-align:left&quot;| Vollständig strukturierte Syntax || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | nein
|-
| style=&quot;text-align:left&quot;| Datentypsicherheit bei Basistypen || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | ja
|-
| style=&quot;text-align:left&quot;| Datentypsicherheit bei komplexen Datentypen || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja
|-
| style=&quot;text-align:left&quot;| Modulsicherheit || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja
|-
| style=&quot;text-align:left&quot;| Keine zyklischen Importe || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | nein
|-
| style=&quot;text-align:left&quot;| Keine mehrfache Schnittstellenvererbung || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | nein
|-
| style=&quot;text-align:left&quot;| Keine mehrfache Implementationsvererbung || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja
|}

==Literatur==
* Niklaus Wirth:
** ''Programming in Modula 2'', Springer, 3. Auflage, 1985, ISBN 3-540-15078-1
** Mit Martin Reiser: ''Programming in Oberon – Steps beyond Pascal and Modula'', Addison-Wesley,1992, ISBN 0-201-56543-9
** ''Algorithmen und Datenstrukturen mit Modula - 2'', Teubner Leitfäden der Informatik, 5. Auflage, Teubner, Stuttgart, 1996, ISBN 9783519122609
* Herbert Schildt: ''Professionelles Modula-2'', McGraw-Hill, Hamburg, 1988, ISBN 3-89028-113-3
* Lászlo Böszörmény, Jürg Gutknecht, Gustav Pomberger: ''The School of Niklaus Wirth – The Art of Simplicity'', dpunkt, Heidelberg, 2000, ISBN 3-932588-85-1
* Hanspeter Mössenböck:
** ''Objektorientierte Programmierung in Oberon-2'', Springer, 1998, ISBN 9783540646495
** ''Sprechen Sie Java?: Eine Einführung in das systematische Programmieren'', dpunkt, Heidelberg, 2005, ISBN 9783898643627
** ''Kompaktkurs C# 4.0'', dpunkt, Heidelberg, 2009, ISBN 9783898646451

==Weblinks==
*{{w|Niklaus Wirth}}:
**Interessantes Interview: [http://www.simple-talk.com/opinion/geek-of-the-week/niklaus-wirth-geek-of-the-week/ Geek of the Week] vom 2. Juli 2009
**Ein noch interessanteres Interview (2009): [http://www.youtube.com/watch?v=wrGytM2YTQY An Interview with Niklaus Emil Wirth, Part 3]
*{{w|Frederick P. Brooks}}: [[w:en:The_Mythical_Man-Month|The Mythical Man-Month]]
*{{w|Benutzer:Bautsch|Markus Bautsch}}: [[:en:User:Bautsch/Capsula|Draft of the graphical programming language '''Capsula''']] (Wikibooks)

== Einzelnachweise ==
&lt;references&gt;&lt;/references&gt;

==Zusammenfassung des Projekts==
{{Vorlage:StatusBuch|10}}
* '''Zielgruppe:''' Programmierer, Software-Entwickler, Informatik-Lehrende
* '''Lernziele:''' Vermeidung von Fehlern, die leicht und unbemerkt zur unstrukturierten Programmierung führen können. Schnelle und sichere Erstellung leicht zu wartender Software.
* '''Buchpatenschaft/Ansprechperson:''' [[Benutzer:Bautsch]]
* '''Sind Co-Autoren gegenwärtig erwünscht?''' Ja, sehr gerne. Korrekturen von offensichtlichen Fehlern direkt im Text; Inhaltliches bitte per Diskussion.
* '''Richtlinien für Co-Autoren:''' Wikimedia-like.

[[Kategorie:Buch]]
[[Kategorie:Studium]]</text>
      <sha1>tcdn257ngz2rvhj6t2lp6oy0va41gb2</sha1>
    </revision>
    <revision>
      <id>1088584</id>
      <parentid>1088582</parentid>
      <timestamp>2026-07-03T12:36:22Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <comment>/* Bezeichner */ Unterprogramme</comment>
      <origin>1088584</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="180573" sha1="p3njimatgog1cegdbaanbzfaddhf1ag" xml:space="preserve">{{Regal | ort=Programmierung}}
[[Datei:Programmierung.Java.Julia-Menge.png|mini|rechts|hochkant=2|Bildschirmaufnahme des mit Tastatursteuerung interaktiven Java-Programms [[Das Apfelmännchen/ FraktaleMengeAusgabe|FraktaleMengeAusgabe]] zur Berechnung und Darstellung von Julia-Mengen oder der Mandelbrot-Menge. Siehe auch '''Wikibook [[Das Apfelmännchen]]'''.]]
[[Datei:Programmierung.Java.Maze.png|mini|rechts|hochkant=2|Bildschirmaufnahme des Java-Programms [[Rekursive Labyrinthe/ MazeGraphs|Maze]] zur rekursiven Erstellung und Darstellung von Labyrinthen. Siehe auch '''Wikibook [[Rekursive Labyrinthe]]'''.]]
[[Datei:Programmierung.Java.SimForestFrame.png|mini|rechts|hochkant=2|Bildschirmaufnahme des Java-Programms [[Waldbrandsimulation/ SimForestFrame|SimForestFrame]] zur Simulation und Darstellung von sich ausbreitenden Waldbränden. Siehe auch '''Wikibook [[Waldbrandsimulation]]'''.]]
[[Datei:Programmierung.Java.Campingplatzraetsel.png|mini|rechts|hochkant=2|Bildschirmaufnahme des mit Maussteuerung interaktiven Java-Programms [[Campingplatzrätsel/ CampingplatzGraphs|CampingplatzGraphs]] zur Erstellung und Darstellung von Campingplatzrätseln. Siehe auch '''Wikibook [[Campingplatzrätsel]]'''.]]
[[Datei:Programmierung.Java.GameOfLife.png|mini|rechts|hochkant=2|Bildschirmaufnahme des Java-Programms &quot;GameOfLife&quot; zur Anzeige von Conways Spiel des Lebens. Siehe auch '''Wikibook [[Game of Life]]'''.]]

==Einleitung==
Das Buch '''Strukturierte Programmierung''' ist kein Lehrbuch zum Erlernen einer Programmiersprache, sondern soll als kleiner Leitfaden dazu dienen, besser strukturierte Programme erstellen zu können, selbst wenn die eingesetzten Programmiersprachen die strukturierte Programmierung weniger stark unterstützen.

&lt;big&gt;Warum lohnt es sich überhaupt, strukturiert zu programmieren&amp;nbsp;?&lt;/big&gt;

Es gibt eine ganze Reihe von naheliegenden Gründen, aber auch einige Vorteile, die nicht auf der Hand liegen oder jedermann sofort ersichtlich sind. Anfänger und Fortgeschrittene profitieren gleichermaßen von gut strukturierter Programmierung. Die Vorteile sind so erheblich, dass es unbedingt sinnvoll ist, gut strukturiert zu programmieren. Im Folgenden werden einige wichtige Vorteile aufgeführt und erläutert:

*'''Strukturierte Programme sind leichter nachvollziehbar.''' Dies erleichtert die Arbeit im Team und vereinfacht die Wartung, wenn der Quellcode ergänzt, geändert oder korrigiert werden muss.
*'''Strukturierte Programme haben weniger Programmierfehler.''' Dies reduziert die Entwicklungszeiten und erhöht die Akzeptanz bei den Auftraggebern und Nutzern der Software.
*'''Strukturierte Programme können ohne Laufzeit-Debugger erstellt werden.''' Dies spart enorm viel Zeit und Nerven bei der Entwicklung von Software.

Die geringen Laufzeiteinbußen, die bei hoch strukturierter Programmierung von Anwendungssoftware gegenüber laufzeitoptimiertem Code entstehen können, spielen –&amp;nbsp;sofern sie überhaupt existieren sollten&amp;nbsp;– bei den heutzutage zur Verfügung stehenden modernen und schnellen Rechenmaschinen praktisch keine Rolle mehr. Programmcode wegzulassen, der der inhärenten Betriebssicherheit von Software oder der inhärenten Datenintegrität dient, macht nur in sehr wenigen, extrem zeitkritischen Anwendungen Sinn, keineswegs jedoch bei herkömmlichen oder gar sicherheitskritischen Anwendungsprogrammen.

Die Ratschläge aus diesem Buch beruhen auf jahrzehntelanger Erfahrung mit der Softwareentwicklung komplexer Systeme und dem Hochschulunterricht im Fach Programmierung mit verschiedenen Programmiersprachen.

Die folgende Check-Liste enthalt eine Reihe von wichtigen Kriterien, die bei strukturierter Programmierung berücksichtigt werden sollten:

* &lt;big&gt;&lt;big&gt;'''[[Strukturierte Programmierung/ Checkliste|Checkliste]]'''&lt;/big&gt;&lt;/big&gt;

Übrigens: ''In der Kürze der Quelltextdatei liegt nicht die wahre Würze des Programmierens&amp;nbsp;!''

Und noch wichtiger:

:''So ists mit aller Bildung auch beschaffen:''
:''Vergebens werden ungebundne Geister''
:''Nach der Vollendung reiner Höhe streben.''

:''Wer Großes will, muß sich zusammenraffen;''
:''In der Beschränkung zeigt sich erst der Meister,''
:''Und das Gesetz nur kann uns Freiheit geben.''

::Johann Wolfgang von Goethe, Ende von ''Das Sonett''

Viel Erfolg beim strukturierten Programmieren wünscht [[Benutzer:Bautsch]]&amp;nbsp;!
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Quelltextgestaltung==
In diesem Abschnitt stehen einige Vorschläge zur allgemeinen Gestaltung der Quelltexte, die keine unmittelbare Auswirkung auf die Lauffähigkeit und die Funktion der Programme haben, aber dazu führen, dass der Quelltext besser verständlich und nachvollziehbar ist.

===Anweisungen===
Der Quelltext wird bei imperativen Programmiersprachen durch Anweisungen gestaltet, die ganz unterschiedlich geartet sein können. Zu den typischen und wichtigen Anweisungen gehören:

* Deklaration (declaration)
* Blockanweisung (block, begin / end)
* Zuweisung (assignment)
* Aufruf (call)
* Rücksprung (return)
* Verzweigung (branch)
* Schleife (loop)
* Sicherstellung (assertion)

Bei Kommentaren und Leerräumen (Leerzeichen, Tabulatoren, Zeilenumbrüche, ...) in Quelltexten handelt es sich nicht um Anweisungen, da sie vom Übersetzer (compiler) beziehungsweise Interpreter des Programmcodes ignoriert werden.

===Kommentare===
Jeder Quelltext sollte zu Beginn der Datei in einem von Compiler zu ignorierenden '''Kommentar''' für die Klarstellung des Inhalts einige Mindestangaben zum Inhalt und Ursprung machen. Dazu gehören beispielsweise die Autoren, Urheber oder Rechteinhaber, deren beabsichtigte Nutzungsarten/-rechte und Nutzungsbedingungen und weitere Angaben zur Lizenzierung, das Datum der Erstellung oder Veränderung, eine Versionsangabe und Angaben zur verwendeten Programmiersprache und gegebenenfalls zu den eingesetzten Programmbibliotheken (gegebenenfalls ebenfalls mit Versionsangaben). Ferner soll beschrieben werden, für welchen Zweck oder für welche Aufgabenstellungen das Programm eingesetzt werden kann. Darüber hinaus können und sollen auch weitere sinnvolle oder nützliche Angaben in diesem '''Kopfkommentar''' festgehalten werden.

Der Kommentartext wird bei vielen Programmiersprachen im Quelltext mit dem Symbolpaar &quot;/*&quot; und &quot;*/&quot; oder dem Symbolpaar &quot;(*&quot; und &quot;*)&quot; eingeschlossen.

Beispiel:

 /*
   Program: generation of pseudorandom numbers
   Author: Bautsch
   License: public domain
   Date: 7th January 2011
   Version: 1.0
   Programming language: Java
   Description: This program uses a primitive polynomial sequence with large prime coefficients to efficiently generate uniformly distributed pseudorandom numbers.
 */

Alle Methoden und Variablen werden ausreichend kommentiert, sofern sie nicht durch die Wahl „sprechender” Bezeichner selbsterklärend sind.

Bei Methoden werden insbesondere die Bedeutung aller Parameter und Rückgabewerte dokumentiert:

 /* The method &quot;add&quot; computes and returns the sum of &quot;summand1&quot; and &quot;summand2&quot; */
 double add (double summand1, double summand2)
 {
    double sum ← summand1 + summand2
    return sum
 }

Viele Entwicklungssysteme bieten Funktionen, die die Dokumentation der Quelltexte mit Kommentaren unterstützen.

Bei einigen Programmiersprachen ist Aufmerksamkeit geboten, wenn in der Sprachdefinition geschachtelte Kommentare nicht vorgesehen sind. Wird zum Beispiel während der Programmentwicklung Quelltext auskommentiert, um das Verhalten des modifizierten Programms zu überprüfen, und enthält dieser Quelltext einen Kommentar, ist dann nicht sofort erkennbar, welcher Abschnitt des Quelltextes tatsächlich auskommentiert werden soll. Dabei kann es auch vorkommen, dass einige Compiler die geschachtelten Kommentare erkennen und im eigentlichen Sinne des Programmierers berücksichtigen; andere Compiler, die sich streng an die standardisierten Sprachdefinitionen halten, jedoch nicht, so dass es bei der Portierung von Quellcode unweigerlich zu Übersetzungsfehlern kommt.

Das folgende Beispiel zeigt einen Programmabschnitt, bei dem hinter der letzten Anweisung zwischen den Zeichenfolgen &quot;/*&quot; und &quot;*/&quot; ein Textkommentar hinzugefügt wurde, der vom Compiler ignoriert werden soll.

 int i ← 1
 i ← i * i /* die Variable i wird quadriert. */

Wird zusätzlich mit den gleichen Zeichenfolgen &quot;/*&quot; und &quot;*/&quot; die gesamte Programmzeile auskommentiert, gibt es einen Übersetzungsfehler, wenn der Compiler die allerletzte Zeichenfolge &quot;*/&quot; als Kommentarende ohne Kommentaranfang interpretiert, sofern der zweite und nunmehr auskommentierte Kommentaranfang &quot;/*&quot; in der Zeile mit dem Textkommentar ignoriert wurde und die erste auftretende Zeichenfolge &quot;*/&quot; bereits als Kommentarende interpretiert wurde:

 int i ← 1
 /*
    i ← i * i /* die Variable i wird quadriert. */
 */

===Leerräume===
'''Leerräume''', also zum Beispiel Leerzeichen, Zeilen- und Seitenumbrüche oder Tabulatoren, werden - genauso wie Kommentare - von vielen Compilern überlesen und dienen in diesen Fällen ausschließlich zur Verbesserung der Lesbarkeit für die Programmierer. Daher sollten diese Leerräume sorgfältig eingesetzt werden, um die Nachvollziehbarkeit des Quellcodes für Programmierer zu erleichtern. Bei einigen Programmiersprachen werden allerdings bestimmte Formatierungen in der Sprachdefinition gefordert und müssen dann natürlich den Vorgaben entsprechend eingehalten werden.

Viele Entwicklungssysteme bieten sehr nützliche, unterstützende Funktionen zur einheitlichen Formatierung der Quelltexte, die sehr einfach anzuwenden sind und benutzt werden sollten. So ist es zum Beispiel allgemein üblich, Programmblöcke so zu formatieren, dass die Inhalte gegenüber dem Kopf und dem Fuß etwas eingerückt und durch Zeilenumbrüche voneinander getrennt werden:

 Blockkopf
    eingerückter Inhalt 1
    eingerückter Inhalt 2
 Blockfuß

Für die Einrückungen werden heute meist mehrere Leerzeichen oder ein Tabulatorzeichen verwendet. Neuerdings wird in manchen Programmiersprachen empfohlen, vier Leerzeichen zu verwenden. Manche Editoren fügen bei der Betätigung der Tabulatortaste eine gewünschte Anzahl von Leerzeichen ein. Das Mischen von mehreren Leerzeichen und Tabulatorzeichen für die Einrückungen kann nicht empfohlen werden, da dies bei der Bearbeitung mit verschiedenen Editoren zur uneinheitlichen Darstellung der Einrückungen führen kann. Moderne Editoren haben Funktionen, mit denen der gesamte Programmcode oder Teile davon einheitlich und korrekt eingerückt werden können (Englisch: &quot;correct indentation&quot;).

Siehe hierzu auch [[Strukturierte Programmierung#Blockanweisungen|Blockanweisungen]].

===Bezeichner===
In den meisten Programmiersprachen gibt es '''Bezeichner''' (oder '''Identifikatoren''', englisch: '''identifier''') für ganz unterschiedliche Dinge, wie für symbolische '''Konstanten''', für '''Variablen''', für '''Parameter''' oder '''Attribute''', für '''Unterprogramme''' (respektive für '''Methoden''', '''Prozeduren''' oder für '''Funktionen'''), für '''Module''' (respektive für '''Klassen''') oder für '''Bibliotheken'''. Zur Strukturierung von Daten werden auch '''Pakete''' (englisch: '''packages''') eingesetzt.

In der Regel stehen alle Buchstaben ohne Diakritika zur Verfügung. Oft sind auch noch Ziffern und der Unterstrich &quot;_&quot; erlaubt. Das erste Zeichen muss üblicherweise immer ein Buchstabe sein. Leerzeichen sind innerhalb von Bezeichnern im Allgemeinen nicht zulässig.

Beim Lesen und Analysieren von Quelltexten ist es sehr hilfreich, wenn einem Bezeichner nicht nur beim ersten Auftauchen bei der Deklaration, sondern an jeder Stelle im Programm sofort angesehen werden kann, wofür er steht. Meist bildet sich für eine Gruppe von Programmiersprachen ein bestimmter Usus aus, wie die entsprechenden Bezeichner gestaltet werden sollen. Der Compiler stellt in der Regel keine Ansprüche an die Schreibweise von Bezeichnern, solange der definierte Zeichenvorrat verwendet wird. Eine Ausnahme stellen die vorgegebenen Schlüsselwörter dar, die häufig und je nach Programmiersprache nur aus Großbuchstaben oder nur aus Kleinbuchstaben bestehen, wie zum Beispiel:

* '''IMPORT''', '''CONST''', '''TYPE''', '''VAR''', '''PROCEDURE''', '''NIL''', '''LONG''', '''REAL''', '''BEGIN''', '''END''', '''WHILE'''
versus
* '''import''', '''final''', '''void''', '''static''', '''null''', '''long''', '''double''', '''while'''

In vielen Programmiersprachen haben sich für die frei definierbaren Bezeichner bestimmte Praktiken herausgebildet, damit die Bedeutung der Bezeichner im Quelltext von den beteiligten Programmierern leichter erkannt werden kann. Dieses Vorgehen ist allerdings nicht immer einheitlich gestaltet, wie anhand der folgenden, beispielhaften Liste gesehen werden kann:
* Die Bezeichner von übergeordnet verfügbaren Konstanten, Variablen, Datentypen, Klassen oder Modulen beginnen mit '''einem Großbuchstaben'''.
* Die Bezeichner von Konstanten werden '''vollständig mit Großbuchstaben''' geschrieben.
* Die Bezeichner von lokal verfügbaren Variablen, Attributen oder Parametern werden '''vollständig mit Kleinbuchstaben''' geschrieben.
* Die Bezeichner von Methoden werden '''vollständig mit Kleinbuchstaben''' geschrieben.

====Variablen und Methoden====
So ist es zum Beispiel üblich, Variablen und Methoden mit Kleinbuchstaben zu benennen. Dabei ist der Unterschied zwischen Variable und Methode immer und einfach anhand der obligatorischen Parameterliste von Methoden zu erkennen, die beim Fehlen von Parametern leer ist und in vielen Programmiersprachen durch runde Klammern begrenzt ist und direkt hinter dem Methodennamen steht:

 /* &quot;diameter&quot; is variable of the data type integer */
 int diameter
 
 /* &quot;radius&quot; is variable (parameter of the function &quot;calcDiameter&quot;) of the data type integer */
 /* &quot;calcDiameter&quot; is a function */
 /* the result of the function call has the data type integer */
 int calcDiameter (int radius)

&quot;calcDiameter&quot; ist hierbei mit dem Binnenmajuskel &quot;D&quot; versehen (umgangssprachlich auch &quot;Kamelhöcker-Notation&quot; genannt, englisch &quot;camel case&quot;), um den Anfang eines neuen Wortes ohne die Verwendung eines Leerzeichens erkennbar zu machen.

Es ist im Sinne der guten Lesbarkeit des Quelltextes allgemein hilfreich, in Bezeichnern immer passende grammatische Formen zu verwenden, wie zum Beispiel:
* für booleschen Variablen und Funktionen: Partizipien oder Adjektive
* für andere Variablen und Funktionen: Substantive
* für Methoden und Kommandos: Verben im Imperativ

In manchen Programmiersprachen ist es üblich, lokale Variablen mit einem Kleinbuchstaben zu beginnen und globale Variablen - also in mehreren Programmodulen, Klassen oder Methoden sichtbare Variablen - mit einem Großbuchstaben zu beginnen, um deren Sichtbarkeiten unmittelbar erkennbar zu machen.

====Konstanten====
Die Werte von Konstanten können zur Laufzeit nicht mehr verändert werden. Dieser Umstand wird dem Compiler bei der Deklaration der Konstanten durch entsprechende Deklarationen (wie zum Beispiel &quot;CONST&quot;) oder Modifikatoren (wie zum Beispiel &quot;final&quot;) mitgeteilt.

Damit an jeder Stelle des Quelltextes, also auch nach der Deklaration, erkannt werden kann, dass es sich um eine Konstante handelt, ist es hilfreich Konstanten mit einem '''Großbuchstaben''' beginnen zu lassen; manchmal werden für Konstanten sogar ausschließlich Großbuchstaben verwendet.

Es ist empfehlenswert, die Initialisierung einer Konstanten immer unmittelbar im Kontext der Deklaration vorzunehmen, damit es keine Mehrdeutigkeiten und somit auch keine Verwechslungen durch undefinierte Werte geben kann. Wenn dies nicht sinnvoll erscheint, sollte vorzugsweise keine Konstante verwendet werden. In vielen modernen Programmiersprachen ist es möglich, Klassenvariablen beziehungsweise globale Variablen zu schützen, indem diese nur innerhalb einer Klasse beziehungsweise innerhalb eines Moduls verändert werden dürfen. In diesem Fall gibt es von Außerhalb nur einen Lesezugriff auf den Wert der Variablen (&quot;read-only&quot;), oder der aktuelle Wert der Variablen kann durch den Aufruf eines Unterprogramms zurückgegeben werden (&quot;get&quot;-Methoden).

&lt;syntaxhighlight lang=&quot;Pascal&quot;&gt;
(* Programmiersprache Component Pascal *)

MODULE Zahlen;

(* Auf die globale ganzzahlige Konstante &quot;Konstante&quot; kann nur lesend zugegriffen werden. *)
(* Die globale Konstante &quot;Konstante&quot; ist durch Deklaration und Initialisierung vollständig definiert. *)
CONST
	Konstante = 7;

(* Auf die globale ganzzahlige Variable &quot;zahl&quot; kann von außerhalb des Moduls &quot;Zahlen&quot; nur lesend zugegriffen werden. *)
(* Die globale Variable &quot;zahl&quot; wird mit dem Zusatz &quot;-&quot; als &quot;read-only&quot; deklariert. *)
VAR
	zahl-: LONGINT;

BEGIN
	(* Die globale Variable &quot;zahl&quot; wird mit einem Wert initialisiert. *)
	zahl := 8;
END Zahlen.
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Zahlen;
{
	// Auf die öffentliche ganzzahlige Klassenkonstante &quot;Konstante&quot; kann nur lesend zugegriffen werden.
	// Die Klassenkonstante &quot;Konstante&quot; ist durch Deklaration und Initialisierung vollständig definiert.
	// Die Klassenkonstante &quot;Konstante&quot; wird mit dem Zusatz &quot;final&quot; deklariert.
	public static final long Konstante = 7;

	// Auf die nicht-öffentliche ganzzahlige Klassenvariable &quot;zahl&quot; kann von außerhalb der Klasse
	// nur über die öffentliche Methode &quot;getZahl ()&quot; lesend zugegriffen werden.
	// Die Klassenvariable &quot;zahl&quot; wird mit dem Zusatz &quot;private&quot; deklariert.
	private static long zahl = 8;

	public static long getZahl ()
	{
		return zahl;
	}
}
&lt;/syntaxhighlight&gt;

Im folgenden Java-Beispiel wird eine als konstant deklarierte lokale Variable erst innerhalb einer Fallunterscheidung (if-Anweisung) und zudem mit zwei verschiedenen optionalen Werten initialisiert. Wenn die Deklaration und die optionalen Initialisierungen im Quelltext weiter auseinanderliegen, ist es schwierig, den definierten Zustand der vermeintlich eindeutig definierten Variablen vollständig zu erfassen.

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
private static boolean boolescherAusdruck ()
{
	java.util.Random zufall = new java.util.Random ();
	boolean zufaelligerBoolescherWert = zufall.nextBoolean ();
	return zufaelligerBoolescherWert;
}

public static void main (java.lang.String [] arguments)
{
	// Deklaration der lokalen Konstante &quot;Zahl&quot;,
	// die wegen fehlender Initialisierung nicht definiert ist.
	final long Zahl;

	if (boolescherAusdruck ())
	{
		Zahl = 7;
	}
	else
	{
		Zahl = 8;
	}
	java.lang.System.out.println (&quot;Konstante Zahl = &quot; + Zahl);
}
&lt;/syntaxhighlight&gt;

====Klassen und Module====
Auch Unterprogrammeinheiten wie '''Module''' oder '''Klassen''' werden in der Regel mit eindeutigen Bezeichnern benannt, die üblicherweise mit einem '''Großbuchstaben''' beginnen.

Im Kontext eines Quellcodes ist es immer möglich, diese Unterprogrammeinheiten von anderen zu unterscheiden, die ebenfalls mit einem Großbuchstaben beginnen (beispielsweise Konstanten), weil die Bezeichner von Unterprogrammeinheiten von einer Blockanweisung (zum Beispiel geschweifte Klammern) für die Implementation von Programmcode oder von einem Separator (beispielsweise &quot;.&quot;) zur qualifizierten Bezeichnung von Teilen der Unterprogrammeinheiten gefolgt werden.

Das Konzept von Unterprogrammeinheiten ist, dass mehrere Unterprogramme (Methoden, Prozeduren, Funktionen, Kommandos) sowie mehrere Konstanten, Variablen oder Datenstrukturen (Verbunde (struct, record), Arrays) in einer speicherbaren Datei zusammengefasst werden. Insofern handelt es sich bei solchen Unterprogrammeinheiten um die '''kleinsten dauerhaft speicherbaren Einheiten''' in einem Software-Projekten.

Unterprogrammeinheiten werden in strukturierten Programmiersprachen unter der Verwendung von Schlüsselwörtern wie zum Beispiel &quot;program&quot;, &quot;MODULE&quot; oder &quot;class&quot; '''deklariert''':

&lt;syntaxhighlight lang=&quot;Pascal&quot;&gt;
(* Die Unterprogrammeinheit &quot;Programmeinheit&quot; in der Programmiersprache Pascal *)
program Programmeinheit;
begin
end.
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;modula2&quot;&gt;
(* Die Unterprogrammeinheit &quot;Programmeinheit&quot; in den Programmiersprachen Modula-2, Oberon oder Component Pascal *)
MODULE Programmeinheit;
BEGIN
END Programmeinheit.
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
// Die Unterprogrammeinheit &quot;Programmeinheit&quot; in der Programmiersprache Java
public class Programmeinheit;
{
}
&lt;/syntaxhighlight&gt;

====„Sprechende” Bezeichner====
Die Wahl '''„sprechender“ Bezeichner''' hilft beim Lesen, Verstehen und Nachvollziehen von Quelltext ungemein. Häufig erübrigt sich sogar ein erläuternder Kommentar, wenn mit hinreichend „sprechenden“ Variablen- beziehungsweise Methodennamen gearbeitet wird.

Also nicht eine solche Anweisung:

 h ← (t – b)

Sondern besser:

 height ← (top - bottom)

Die verpasste Chance, einen Bezeichner sprechend zu benennen, kann in vielen Entwicklungssystemen durch sogenanntes ''Refactoring'' zentral für den gesamten Quelltext durch Umbenennung geheilt werden.

====Parameter====
Bei Methodenaufrufen werden '''alle Parameter''' mit Variablen oder mit Konstanten übergeben, also nicht mit '''komplexen Ausdrücken''' (beispielsweise arithmetische Berechnungen und Aufrufe von Unterprogrammen) oder mit '''Literalen''' (also direkt eingegebene Werte, wie 100 oder &quot;Text&quot;).

Hier ein schlechtes Beispiel mit dem Aufruf des Java-Unterprogramms &quot;zeichneRechteck&quot; mit fünf kryptischen Parameterausdrücken in den runden Klammern. Jedes der fünf Literalen 50 hat eine eigene unabhängige Bedeutung, die bei dieser Schreibweise nicht unterschieden oder nachvollzogen werden können, was deswegen schnell zu Verwechslungen führen kann:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   zeichneRechteck (50, 50, 50, berechneHoehe (50), 50);
&lt;/syntaxhighlight&gt;

Ein strukturiertes Programm weist die Werte für alle fünf Parameter vor dem Aufruf des Unterprogramms an eigene Variablen mit sprechenden Bezeichnern zu:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   int x = 50;
   int y = 50;
   int breite = 50;
   int hoehe = berechneHoehe (breite);
   int helligkeitProzent = 50;
   zeichneRechteck (x, y, breite, hoehe, helligkeitProzent);
&lt;/syntaxhighlight&gt;

Diese Anweisungsfolge ist im Gegensatz zu der Anweisung darüber auch ohne die explizite Kenntnisnahme der '''Deklaration des Unterprogramms''' verständlich:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   /**
   * Zeichnet ein Rechteck in das Bildschirmfenster
   * @param x: x-Koordinate vom linken Bildschirmfensterrand nach rechts
   * @param y: y-Koordinate vom oberen Bildschirmfensterrand nach unten
   * @param breite: Breite des Rechtecks von x nach rechts
   * @param hoehe: Hoehe des Rechtecks von y nach unten
   * @param helligkeitProzent: Helligkeit des Rechtecks in Prozent (0 = schwarz, 100 = weiss)
   */
   public static void zeichneRechteck (int x, int y, int breite, int hoehe, int helligkeitProzent)
&lt;/syntaxhighlight&gt;

====Qualifizierte Bezeichner====
=====Programmeinheiten=====
Damit der sich hinter einem Bezeichner verborgene Inhalt eindeutig einer Programmeinheit zugeordnet werden kann, muss dieser '''qualifiziert bezeichnet''' werden.

In manchen Programmiersprachen geschieht dies für bestimmte Bezeichner inhärent, obwohl es eine explizite import-Anweisung für die entsprechenden Bezeichner gibt, so dass die Programmierer in diesen Sonderfällen also wissen müssen, worauf sich der unqualifizierte Bezeichner bezieht. In der Programmiersprache Java dürfen häufig verwendete Bezeichner wie beispielsweise die zur Textausgabe verwendete Methode &quot;print&quot; aus der Klasse &quot;System&quot; oder die für Zeichenketten verwendete Klasse &quot;String&quot; ohne eine vollständige und qualifizierte Bezeichnung in den Programmtext geschrieben werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   String text = &quot;Hallo Welt!&quot;;
   System.out.print (text);
&lt;/syntaxhighlight&gt;

In der Variablen &quot;text&quot; der Klasse &quot;String&quot; wird die Zeichenkette &quot;Hallo Welt!&quot; gespeichert und mit der klassengebundenen Methode &quot;print&quot; der Klassenvariablen &quot;out&quot; aus der Klasse &quot;System&quot; ausgegeben. Hier ist allerdings nicht ohne weiteres ersichtlich, wo sich die Deklarationen oder die Implementierungen beiden Klassen &quot;String&quot; und &quot;System&quot; befinden.

Die '''qualifizierte Bezeichnung''' dieser beiden Anweisungen hat folgendes Aussehen:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   java.lang.String text = &quot;Hallo Welt!&quot;;
   java.lang.System.out.print (text);
&lt;/syntaxhighlight&gt;

Durch die qualifizierte Bezeichnung wird klar, dass sich beide Klassen im Programmpaket &quot;java.lang&quot; des Programmmoduls &quot;java.base&quot; befinden. Jedes Modul (englisch &quot;module&quot;) und jedes Paket (englisch &quot;package&quot;) kann in der Systembibliothek der Programmiersprache beziehungsweise in der Programmbibliothek der Laufzeitumgebung eindeutig zugeordnet werden.

Alternativ wird die Qualifikation von bestimmten Bezeichnern durch eine Import-Anweisung zu Beginn des Programms vorgenommen:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   import java.lang.String;
   import java.lang.System;

//...

      String text = &quot;Hallo Welt!&quot;;
      System.out.print (text);
&lt;/syntaxhighlight&gt;

Dieses Vorgehen erlaubt innerhalb einer Programmdatei zwar grundsätzlich eine korrekte und eindeutige Zuordnung der weiter unten im Programmtext verwendeten '''unqualifizierten''' Bezeichner, bei der Analyse des Programmtextes sind sämtliche Import-Anweisungen jedoch stets und vollständig zu berücksichtigen, was die Sache für die Programmierer insbesondere bei langen oder komplexen Quelltexten sehr erschweren kann. Dies kann durch die ausschließliche und obligatorische Verwendung von qualifizierten Bezeichnern ausgeschlossen werden, und deswegen wird von streng strukturierten Programmiersprachen überall und immer eine qualifizierte Bezeichnung gefordert.

Leider dürfen diese qualifizierten Importe beziehungsweise Bezeichnungen in manchen Programmiersprachen für gängige Unterprogrammeinheiten weggelassen werden, wie im folgenden Beispiel in der Programmiersprache Java:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
public class Test
{
   public static void main (String [] args)
   {
   }
}
&lt;/syntaxhighlight&gt;

Ein Aufruf des formal korrekt deklarierten Hauptprogramms &quot;main&quot; kann zu folgender völlig irritierender Fehlermeldung führen, wenn gar nicht die dafür vorgesehene Standard-Java-Klasse &quot;java.lang.String&quot; referenziert wird, weil sich im Software-Projekt, in dem sich das Hauptprogramm befindet, eine gleichnamige Klasse &quot;String&quot; definiert ist, die durch die Regeln der Programmiersprache vorrangig referenziert wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
Error: Main method not found in class Test, please define the main method as: public static void main (String [] args)
&lt;/syntaxhighlight&gt;

=====Datenstrukturen=====
Auch bei Datenstrukturen müssen qualifizierte Bezeichner verwendet werden, damit eindeutig auf bestimmte Datenfelder zugegriffen werden kann. Im folgenden Beispiel in der Syntax der '''Pascal'''-Programmiersprachenfamilie wird dies anhand des komplexen Datentyps &quot;Postadresse&quot; mit den sechs Attributen &quot;vorname&quot;, &quot;nachname&quot;, &quot;strasse&quot;, &quot;hausnummer&quot;, &quot;postleitzahl&quot; und &quot;ort&quot; dargestellt:

&lt;syntaxhighlight lang=&quot;Pascal&quot;&gt;
   (* Datentyp &quot;Postadresse&quot; *)
   TYPE Postadresse =
      RECORD
         vorname: ARRAY OF CHAR;
         nachname: ARRAY OF CHAR;
         strasse: ARRAY OF CHAR;
         hausnummer: ARRAY OF CHAR;
         postleitzahl: LONGINT;
         ort: ARRAY OF CHAR;
      END;
&lt;/syntaxhighlight&gt;

In den Deklarationen der Attribute steht &quot;ARRAY OF CHAR&quot; für den Datentyp Zeichenkette, der zur Speicherung von Zeichenfolgen verwendet wird. Der Datentyp &quot;LONGINT&quot; dient zur Speicherung ganzer Zahlen.

Eine Instanz &quot;adresse&quot; dieses Datentyps &quot;Postadresse&quot; kann wie folgt mit der NEW-Prozedur erzeugt werden, wobei der dafür erforderliche Speicherplatz festgelegt und für andere Verwendungen gesperrt wird. Auf die sechs einzelnen Datenfelder der in &quot;adresse&quot; gespeicherten sechs Attribute des Datentyps &quot;Postadresse&quot; kann danach im Programm mit den entsprechenden qualifizierten Bezeichnern beispielsweise zugegriffen werden, indem die jeweiligen initialen Werte mithilfe des Zuweisungsoperators := zugewiesen werden. Auf die Prozeduren &quot;String&quot; und &quot;Int&quot; aus dem Modul &quot;Out&quot; wird über &quot;Out.String&quot; und &quot;Out.Int&quot; ebenfalls qualifiziert zugegriffen:

&lt;syntaxhighlight lang=&quot;Pascal&quot;&gt;
   IMPORT
      Out; (* Import des Moduls &quot;Out&quot; mit den Textausgabe-Prozeduren &quot;String&quot; für Zeichenketten und &quot;Int&quot; für ganze Zahlen *)
   VAR
      adresse: Postadresse; (* globale Variable &quot;adresse&quot; *)
   BEGIN
      NEW (adresse);  (* Speicherreservierung für den Bezeichner &quot;adresse&quot; *)
      adresse.vorname := &quot;Irgend&quot;;
      adresse.nachname := &quot;Jemand&quot;;
      adresse.strasse := &quot;Allee&quot;;
      adresse.hausnummer := &quot;100&quot;;
      adresse.postleitzahl := 10000;
      adresse.ort := &quot;Irgendwo&quot;;

      Out.String (adresse.vorname);
      Out.String (adresse.nachname);
      Out.String (adresse.strasse);
      Out.String (adresse.hausnummer);
      Out.Int (adresse.postleitzahl);
      Out.String (adresse.ort);
   END;
&lt;/syntaxhighlight&gt;

In einem weiteren Beispiel mit der Syntax der Programmiersprache '''Java''' wird die Datenstruktur dieses komplexen Datentyps als Klasse &quot;Postadresse&quot; mit den sechs Instanzvariablen &quot;vorname&quot;, &quot;nachname&quot;, &quot;strasse&quot;, &quot;hausnummer&quot;, &quot;postleitzahl&quot; und &quot;ort&quot; für diese sechs Attribute gebildet. Eine Instanz dieses Datentyps kann hier mit dem new-Operator erzeugt werden. Der öffentliche Konstruktor &quot;Postadresse ()&quot; ist eine Methode mit derselben Bezeichnung wie die Klasse selbst, die aufgerufen werden muss, um die sechs Datenfelder der jeweiligen Instanz &quot;this&quot; zu initialisieren. Auf die einzelnen Datenfelder der in der nicht-öffentlichen Klassenvariable &quot;adresse&quot; gespeicherten sechs Attribute des Datentyps &quot;Postadresse&quot; kann danach über die entsprechenden sechs qualifizierten Bezeichner zugegriffen werden. In der Methode &quot;main&quot; werden die Attribute zwischen den runden Klammern über die qualifizierten Bezeichner als Parameter bei den Aufrufen der allgemeinen Textausgabe-Methode &quot;println&quot; verwendet, die zur Klassenvariable &quot;out&quot; der Klasse &quot;System&quot; im Programmpaket &quot;java.lang&quot; gehört:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
public class Postadresse // Klasse &quot;Postadresse&quot;
{
   // Instanzvariablen
   java.lang.String vorname;
   java.lang.String nachname;
   java.lang.String strasse;
   java.lang.String hausnummer;
   long postleitzahl;
   java.lang.String ort;

   private static Postadresse adresse = new Postadresse (); // Klassenvariable &quot;adresse&quot;

   public Postadresse () // Konstruktor der Klasse &quot;Postadresse&quot;
   {
      this.vorname = &quot;Irgend&quot;;
      this.nachname = &quot;Jemand&quot;;
      this.strasse = &quot;Allee&quot;;
      this.hausnummer = &quot;100&quot;;
      this.postleitzahl = 10000;
      this.ort = &quot;Irgendwo&quot;;
   }

   public static void main (java.lang.String [] argumente) // main-Methode der Klasse &quot;Postadresse&quot;
   {
      java.lang.System.out.println (adresse.vorname);
      java.lang.System.out.println (adresse.nachname);
      java.lang.System.out.println (adresse.strasse);
      java.lang.System.out.println (adresse.hausnummer);
      java.lang.System.out.println (adresse.postleitzahl);
      java.lang.System.out.println (adresse.ort);
   }
}
&lt;/syntaxhighlight&gt;

====Komplexe Anweisungen====
In der Programmiersprache Java kann die Gestaltung eines softwaretechnischen Containers &quot;host&quot; beispielsweise mit der Variablen &quot;layout&quot; realisiert werden. Hierzu werden Instanzen von Objekten der Klassen &quot;Container&quot; und &quot;GroupLayout&quot; erzeugt:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   java.awt.Container host = new java.awt.Container ();
   javax.swing.GroupLayout layout = new javax.swing.GroupLayout (host);
&lt;/syntaxhighlight&gt;

Eine multiple qualifizierte Bezeichnung zur Referenzierung von Datenfeldern mit diversen Aufrufen typengebundener Methoden (Unterprogramme) kann dann mit einer einzigen hyperkomplexen Anweisung in einer Zeile zusammengefasst werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   layout.setVerticalGroup (layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING).addGroup (layout.createSequentialGroup ().addContainerGap ().addGroup(layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING).addGroup (layout.createSequentialGroup().addGroup (layout.createParallelGroup (javax.swing.GroupLayout.Alignment.BASELINE))))));
&lt;/syntaxhighlight&gt;

Mit Zeilenumbrüchen wird der inhaltlich identische Quelltext schon besser nachvollziehbar:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   layout.setVerticalGroup
   (
      layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING)
      .addGroup (layout.createSequentialGroup ()
      .addContainerGap ()
      .addGroup (layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING)
      .addGroup (layout.createSequentialGroup()
      .addGroup (layout.createParallelGroup (javax.swing.GroupLayout.Alignment.BASELINE)))))
   );
&lt;/syntaxhighlight&gt;

Durch Verwendung von Hilfsvariablen mit sprechenden Bezeichnern wird der Quelltext zwar etwas länger, aber noch verständlicher. Die Komplexität ist deutlich reduziert, und die Anweisungsfolge kann viel einfacher nachvollzogen, überprüft oder angepasst werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
      javax.swing.GroupLayout.SequentialGroup sequentialGroup2 = layout.createSequentialGroup ();
      javax.swing.GroupLayout.ParallelGroup parallelBaselineGroup = layout.createParallelGroup (javax.swing.GroupLayout.Alignment.BASELINE);
      sequentialGroup2 = sequentialGroup2.addGroup (parallelBaselineGroup);

      javax.swing.GroupLayout.ParallelGroup parallelLeadingGroup2 = layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING);
      parallelLeadingGroup2 = parallelLeadingGroup2.addGroup (sequentialGroup2);

      javax.swing.GroupLayout.SequentialGroup sequentialGroup1 = layout.createSequentialGroup ();
      sequentialGroup1 = sequentialGroup1.addContainerGap ();
      sequentialGroup1 = sequentialGroup1.addGroup (parallelLeadingGroup2);

      javax.swing.GroupLayout.ParallelGroup parallelLeadingGroup1 = layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING);
      parallelLeadingGroup1 = parallelLeadingGroup1.addGroup (sequentialGroup1);

      layout.setVerticalGroup (parallelLeadingGroup1);
&lt;/syntaxhighlight&gt;

==Programmgestaltung==
Idealerweise kann die kontextfreie Grammatik der verwendeten Programmiersprache mit einer strukturierten Metasprache, wie zum Beispiel der '''Erweiterten Backus-Naur-Form''' ('''EBNF''') nach der Norm ISO/IEC 14977 dargestellt werden. Jedes strukturierte Programm und jede Datenstruktur kann damit eindeutig definiert werden. Leider trifft dies für viele Programmiersprachen nicht zu. Die Darstellung beliebiger ganzer Zahlen (sowohl negative, als auch positive und die Null) mit Zeichen kann in der Erweiterten Backus-Naur-Form zum Beispiel schrittweise so definiert werden:

&lt;syntaxhighlight lang=&quot;ebnf&quot;&gt;
 NatuerlicheZiffer = &quot;1&quot; | &quot;2&quot; | &quot;3&quot; | &quot;4&quot; | &quot;5&quot; | &quot;6&quot; | &quot;7&quot; | &quot;8&quot; | &quot;9&quot;;
 Ziffer = &quot;0&quot; | NatuerlicheZiffer;
 NatuerlicheZahl = NatuerlicheZiffer{Ziffer};
 GanzeZahl = &quot;0&quot; | [&quot;-&quot;]NatuerlicheZahl;
&lt;/syntaxhighlight&gt;

[[Datei:Nassi-Shneiderman diagram - InsertionSort.svg|mini|rechts|hochkant=2|Beispiel für einen Algorithmus mit zwei geschachtelten, kopfgesteuerten Schleifen in der Darstellung als Nassi-Shneidermann-Diagramm.]]

Programme können als '''Struktogramm''' (auch '''Nassi-Shneidermann-Diagramm genannt''') nach Norm DIN 66261 notiert werden. Alle Teilprogramme sind dabei so geartet, dass sie ausgehend von einem einfachen Hauptblock, der für das gesamte Programm und somit für mindestens einen Unterprogrammaufruf steht, durch schrittweise Verfeinerung hierarchisch zusammengesetzt werden können. Am Ende der Hierarchie stehen dann elementare Teilprogramme, die nicht weiter zerlegt werden können.

Die zyklomatische Komplexität der Software kann zum Beispiel mit der '''McCabe-Metrik''' untersucht und analysiert werden. Hierbei sollte darauf geachtet werden, dass die Komplexität beschränkt bleibt, damit der Quelltext überschaubar bleibt und gut nachvollzogen werden kann. Durch geeignete Strukturierung ist dies in modernen Programmiersprachen immer möglich, und mit einer McCabe-Metrik bis maximal 10 ist die Komplexität meist hinreichend niedrig.

Dies gilt nicht nur für den prozeduralen Programmablauf, sondern gleichermaßen für Datenstrukturen, bei denen komplexe Datentypen aus elementaren Datentypen übersichtlich und hierarchisch zusammengesetzt werden können.

Wichtig ist, dass die Anzahl der Programmzeilen ('''lines of code''') zwar gut als Maß für das zeitliche Wachstum einer bestimmten Software herangezogen werden kann, dies jedoch nicht geeignet ist, um eine Aussage über die Qualität oder Strukturiertheit des Programmcodes zu treffen. Weder eine besonders kleine noch eine besonders große Anzahl von Programmzeilen sind ein Garant für guten oder strukturierten Code.

Das Optimum ist nicht erreicht, wenn nichts mehr hinzugefügt werden kann, weil schon alles implementiert ist, sondern wenn nichts mehr entfernt werden kann, ohne dass die Implementierung hiervon beeinträchtigt wird (frei nach Antoine de Saint-Exupéry in ''Wind, Sand und Sterne - Terre des Hommes'' (1939)).

Programmieren ist nicht nur ein einfaches Handwerk, sondern eine anspruchsvolle Kunstfertigkeit (vergleiche auch Donald E. Knuth: ''The Art of Computer Programming'').
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

===Sichtbarkeiten===
Grundsätzlich gilt immer das '''Prinzip der Lokalität'''. Dies bedeutet, dass auf Programmkonstrukte nur dort zugegriffen werden kann und darf, wo es unbedingt erforderlich ist. Zum Datenaustausch zwischen verschiedenen Programmteilen dienen unter diesen Voraussetzungen Schnittstellen, die in der strukturierten Programmierung exakt definiert sein müssen.

Alle Klassenvariablen, Instanzvariablen und Parametervariablen sowie Rückgabewerte werden in Bezug auf ihre Teilprogramme zum Beispiel als '''lokale Variablen''' behandelt, so dass sie nur innerhalb dieser Teilprogramme aufgerufen und verändert werden können. Auf diese Weise können unbeabsichtigte und unerwünschte Seiteneffekte nachhaltig vermieden werden.

Je weniger lokal eine Variable definiert ist, desto größer ist die Gefahr, dass diese unbeabsichtigt oder sogar zuwider den Absichten des Programmierers verändert werden kann, was dann zu entsprechend dramatischen und schwer identifizierbaren Programmfehlern führen kann, die zudem erst zur Laufzeit auftreten und oft nur zufällig und somit umso schwerer zu entdecken sind. Variablen sollen also immer so '''lokal''' wie möglich definiert werden. Am besten sind Variablen lokalisiert, wenn sie innerhalb der Teilstruktur definiert werden, wo die Variablen üblicherweise „sichtbar” (und demzufolge verwendbar) sind. Außerhalb der Blöcke sind diese Variablen dann „unsichtbar” und somit auch nicht benutzbar.

Für Programmiersprachen die keine explizite Blockanweisung für Teilprogramme haben, ist die am stärksten lokalisierte Definition in der Regel innerhalb einer Methode respektive einer Prozedur oder einer Funktion. Die nächsthöhere Strukturebene ist dann - sofern möglich - das Modul beziehungsweise die Klasse (dies ist zwar häufig eine vom Compiler zu übersetzende Einheit, ist jedoch nicht unbedingt identisch mit einer Quelltextdatei). Innerhalb von Programmstrukturen sollten Variablen möglichst mit dem Sichtbarkeitsmodifikator für die ausschließlich interne Verwendbarkeit (zum Beispiel mit dem Modifikator ''private'' oder ''limited'') deklariert werden. Solche internen Variablen können dann gegebenenfalls mit entsprechend zu implementierenden Konstruktoren initialisiert, mit sogenannten Getter-Methoden abgefragt und mit Setter-Methoden verändert werden. Falls diese exportiert werden (beispielsweise mit dem Modifikator ''public'' oder ''export''), ist auch außerhalb der Deklarationsstruktur ein definierter indirekter Zugriff auf die internen Variablen möglich.

Manche Programmiersprachen erlauben eine Deklaration, die außerhalb des Deklarationsbereiches nur gesehen respektive gelesen werden können (zum Beispiel mit dem Modifikator ''read-only'' für Variablen oder ''implement-only'' für Methoden). In diesem Fall können die entsprechenden Variablen oder Methoden außerhalb der Deklarationsstruktur also nicht verändert, aber zumindest abgefragt oder aufgerufen werden.

'''Globale Variablen''', die überall innerhalb von großen Programmeinheiten verändert werden können, sind immer vermeidbar, erhöhen die Gefahr von Programmfehlern und erleichtern unter Umständen Cyber-Attacken.

Besondere Probleme ergeben sich, wenn innerhalb eines Sichtbarkeitsbereiches für verschiedene Dinge gleichlautende '''Bezeichner''' verwendet werden dürfen. Dies kann wegen der Wahlfreiheit bei der Benennung sehr leicht vermieden werden, indem einfach keine gleichlautenden Bezeichner benutzt werden. Im folgenden Beispiel wird verdeutlicht, wie in einem Java-Programm zwischen den Bezeichnern von lokalen und globalen Variablen sowie von Methoden formal dennoch eindeutig unterschieden werden kann:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
public class Bezeichner
{
	// globale Variable &quot;bezeichner&quot; (Klassenvariable)
	private static long bezeichner = 1;

	// Methode &quot;bezeichner&quot; (Unterprogramm)
	private static long bezeichner ()
	{
		// lokale Variable &quot;bezeichner&quot; in der Methode &quot;bezeichner&quot;
		long bezeichner = 3;
		return bezeichner;
	}

	// Hauptprogramm (Methode &quot;main&quot;)
	public static void main (java.lang.String [] argumente)
	{
		// Ausgabe der globalen Variable aus der Klasse &quot;Bezeichner&quot;
		java.lang.System.out.println (&quot;Wert der globalen Variable = &quot; + Bezeichner.bezeichner);

		// lokale Variable &quot;bezeichner&quot; in der Methode &quot;main&quot;
		long bezeichner = 2;
		// Ausgabe der lokalen Variable aus der Methode &quot;main&quot;
		java.lang.System.out.println (&quot;Wert der lokalen Variable = &quot; + bezeichner);

		// Ausgabe des Ergebnisses des Aufrufs der Methode &quot;bezeichner&quot;
		java.lang.System.out.println (&quot;Wert des Unterprogramms = &quot; + bezeichner ());
	}
}
&lt;/syntaxhighlight&gt;

In dieser Java-Klasse &quot;Bezeichner&quot; gibt es vier gleichlautende Bezeichner &quot;bezeichner&quot;:

* Der Name einer '''globalen Klassenvariable'''.
* Der Name einer '''Methode'''.
* Der Name einer '''lokalen Variable''' in der Methode &quot;bezeichner&quot;.
* Der Name einer '''lokalen Variable''' in der Methode &quot;main&quot;.

Nach den Regeln der Programmiersprache Java haben lokale Bezeichner bei der Referenzierung innerhalb einer Blockanweisung Vorrang, so dass bei der Verwendung dieser Bezeichner immer auf die lokale Variable zugegriffen wird. Im obigen Beispiel haben die beiden lokalen Variablen &quot;'''bezeichner'''&quot; nichts miteinander zu tun und können nur in ihrer entsprechenden Methode referenziert werden. Soll in einem lokalen Sichtbarkeitsbereich auf die globale Klassenvariable referenziert werden, so kann dies durch einen expliziten und '''qualifizierten Bezeichner''' erwirkt und sichergestellt werden, im obigen Beispiel mit &quot;'''Bezeichner.bezeichner'''&quot;. Der Bezeichner einer Methode kann durch das stets folgende runde Klammerpaar identifiziert werden, im obigen Beispiel &quot;'''bezeichner ()'''&quot;.

===Modularisierung===
Teilprogramme können Methoden oder ganze Sammlungen von Datenstrukturen und Methoden sein. Diese werden oft '''Klassen''' oder '''Module''' genannt und können in '''Paketen''' gruppiert werden. Alle Teilprogramme sollen eindeutige und sprechende Bezeichner und streng definierte Signaturen und Schnittstellen für die Namen und die Datentypen aller Parameter beziehungsweise Klassen- und Instanzvariablen haben. Bei diesen Teilprogrammen handelt es sich in der Regel um die kleinsten dauerhaft speicherbaren Programmeinheiten, die zum Beispiel in einer Datenbank oder einem Dateisystem zu größeren Einheiten wie Verzeichnissen, Paketen oder Bibliotheken zusammengefasst werden.

Solche Programmeinheiten werden durch ihre '''Signatur''' eindeutig gekennzeichnet. Die Signatur besteht zunächst aus dem '''Namen''' der Programmeinheit. Ferner kann mit einem Modifikator explizit definiert werden, dass diese Programmeinheit allgemein, also von allen und beliebigen anderen Programmeinheiten, verfügbar sein soll (Modifikator ''public'' / ''öffentlich''). Für eine Beschränkung nur auf die nächst höhere Programmeinheit, wie beispielsweise einem Paket (englisch &quot;package&quot;), kann der Modifikator ''private'' verwendet werden.

Eine typische Programmbibliothek hat in der Programmiersprache Java am Beispiel des Moduls &quot;java.base&quot; und der beiden Pakete &quot;java.io&quot; und &quot;java.lang&quot; folgende ausschnittsweise Struktur und Hierarchie:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
module java.base;

   package java.io;

      class Reader;
      {
         // Implementation der Klasse Reader
      }

      class Writer;
      {
         // Implementation der Klasse Writer
      }

   package java.lang;

      class String;
      {
         // Implementation der Klasse String
      }

      class System;
      {
         // Implementation der Klasse System
      }
&lt;/syntaxhighlight&gt;

===Methoden===
'''Methoden''' beziehungsweise '''Prozeduren''' werden ebenfalls durch ihre '''Signatur''' eindeutig deklariert, und alle Methodenaufrufe müssen sich streng an diese Deklaration halten. Die Signatur besteht zunächst aus dem '''Namen''' der Methode.

Methoden haben optional einen '''Rückgabewert''', für die der Datentyp ebenfalls festgelegt werden muss und der in streng strukturierten Programmiersprachen ebenfalls zur Signatur der Methode gehört und verwendet werden muss. Solche Methoden werden auch '''Funktionen''' genannt. Leider ist es in manchen Programmiersprachen erlaubt, Rückgabewerte von Funktionen einfach zu ignorieren und diese nicht in einer Variablen zu speichern oder im Rahmen eines Ausdrucks auszuwerten, da dies zu leicht zu übersehenden Programmierfehlern führen kann.

Ferner gibt es innerhalb der Signatur optionale '''Modifikatoren''', die die Regeln für die Sichtbarkeit (zum Beispiel ''öffentlich'' / ''privat'' / ''eingeschränkt'', englisch: ''public'' / ''private'' / ''limited'') festlegen.

Die Überschreibbarkeit einer Methode wird mit einem weiteren Modifikator festgelegt (wie zum Beispiel mit ''statisch'' / ''erweiterbar'' / ''abstrakt'' / ''abgeschlossen'', englisch: ''static'' / ''extensible'' / ''abstract'' / ''final'').

Methoden haben keinen, einen oder mehrere '''Parameter'''. Methoden ohne Parameter werden auch parameterlose Methoden genannt. Parameter sind innerhalb der Methode lokale Variablen, die beim Aufruf der Methode angegeben werden müssen und gegebenenfalls zusammen mit dem Rückgabewert die Schnittstelle für den Datenaustausch zum aufrufenden Programm darstellen. Die Anzahl, die Namen, die Datentypen und die Reihenfolge der '''Parameter''' gehören ebenfalls zur Signatur einer Methode. Beim Aufruf einer Methode müssen alle Parameter in der richtigen Reihenfolge und zuweisungskompatibel angegeben werden. Parameter können unterschieden werden in:

* '''Eingangsparameter''' ('''in'''), die als Wert (englisch ''value'') übergeben und nur innerhalb der Methode verwendet werden. Nach Beendigung des Methodenaufrufs sind sie ungültig und dürfen nicht weiterhin referenziert werden.
* '''Ausgangsparameter''' ('''out'''), die als Referenzen (Zeiger auf einen Speicherbereich, englisch ''pointer'') übergeben und deren Werte erst innerhalb der Methode ermittelt und zugewiesen werden. Nach Beendigung des Methodenaufrufs sind ihre Werte über die Referenzen abrufbar. Die referenzierten Speicherbereiche müssen vor dem Methodenaufruf allokiert worden sein, aber die Speicherinhalte müssen nicht festgelegt werden, da sie innerhalb der Methode nicht verwendet, sondern bestimmt und zugewiesen werden. Beim Programmieren ist große Sorgfalt darauf zu legen, dass die entsprechenden Zuweisungen innerhalb der Methode in jedem Fall erfolgen, falls die verwendete Programmiersprache dies nicht sowieso vorschreibt und erzwingt.
* '''Durchgangsparameter''' ('''var'''iable), die als Referenzen mit definierten Speicherinhalten übergeben, innerhalb der Methode verwendet und nach einer möglichen Veränderung (respektive '''Var'''iation) während des Methodenaufrufs weiterverwendet werden können. Nach Beendigung des Methodenaufrufs sind ihre aktuellen Werte in den aufrufenden Programmteilen über die Referenzen abrufbar.

===Grundlegende Anweisungen===
Grundsätzlich kommt die strukturierte Programmierung in imperativen Programmiersprachen mit folgenden grundlegenden Anweisungen aus:

* '''Deklaration''', zum Beispiel bei Klassen, Methoden, Variablen oder Konstanten mit einer eindeutigen Signatur:
** '''Modifikatoren''' für die Sichtbarkeit, Verwendbarkeit oder Veränderbarkeit
** '''Bezeichner'''
** Optional (bei Methoden, Funktionen, Prozeduren): '''Parameter''' mit Deklaration der Bezeichner, der Veränderbarkeiten und der Datentypen
** Optional (bei Funktionen): Datentyp des '''Rückgabewertes'''
* '''Blockanweisung''', zum Beispiel BEGIN ... END oder { ... }
* '''Zuweisung''', zum Beispiel a := b - c; (das Gleichheitseichen ist nicht zu verwechseln mit einem Vergleichsoperator)
* '''Aufruf von Unterprogrammen''':
** '''Kommandos''' (ohne Parameter und ohne Rückgabewert)
** '''Prozeduren''' oder Methoden (ohne Rückgabewert)
** '''Funktionen''' (mit Rückgabewert)
* '''Rückgabe''' bei Funktionen, zum Beispiel return x;

Anweisungen werden häufig durch ein reserviertes Zeichen abgeschlossen, wie zum Beispiel mit einem Semikolon.

Das folgende Beispiel zeigt eine Java-Klasse mit 15 grundlegenden Anweisungen:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
// Deklaration der oeffentlichen Klasse &quot;Anweisungen&quot;
public class Anweisungen
// Implementation der Klasse mit einer Blockanweisung &quot;{}&quot;
{	
	// Deklaration der privaten, globalen Klassenvariable &quot;flaeche&quot; vom Datentyp &quot;double&quot;
	private static double flaeche;

	// Deklaration der privaten statischen Methode &quot;kreisflaeche&quot; (Unterprogramm) zur Berechnung der Flaeche eines Kreises mit dem Radius &quot;radius&quot;
	// mit dem Parameter &quot;radius&quot; vom Datentyp &quot;double&quot;
	// und mit einer Gleitkommazahl vom Datentyp &quot;double&quot; als Rueckgabewert
	private static double kreisflaeche (double radius)
	// Implementation der Methode &quot;kreisflaeche&quot; mit einer Blockanweisung &quot;{}&quot;
	{
		// Deklaration der lokalen Variable &quot;ergebnis&quot; vom Datentyp &quot;double&quot;
		double ergebnis;

		// Zuweisung eines Ausdrucks an die Variable &quot;ergebnis&quot; mit dem Zuweisungsoperator &quot;=&quot;
		// Syntax: &quot;Variablenname Zuweisungsoperator Ausdruck Semikolon&quot;
		// Der arithmetische Ausdruck verwendet zwei Multiplikationsoperatoren &quot;*&quot;
		// Die Kreiszahl pi aus der Klasse &quot;java.lang.Math&quot; wird qualifiziert bezeichnet: &quot;java.lang.Math.PI&quot;
		ergebnis = java.lang.Math.PI * radius * radius;

		// Ruecksprunganweisung &quot;return&quot; mit der Rueckgabe der Gleitkommazahl &quot;ergebnis&quot;
		return ergebnis;
	}

	// Deklaration der oeffentlichen statischen Methode main (Hauptprogramm)
	public static void main (java.lang.String [] arguments)
	// Implementation der Methode &quot;main&quot; mit einer Blockanweisung &quot;{}&quot;
	{
		// Deklaration der lokalen Variable &quot;raddurchmesser&quot; vom Datentyp double
		double raddurchmesser;

		// Initialisierung der lokalen Variable &quot;raddurchmesser&quot; durch Zuweisung des konstanten arithmetischen Zahlenausdrucks &quot;1.5&quot;
		raddurchmesser = 1.5;

		// Aufruf der Methode &quot;kreisflaeche&quot; mit dem arithmetischen Ausdruck &quot;raddurchmesser / 2&quot; als Parameter
		// Der Rueckgabewert des Methodenaufrufs ist ein Ausdruck und wird der globalen Klassenvariablen &quot;flaeche&quot; zugewiesen
		flaeche = kreisflaeche (raddurchmesser / 2);

		// Aufruf der Methode &quot;println&quot; mit dem Parameter &quot;flaeche&quot; zur Ausgabe der berechneten Kreisflaeche
		// Die Methode aus der Klasse &quot;java.lang.System&quot; wird qualifiziert bezeichnet: &quot;java.lang.System.out.println&quot;
		java.lang.System.out.println (flaeche);
	}
}
&lt;/syntaxhighlight&gt;

Diese Anweisungen sind in der Reihenfolge des Auftretens:
# '''Deklaration''' der Klasse &quot;Anweisungen&quot;
# '''Blockanweisung''' zur Implementation der Klasse &quot;Anweisungen&quot;
# '''Deklaration''' der Klassenvariable &quot;flaeche&quot;
# '''Deklaration''' der Methode &quot;kreisflaeche&quot; (Unterprogramm)
# '''Blockanweisung''' zur Implementation der Methode &quot;kreisflaeche&quot;
# '''Deklaration''' einer lokalen Variable &quot;ergebnis&quot; in der Methode &quot;kreisflaeche&quot; 
# '''Zuweisung''' an die lokale Variable &quot;ergebnis&quot; in der Methode &quot;kreisflaeche&quot;
# '''Rücksprung''' vom Unterprogramm &quot;kreisflaeche&quot; zum Hauptprogramm &quot;main&quot;
# '''Deklaration''' der Methode &quot;main&quot; (Hauptprogramm)
# '''Blockanweisung''' zur Implementation der Methode &quot;main&quot;
# '''Deklaration''' der lokalen Variable &quot;raddurchmesser&quot;
# '''Zuweisung''' an die lokale Variable &quot;raddurchmesser&quot;
# '''Aufruf''' des Unterprogramms &quot;kreisflaeche&quot;
# '''Zuweisung''' an die globale Klassenvariable &quot;flaeche&quot;
# '''Aufruf''' des Unterprogramms &quot;println&quot;

===Anweisungsstrukturen===
Anweisungesstrukturen setzen sich aus mehreren Anweisungen zusammen. Eine Methode besteht zum Beispiel aus einer Deklaration mit der Definition der Schnittstelle, der unmittelbar eine Blockanweisung mit der Implementierung folgt.

Zu den weiteren elementaren Anweisungsstrukturen für Teilprogramme gehören:

* '''Anweisungsfolgen'''
* '''Kontrollstrukturen'''
** '''Fallunterscheidungen'''
*** bedingte Anweisungen (if - then)
*** einfache Verzweigungen (if - then - else)
*** mehrfache Verzweigungen (switch - case - else)
** '''Wiederholungen (Schleifen)'''
*** kopfgesteuerte Schleifen (while-Schleifen, for-Anweisungen)
*** fußgesteuerte Schleifen (repeat - until, do - while)

Bei jedem elementaren Teilprogramm (respektive jeder Methode, Prozedur oder Funktion, aber auch bei jeder Definition von Datenstrukturen) sollte der Quelltext bequem und vollständig auf einer Bildschirmseite gelesen werden können, ohne dass der Text im Betrachtungsfenster verschoben werden muss. Dabei empfiehlt es sich, Methodenaufrufe und übersichtliche Blockanweisungen zu verwenden, mit denen der Quellcode in Unterabschnitte gegliedert werden kann (Verfeinerung).

Im folgenden Beispiel werden drei geschachtelte Blockanweisungen durch jeweils ein Paar geschweifter Klammern begrenzt. Die äußersten Klammern dienen zur Begrenzung der Implementation der Methode &quot;printMonth&quot;, die inneren Blockanweisungen sind ebenso wie alle anderen Anweisungen nach rechts eingerückt:

 printMonth ()
 {
    const int NumberOfWeekdays ← 7
    const int LastDay ← 31
 
    int column
    int day ← 1
 
    while (day &lt;= LastDay)
    {
       printInt (day)
       column ← day modulo NumberOfWeekdays
       if (column = 0)
       {
          printLine ()
       }
       day ← day + 1
    }
 }

Wächst die Länge einer Methode zu sehr an, können und sollen einzelne Blockanweisungen unter Berücksichtigung der entsprechenden Übergabeparameter in eigene, aufzurufende Methoden ausgelagert werden, wodurch der Code geringfügig länger, aber wesentlich besser verständlich wird:

 optionalNewLine (int day)
 {
    const int NumberOfWeekdays ← 7
 
    int column ← day modulo NumberOfWeekdays
 
    if (column = 0)
    {
       printLine ()
    }
 }
 
 void printMonth ()
 {
    const int LastDay ← 31
    int day ← 1
 
    while (day &lt;= LastDay)
    {
       printInt (day)
       optionalNewLine (day)
       day ← day + 1
    }
 }

Hierbei ist es hilfreich, wenn die aufzurufenden Programmteile vor ihrer ersten Verwendung implementiert werden, im Quelltext also zuerst definiert (also deklariert und implementiert) und erst weiter unten benutzt (respektive aufgerufen oder referenziert) werden.

Häufig wird behauptet, dass die Performanz der ausgeführten Programme durch die Aufteilung in solche Unterprogramme leiden würde, da die zahlreichen Aufrufe und Rücksprünge Rechenzeit und Speicherressourcen kosten. In den allermeisten Fällen ist dies auf modernen Rechenmaschinen jedoch zu vernachlässigen. Bei den meisten Anwendungen wird am Speicherbedarf und an der Rechenzeit nicht bemerkt werden können, ob ein strukturiertes oder ein unstrukturiertes Programm vorliegt. Bestenfalls bei extrem rechenintensiven Aufgaben (wie zum Beispiel beim sogenannten &quot;number crunching&quot; (&quot;Zahlenfressen&quot;), bei Monte-Carlo-Simulationen oder Big-Data-Analysen) kann dies bei den extrem häufig aufgerufenen Unterprogrammen einen nennenswerten Effekt haben. Hierbei kann eine wohlstrukturierte Parallelisierung von Programmen oder die Ausgliederung von Rechenaufgaben in spezialisierte Hardware (Graphikprozessoren, digitale Signalprozessoren (DSP), Field Programmable Gate Arrays (FPGA) oder Quantencomputer) wesentlich zu einer Beschleunigung der Programmabläufe beitragen.

Eine Software, die von den Anwendern als zu langsam empfunden wird, ist meist nur schlecht programmiert. Ferner kann gar nicht häufig genug betont werden, dass die Entwicklung und Wartung unstrukturierter Programme erheblich länger dauert und wesentlich fehleranfälliger ist.

=== Schrittweise Verfeinerung ===
Die Implementierung von Software geschieht in der Regel vom Großen ins Kleine. Grob entworfene Anweisungsfolgen und Datenstrukturen werden dabei im Rahmen einer '''schrittweisen Verfeinerung''' immer genauer den Anforderungen angepasst.

Die folgenden Aspekte sind bei der schrittweisen Verfeinerung nach wie vor typisch:&lt;ref&gt;Niklaus Wirth: [http://sunnyday.mit.edu/16.355/wirth-refinement.html Program Development by Stepwise Refinement], Communications of the Association for Computing Machinery, Band 14, Nummer 4, April 1971, Seiten 221 bis 227&lt;/ref&gt;

* In jedem Schritt wird eine Aufgabe (ein Programmteil / ein Datensatz) in Unteraufgaben (in Unterprogramme / in Unterdatensätze) aufgeteilt.
* Der Grad der Abkapselung von Unteraufgaben bestimmt, wie leicht oder schwer Programme und Datenstrukturen angepasst oder übertragen werden können.
* Die Notation für Programme und Daten sollte stets so weit wie möglich sowohl der natürlichen Sprache und der Natur der Sache als auch der Hardware und den Software-Werkzeugen angepasst sein.
* Die Berücksichtigung der Kriterien Laufzeiteffizienz und Speichereffizienz sowie Klarheit und Regelmäßigkeit der Strukturen ist in allen Entwicklungsschritten bis zur Fertigstellung relevant.
* Es muss immer erwogen werden, dass ein korrekt funktionierendes Programm durch eine bessere Version ersetzt werden kann und dass frühere Entscheidungen aus allen Entwicklungsschritten revidiert werden können.
* Die Entwicklung und Wartung guter Programme ist alles andere als trivial, wird aber durch den Einsatz streng strukturierter Programmiersprachen deutlich erleichtert.

== Datenstrukturen ==
Nicht nur der Programmcode, sondern auch die zu verarbeitenden Daten müssen gut strukturiert werden, um die Entwicklungszeiten zu reduzieren, die Qualität der Programme zu erhöhen und die Wartung der Quelltexte zu erleichtern. Gehören zum Beispiel ganz verschiedene Attribute zu einer Sache, sollen diese Attribute zu einer Datenstruktur zusammengefasst werden. Datenstrukturen können auch geschachtelt eingesetzt werden, so dass sehr umfangreiche und komplexe Datenstrukturen abgebildet werden können.

===Aufzählungen===
Eine '''Aufzählung''' (englisch &quot;enumeration&quot;) wird verwendet, wenn bestimmte Eigenschaften von Datenstrukturen abzählbar und endlich sind. Mit diesen thematisch zusammengehörigen Aufzählungen können im Programmtext an allen entsprechenden Stellen statt abstrakt zugeordneter Zahlen konkret zugeordnete symbolische Konstanten mit sprechenden und selbsterklärenden Bezeichnern verwendet werden. Manche Programmiersprachen bieten dafür sogar die Möglichkeit an, dafür eigene Datentypen zu erstellen, in vielen Programmiersprachen wird das jedoch auf sehr simple Weise mit ganzzahligen Basisdaten nachgebildet.

Im folgenden Beispiel wird erläutert, wie verschiedene Kalendersysteme als Aufzählung behandelt werden können. Hierbei werden die folgenden vier Kalendersysteme zu Auswahl:
* Jüdisches Kalendersystem, Kennzahl = 1
* Julianisches Kalendersystem, Kennzahl = 2
* Gregorianisches Kalendersystem, Kennzahl = 3
* Islamisches Kalendersystem, Kennzahl = 4

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Kalendersystem
{
   public final static long JUEDISCH = 1; // Lunisolarkalender
   public final static long JULIANISCH = 2; // Solarkalender bis 4. Oktober 1582 (Donnerstag)
   public final static long GREGORIANISCH = 3; // Solarkalender seit 15. Oktober 1582 (Freitag)
   public final static long ISLAMISCH = 4; // Lunarkalender
}
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;oberon2&quot;&gt;
(* Programmiersprache Oberon *)

MODULE Kalendersystem;

   CONST
      JUEDISCH = 1; (* Lunisolarkalender *)
      JULIANISCH = 2; (* Solarkalender bis 4. Oktober 1582 (Donnerstag) *)
      GREGORIANISCH = 3; (* Solarkalender seit 15. Oktober 1582 (Freitag) *)
      ISLAMISCH = 4; (* Lunarkalender *)
&lt;/syntaxhighlight&gt;

In manchen, meist älteren Programmiersprachen gibt es explizite Aufzählungstypen, bei denen der Compiler automatisch die dazugehörigen ganzen Kennzahlen festlegt, ohne dass diese im Quelltext auftauchen, weil ausschließlich die symbolischen Konstanten aus der Deklaration des Aufzählungstyps verwendet werden. Variablen des Datentyps &quot;Kalendersystem&quot; im folgenden Beispiel dürfen nur die vier zwischen den runden Klammern explizit angegebenen respektive aufgezählten symbolischen Konstanten und keine beliebigen ganzen Zahlen verwenden:

&lt;syntaxhighlight lang=&quot;modula2&quot;&gt;
(* Programmiersprache Modula-2 *)

   TYPE Kalendersystem = (JUEDISCH, JULIANISCH, GREGORIANISCH, ISLAMISCH);
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;cpp&quot;&gt;
/* Programmiersprache C++ */

   enum Kalendersystem = {JUEDISCH, JULIANISCH, GREGORIANISCH, ISLAMISCH};
&lt;/syntaxhighlight&gt;

===Verbunde===
Gehören mehrere verschiede Attribute zu einer Datenstruktur, spricht man auch von einem '''Verbund'''. Diese Datenstrukturen werden je nach Programmiersprache häufig &quot;struct&quot; oder &quot;record&quot; genannt. Alle Attribute können und müssen über einen zentralen Zugang adressiert werden. Dies soll im Folgenden anhand der Datenstruktur &quot;Kalenderdatum&quot; beispielhaft erläutert werden.

Ein Kalenderdatum möge aus einem '''Tag''', einem '''Monat''', einem '''Jahr''' und einem '''Kalendersystem''' bestehen:

Alle vier Attribute werden in vier unabhängigen Datenfeldern gespeichert. Im vorliegenden Beispiel sind zwar alle vier Datenfelder vom Basisdatentyp &quot;ganze Zahl&quot; (&quot;long&quot; oder &quot;INTEGER&quot;), die Bedeutung und die gültige Zahlenbereiche unterscheiden sich jedoch:
* Tag: ganze Zahl im Intervall [1..31]
* Monat: ganze Zahl im Intervall [1..12]
* Jahr: ganze Zahl
* Kalendersystem. ganze Zahl des Aufzählungstyps &quot;Kalendersystem&quot; mit den vier Optionen (JUEDISCH, JULIANISCH, GREGORIANISCH, ISLAMISCH)

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Kalenderdatum
{
   // Instanzvariablen
   private long tag;
   private long monat;
   private long jahr;
   private long kalendersystem;

   public Kalenderdatum (long tag, long monat, long jahr, long kalendersystem) // Konstruktor zur Initialisierung von Instanzvariablen der Klasse Kalenderdatum
   {
      this.tag = tag;
      this.monat = monat;
      this.jahr = jahr;
      this.kalendersystem = kalendersystem;
   }

   public static void main (java.lang.String [] argumente) // main-Methode der Klasse &quot;Kalenderdatum&quot;
   {
      Kalenderdatum kalenderdatum = new Kalenderdatum (10, 4, 2023, Kalendersystem.GREGORIANISCH); // Eine neue Instanz wird erzeugt und durch den Aufruf des Konstruktors initialisiert
      java.lang.System.out.print (kalenderdatum.tag);
      java.lang.System.out.print (&quot;.&quot;);
      java.lang.System.out.print (kalendekalenderdatum.monat);
      java.lang.System.out.print (&quot;.&quot;);
      java.lang.System.out.print (kalenderdatum.jahr);
      java.lang.System.out.println (); // Zeilenumbruch
   }
}
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;oberon2&quot;&gt;
(* Programmiersprache Oberon *)

   IMPORT Out; (* Import des Moduls &quot;Out&quot; für die Textausgabe *)

   TYPE Kalenderdatum =
   RECORD
      tag: INTEGER;
      monat: INTEGER;
      jahr: INTEGER;
      kalendersystem: INTEGER;
   END;

   VAR kalenderdatum; (* Variable *)

   BEGIN
      kalenderdatum.tag = 10;
      kalenderdatum.monat = 4;
      kalenderdatum.jahr = 2023;
      kalenderdatum.kalendersystem = Kalendersystem.GREGORIANISCH;

      Out.Int (kalenderdatum.tag);
      Out.String (&quot;.&quot;);
      Out.Int (kalenderdatum.monat);
      Out.String (&quot;.&quot;);
      Out.Int (kalenderdatum.jahr);
      Out.Ln; (* Zeilenumbruch *)
   END;
&lt;/syntaxhighlight&gt;

Die Textausgabe lautet jeweils:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
23.4.2023
&lt;/syntaxhighlight&gt;

===Arrays===
In Arrays werden endlich viele und abzählbare Elemente eines bestimmten Datentyps in einer geordneten Reihe gespeichert. Die einzelnen Elemente können über einen ganzzahligen Index angesprochen werden. Der niedrigste Index ist meistens der Index Null, und dieser zeigt auf die erste Speicheradresse des Arrays. Da alle Elemente vom gleichen Datentyp sind, wird für jedes Element immer der gleiche Speicherplatz benötigt. Elemente mit komplexen Datentypen, werden nicht direkt im Array gespeichert, sondern dieses enthält als Verweise Zeiger mit den Speicheradressen der Inhalte der Elemente. Wenn der Speicherbedarf für ein Element (oder dessen Zeiger) &lt;math&gt;S_E&lt;/math&gt; Bytes beträgt und das Array insgesamt &lt;math&gt;N&lt;/math&gt; Elemente hat, dann berechnet sich der Speicherbedarf &lt;math&gt;S&lt;/math&gt; für das ganze Array aus dem Produkt:

&lt;math&gt;S = S_E \cdot N&lt;/math&gt;

Die Speicheradresse &lt;math&gt;A_i&lt;/math&gt; des i-ten Elements des Arrays berechnet sich dann mit einfacher und effizient ausführbarer Arithmetik aus der Speicheradresse des Arrays &lt;math&gt;A&lt;/math&gt;, dem Speicherbedarf für ein Element (oder dessen Zeiger) &lt;math&gt;S_E&lt;/math&gt; und dem Index &lt;math&gt;i&lt;/math&gt; :

&lt;math&gt;A_i = A + S_E \cdot i&lt;/math&gt; mit &lt;math&gt;0 \le i &lt; N&lt;/math&gt;

Die Speicheradresse des ersten Elements mit dem Index Null &lt;math&gt;A_0&lt;/math&gt; ist also stets identisch mit der Speicheradresse des Arrays &lt;math&gt;A&lt;/math&gt;.

Im folgenden Beispiel wird ein Array mit acht zufällig verteilten Gleitkommazahlen dargestellt, bei denen jede Gleitkommazahl einen Speicherplatz von '''8&amp;nbsp;Bytes''' (Datentyp '''double''' mit 64&amp;nbsp;Bits) belegt:

{| class=&quot;wikitable&quot;
|'''Länge des Arrays &lt;math&gt;N&lt;/math&gt;'''
|'''Speicheradresse des Arrays (dezimal) &lt;math&gt;A&lt;/math&gt;'''
|'''Speicheradresse des Arrays (hexadezimal) &lt;math&gt;A&lt;/math&gt;'''
|'''Speicherbedarf für eine Gleitkommazahl in Bytes &lt;math&gt;S_E&lt;/math&gt;'''
|-
|8
|10000000
|98 96 80
|8
|-
|'''Index &lt;math&gt;i&lt;/math&gt;'''
|'''Speicheradresse des Elements im Array (dezimal) &lt;math&gt;A_i = A + S_E \cdot i&lt;/math&gt;'''
|'''Speicheradresse des Elements im Array (hexadezimal) &lt;math&gt;A_i = A + S_E \cdot i&lt;/math&gt;'''
|'''Gespeicherter Inhalt des Elements (Gleitkommazahl)'''
|-
|0
|10000000
|98 96 80
|678,1495238
|-
|1
|10000008
|98 96 88
|317,4610959
|-
|2
|10000016
|98 96 90
|574,3131347
|-
|3
|10000024
|98 96 98
|673,9323679
|-
|4
|10000032
|98 96 A0
|854,6637912
|-
|5
|10000040
|98 96 A8
|764,4845853
|-
|6
|10000048
|98 96 B0
|335,5146962
|-
|7
|10000056
|98 96 B8
|545,0787382
|}

Das folgende Java-Programm implementiert ein solches Array mit acht Gleitkommazahlen:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Array
{
	
	// Klassenvariable zufallszahlen als Array mit acht Gleitkommazahlen
   private static double zufallszahlen [] = new double [8];

   public static void setzeZufallszahlen (long startwert) // Methode zur Bestimmung aller Gleitkommazahlen
   {
	   // Variable zufallszahl
	   java.util.Random zufallszahl = new java.util.Random (startwert); // Startwert für erste Zufallszahl

	   long anzahl = zufallszahlen.length;
	   int zaehler = 0; // der Index von Arrays darf nicht vom Datentyp long sein
	   while (zaehler &lt; anzahl)
	   {
		   zufallszahlen [zaehler] = zufallszahl.nextDouble ();
		   zaehler++;
	   }
   }

   public static void ausgabeZufallszahlen () // Methode zur Ausgabe aller Gleitkommazahlen
   {
	   long anzahl = zufallszahlen.length;
	   int zaehler = 0; // der Index von Arrays darf nicht vom Datentyp long sein
	   while (zaehler &lt; anzahl)
	   {
		   java.lang.System.out.println (zufallszahlen [zaehler]);
		   zaehler++;
	   }
   }

   public static void main (java.lang.String [] argumente) // Hauptprogramm &quot;main&quot; zum Aufruf der beiden Unterprogramme
   {
	   setzeZufallszahlen (1000); // Aufruf des Unterprogramms setzeZufallszahlen mit dem Parameter 1000 als Startwert
	   ausgabeZufallszahlen (); // Aufruf des Unterprogramms ausgabeMonatsname ohne Parameter
   }
}&lt;/syntaxhighlight&gt;

Mit dem Aufruf des Hauptprogramms ''main'' erfolgt die Ausgabe von acht Pseudozufallszahlen:

&lt;syntaxhighlight&gt;
0.7101849056320707
0.574836350385667
0.9464192094792073
0.039405954311386604
0.4864098780914311
0.4457367367074283
0.6008140654988429
0.550376169584217
&lt;/syntaxhighlight&gt;

Im nächsten Beispiel mit einem Array für die zwölf Monatsnamen ist der Datentyp eines Arrayelements jeweils eine Zeichenkette, die je nach ihrer Länge verschieden große Speicherbereiche belegen:

{| class=&quot;wikitable&quot;
|'''Länge des  Arrays'''
|'''Speicheradresse des Arrays'''
|'''Speicherbedarf für eine Speicheradresse'''
|'''Speicherbedarf für ein Zeichen'''
|
|
|-
|13
|10000000
|4
|2
|
|
|-
|Index
|'''Speicheradresse des Elements im Array'''
|'''Gespeicherter Inhalt des Elements (Speicheradresse)'''
|'''Länge der Zeichenkette'''
|'''Speicherbedarf der Zeichenkette'''
|'''Gespeicherter Inhalt des Elements (Zeichenkette)'''
|-
|0
|10000000
|20000000
|8
|16
|&quot;deutsch&quot;
|-
|1
|10000004
|20000016
|7
|14
|&quot;Januar&quot;
|-
|2
|10000008
|20000030
|8
|16
|&quot;Februar&quot;
|-
|3
|10000012
|20000046
|5
|10
|&quot;März&quot;
|-
|4
|10000016
|20000056
|6
|12
|&quot;April&quot;
|-
|5
|10000020
|20000068
|4
|8
|&quot;Mai&quot;
|-
|6
|10000024
|20000076
|5
|10
|&quot;Juni&quot;
|-
|7
|10000028
|20000086
|5
|10
|&quot;Juli&quot;
|-
|8
|10000032
|20000096
|7
|14
|&quot;August&quot;
|-
|9
|10000036
|20000110
|10
|20
|&quot;September&quot;
|-
|10
|10000040
|20000130
|8
|16
|&quot;Oktober&quot;
|-
|11
|10000044
|20000146
|9
|18
|&quot;November&quot;
|-
|12
|10000048
|20000164
|9
|18
|&quot;Dezember&quot;
|}

In den folgenden Beispielen in der Programmiersprache werden die zwölf Monatsnamen in Arrays mit Zeichenketten gespeichert. Hierzu wird die Sprache der Monatsnamen im ersten Arrayfeld mit dem Index 0 und die zwölf Monatsnamen in den folgenden Arrayfeldern mit den Indizes 1 bis 12 gespeichert:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Monatsnamen
{
   // Klassenvariable
   private static java.lang.String monatsnamen [] = {&quot;deutsch&quot;,
      &quot;Januar&quot;, &quot;Februar&quot;, &quot;März&quot;, &quot;April&quot;, &quot;Mai&quot;, &quot;Juni&quot;, &quot;Juli&quot;, &quot;August&quot;, &quot;September&quot;, &quot;Oktober&quot;, &quot;November&quot;, &quot;Dezember&quot;};

   public static void ausgabeMonatsname (int monat) // Methode zur Textausgabe von Monatsnamen
   {
      java.lang.System.out.println (monatsnamen [monat]);
   }

   public static void main (java.lang.String [] argumente) // Hauptprogramm &quot;main&quot; zum Aufruf der Methode ausgabeMonatsname
   {
      ausgabeMonatsname (1); // Aufruf des Unterprogramms ausgabeMonatsname mit dem Parameter 1
   }
}
&lt;/syntaxhighlight&gt;

Mit dem Aufruf des Hauptprogramms ''main'' erfolgt die Ausgabe mit dem ersten Monatsnamen:

&lt;syntaxhighlight&gt;
Januar
&lt;/syntaxhighlight&gt;

In einigen Programmiersprachen muss die Größe der Array vor der Initialisierung festgelegt werden, und die Zuordnung zwischen den Indizes und den Arrayfeldern ist dann auch bei der Initialisierung explizit erkennbar:

&lt;syntaxhighlight lang=&quot;oberon2&quot;&gt;
(* Programmiersprache Component Pascal *)

MODULE Monatsnamen;

   IMPORT Out; (* Import des Moduls &quot;Out&quot; für die Textausgabe *)

   TYPE Monatsnamen = POINTER TO ARRAY OF ARRAY OF CHAR;

   VAR monatsnamen: Monatsnamen;

   PROCEDURE InittialisiereMonatsnamen (); (* Prozedur zur Initialisierung von Monatsnamen *)
   BEGIN
      NEW (monatsnamen, 13, 10); (* Reservierung von 13 Zeichenketten mit je 10 Zeichen) *)
      monatsnamen [0] := &quot;deutsch&quot;;
      monatsnamen [1] := &quot;Januar&quot;;
      monatsnamen [2] := &quot;Februar&quot;;
      monatsnamen [3] := &quot;März&quot;;
      monatsnamen [4] := &quot;April&quot;;
      monatsnamen [5] := &quot;Mai&quot;;
      monatsnamen [6] := &quot;Juni&quot;;
      monatsnamen [7] := &quot;Juli&quot;;
      monatsnamen [8] := &quot;August&quot;;
      monatsnamen [9] := &quot;September&quot;;
      monatsnamen [10] := &quot;Oktober&quot;;
      monatsnamen [11] := &quot;November&quot;;
      monatsnamen [12] := &quot;Dezember&quot;;
   END InittialisiereMonatsnamen;

   PROCEDURE AusgabeMonatsname (monat: INTEGER); (* Prozedur zur Textausgabe von Monatsnamen *)
   BEGIN
      Out.String (monatsnamen [monat]);
   END AusgabeMonatsname;

   PROCEDURE Hauptprogramm*;
   BEGIN
      InittialisiereMonatsnamen (); (* Initialisierung beim Laden des Moduls &quot;Monatsnamen&quot; *)
      AusgabeMonatsname (1); (* Aufruf des Unterprogramms AusgabeMonatsname mit dem Parameter 1 *)
   END Hauptprogramm;

END Monatsnamen.
&lt;/syntaxhighlight&gt;

Durch den Aufruf von ''Monatsnamen.Hauptprogramm'' erfolgt die Ausgabe mit dem ersten Monatsnamen:

&lt;syntaxhighlight&gt;
Januar
&lt;/syntaxhighlight&gt;

Arrays können mehrdimensional gestaltet werden. Um zum Beispiel zwei Sprachen mit Monatsnamen zu speichern, kann eine weitere Dimension mit einem Index für die gewünschte Sprache implementiert werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Monatsnamen
{
   // Konstanten für Sprachaufzählung
   public final static int DEUTSCH = 0;
   public final static int ENGLISCH = 1;

   // Klassenvariablen
   private static java.lang.String monatsnamen [] [] =
   {
      {&quot;deutsch&quot;, &quot;Januar&quot;, &quot;Februar&quot;, &quot;März&quot;, &quot;April&quot;, &quot;Mai&quot;, &quot;Juni&quot;, &quot;Juli&quot;, &quot;August&quot;, &quot;September&quot;, &quot;Oktober&quot;, &quot;November&quot;, &quot;Dezember&quot;},
      {&quot;english&quot;, &quot;January&quot;, &quot;February&quot;, &quot;March&quot;, &quot;April&quot;, &quot;May&quot;, &quot;June&quot;, &quot;July&quot;, &quot;August&quot;, &quot;September&quot;, &quot;October&quot;, &quot;November&quot;, &quot;December&quot;}
   };

   public static void ausgabeMonatsname (int monat) // Methode zur Textausgabe von Monatsnamen
   {
      java.lang.System.out.println (&quot;Deutschsprachiger Monatsname = &quot; + monatsnamen [DEUTSCH] [monat]);
      java.lang.System.out.println (&quot;Englischsprachiger Monatsname = &quot; + monatsnamen [ENGLISCH] [monat]);
   }

   public static void main (java.lang.String [] argumente) // Hauptprogramm &quot;main&quot; zum Aufruf der Methode ausgabeMonatsname
   {
      ausgabeMonatsname (2);
   }
}
&lt;/syntaxhighlight&gt;

Mit dem Aufruf des Hauptprogramms ''main'' erfolgt die Ausgabe mit den beiden zweiten Monatsnamen:

&lt;syntaxhighlight&gt;
Deutschsprachiger Monatsname = Februar
Englischsprachiger Monatsname = February
&lt;/syntaxhighlight&gt;

Bei anderen Programmiersprachen ist durch die obligatorische Verwendung von symbolischen Konstanten (im Beispiel unten &quot;DEUTSCH&quot; und &quot;ENGLISCH&quot;) bei jeder erforderlichen, also auch bei allen initialen Zuweisungen zu Array-Elementen übersichtlich und klar erkennbar, welches Feld angesprochen wird:

&lt;syntaxhighlight lang=&quot;oberon2&quot;&gt;
(* Programmiersprache Component Pascal *)

MODULE Monatsnamen;

   IMPORT Out; (* Import des Moduls &quot;Out&quot; für die Textausgabe *)

   CONST
      DEUTSCH = 0;
      ENGLISCH = 1;

   TYPE Monatsnamen = POINTER TO ARRAY OF ARRAY OF ARRAY OF CHAR;

   VAR monatsnamen: Monatsnamen;

   PROCEDURE InittialisiereMonatsnamen ();  (* Prozedur zur Initialisierung von Monatsnamen *)
   BEGIN
      NEW (monatsnamen, 2, 13, 10); (* Reservierung von 2 mal 13 Zeichenketten mit je 10 Zeichen) *)
      monatsnamen [DEUTSCH, 0] := &quot;deutsch&quot;;
      monatsnamen [DEUTSCH, 1] := &quot;Januar&quot;;
      monatsnamen [DEUTSCH, 2] := &quot;Februar&quot;;
      monatsnamen [DEUTSCH, 3] := &quot;März&quot;;
      monatsnamen [DEUTSCH, 4] := &quot;April&quot;;
      monatsnamen [DEUTSCH, 5] := &quot;Mai&quot;;
      monatsnamen [DEUTSCH, 6] := &quot;Juni&quot;;
      monatsnamen [DEUTSCH, 7] := &quot;Juli&quot;;
      monatsnamen [DEUTSCH, 8] := &quot;August&quot;;
      monatsnamen [DEUTSCH, 9] := &quot;September&quot;;
      monatsnamen [DEUTSCH, 10] := &quot;Oktober&quot;;
      monatsnamen [DEUTSCH, 11] := &quot;November&quot;;
      monatsnamen [DEUTSCH, 12] := &quot;Dezember&quot;;

      monatsnamen [ENGLISCH, 0] := &quot;english&quot;;
      monatsnamen [ENGLISCH, 1] := &quot;January&quot;;
      monatsnamen [ENGLISCH, 2] := &quot;February&quot;;
      monatsnamen [ENGLISCH, 3] := &quot;March&quot;;
      monatsnamen [ENGLISCH, 4] := &quot;April&quot;;
      monatsnamen [ENGLISCH, 5] := &quot;May&quot;;
      monatsnamen [ENGLISCH, 6] := &quot;June&quot;;
      monatsnamen [ENGLISCH, 7] := &quot;July&quot;;
      monatsnamen [ENGLISCH, 8] := &quot;August&quot;;
      monatsnamen [ENGLISCH, 9] := &quot;September&quot;;
      monatsnamen [ENGLISCH, 10] := &quot;October&quot;;
      monatsnamen [ENGLISCH, 11] := &quot;November&quot;;
      monatsnamen [ENGLISCH, 12] := &quot;December&quot;;
   END InittialisiereMonatsnamen;

   PROCEDURE AusgabeMonatsname (monat: INTEGER); (* Prozedur zur Textausgabe von Monatsnamen *)
   BEGIN
      Out.String (&quot;Sprache = &quot; + monatsnamen [DEUTSCH, 0] + &quot;: &quot; + monatsnamen [DEUTSCH, monat]);
      Out.Ln;
      Out.String (&quot;Sprache = &quot; + monatsnamen [ENGLISCH, 0] + &quot;: &quot; + monatsnamen [ENGLISCH, monat]);
      Out.Ln;
   END AusgabeMonatsname;

   PROCEDURE Hauptprogramm*;
   BEGIN
      InittialisiereMonatsnamen (); (* Initialisierung beim Laden des Moduls &quot;Monatsnamen&quot; *)
      AusgabeMonatsname (2);
   END Hauptprogramm;

END Monatsnamen.
&lt;/syntaxhighlight&gt;

Durch den Aufruf von ''Monatsnamen.Hauptprogramm'' erfolgt die Ausgabe mit den beiden zweiten Monatsnamen:

&lt;syntaxhighlight&gt;
Sprache = deutsch: Februar
Sprache = english: February
&lt;/syntaxhighlight&gt;

Die Verwendung von Indizes außerhalb der deklarierten oder angeforderten Array-Größen verursachen in streng strukturierten Programmiersprachen zur Laufzeit einen Programmabbruch. Bei sorgfältiger Programmierung ist deswegen darauf zu achten, dass nur gültige Indizes zur Anwendung kommen können. In schlecht strukturierten Programmiersprachen wie C oder C++ werden die Indizes von Arrays in der Regel nicht automatisch geprüft, so dass unbemerkt auf ungültige Speicheradressen zugegriffen werden kann und bei entsprechenden Angriffen Daten verfälscht und schadhafter Binärcode in die Programme eingeschleust sowie zur Ausführung gebracht werden kann.

==Kontrollstrukturen==
Kontrollstrukturen dienen dazu, den Programmablauf in wohlstrukturierter Weise im Sinne eines Algorithmus zu beeinflussen. Hierfür können '''Unterprogramme''' aufgerufen, '''Fallunterscheidungen''' vorgenommen oder Programmteile mehrfach durchlaufen werden ('''Schleifen''').

===Sprunganweisungen===
Sprünge an andere Programmstellen ergeben sich inhärent beim Aufruf von Unterprogrammen. Geschieht ein solcher Sprung durch eine explizite Sprunganweisung im Programmcode, wie zum Beispiel mit Goto-, Break- oder Continue-Anweisungen, ist dies unstrukturiert und im Übrigen auch völlig überflüssig, denn Programme mit Sprunganweisungen können immer und ohne großen Aufwand durch Kontrollstrukturen, also mit Hilfe von '''Unterprogrammen''', '''Schleifen''' oder '''Fallunterscheidungen''', gestaltet werden.

Explizite Sprunganweisungen stellen eine &quot;Programmiertechnik mit dem Holzhammer&quot; und wegen der daraus resultierenden verschlungenen Pfade während des Programmablaufs einen sogenannten '''Spaghetti-Code''' dar. Im Quellcode ist der Programmablauf nicht mehr ohne weiteres nachvollziehbar, beispielsweise bei der Untersuchung, von welchen Stellen des Programms an welche anderen Stellen gesprungen werden soll oder worden sein kann.

Im Falle der Switch-Case-Anweisung handelt es sich bei der in manchen Programmiersprachen verwendeten Break-Anweisung eigentlich nicht um eine Sprunganweisung, sondern um einen obligatorischen Begrenzer (englisch: ''delimiter''), der zur Herstellung der Programmstruktur erforderlich ist. In einigen Programmiersprachen darf dieser Begrenzer (''break'') jedoch weggelassen werden, um den Code in bestimmten aber vereinzelten Fällen etwas kürzer gestalten zu können, was aber gleichzeitig und unabdingbar zu unstrukturierter Programmierung führt, die Programmabläufe unübersichtlich macht und dazu führen kann, dass die Programme gegebenenfalls nur noch schwierig nachzuvollziehen und zu warten sind.

====Unterprogramme====
[[Datei:Unterprogrammaufruf.png|mini|rechts|hochkant=1|Von der Hauptroutine &quot;Procedure main&quot; eines gestarteten Programms wird nach Ausführung der Anweisungen &quot;Instructions&amp;nbsp;1&quot; ein Unterprogramm &quot;Procedure sub&quot; aufgerufen (&quot;Call sub&quot;), und der Programmablauf wird mit den dortigen Anweisungen &quot;Instructions&quot; fortgeführt. Wenn die letzte Anweisung &quot;Return&quot; des Unterprogramms erreicht worden ist, wird in das Hauptprogramm zurückgesprungen und der Programmablauf an der Stelle direkt hinter dem Aufruf des Unterprogramms mit den Anweisungen &quot;Instructions&amp;nbsp;2&quot; fortgesetzt.]]

Eine besonders häufig angewendete Programmiertechnik ist der Aufruf von Unterprogrammen. Unterprogramme stellen im Sinne des Quelltextes eines Programmes üblicherweise Prozeduren, Methoden oder Funktionen dar. Mit der Programmanweisung des Aufrufs kann der Programmablauf zum entsprechenden Unterprogramm verzweigt werden. Hierbei können in der Regel auch Parameter übergeben werden, um zwischen dem aufrufenden Programmteil und dem Unterprogramm Daten austauschen zu können. Ist das Unterprogramm vollständig abgearbeitet worden, wird der Programmablauf hinter der Stelle des Unterprogrammaufrufs fortgesetzt.

Unterprogramme können mehrfach und von allen Stellen des Programcodes aufgerufen werden, in dem das Unterprogramm sichtbar ist. Die Unterscheidung zwischen Prozeduren und Methoden ist nicht einheitlich. Etliche Programmiersprachen verwenden kategorisch nur einen der beiden Begriffe. Hierbei kann zwischen traditionellen (statischen) Prozeduren und objektorientierten (typengebunden oder dynamischen) Prozeduren unterschieden werden. Letztere werden als Methoden einer Klasse oder aber auch als typengebundene Prozeduren eines Programmoduls bezeichnet.

====Rücksprunganweisungen====
Nach Ablauf des Unterprogramms kann ein Rückgabewert an das aufrufende Programm zurückgegeben werden, der im aufrufenden Programmteil dann zur Verfügung steht und als Ausdruck zum Beispiel an eine Variable zugewiesen werden kann. In diesem Fall wird ein Unterprogramm auch '''Funktion''' genannt, da als Ergebnis des Unterprogrammaufrufs ein Funktionswert berechnet wurde und dann zurückgegeben wird.

Jedes Unterprogramm hat daher exakt eine Rücksprunganweisung (oft mit dem Schlüsselwort '''return''' gekennzeichnet), die logischerweise die letzte Anweisung sein muss, damit alle Anweisungen vorher durchgeführt werden können. Der Rücksprung erfolgt immer zur Stelle des Unterprogrammaufrufs, wo die Programmausführung anschließend fortgeführt wird.

Hat das Unterprogramm keinen Rückgabewert, der an den aufrufenden Programmteil zurückgegeben werden muss, wird in vielen Programmiersprachen auf eine explizite Rücksprunganweisung verzichtet; in diesem Fall wird sie also implizit ausgeführt. Ist das Hauptprogramm vollständig durchlaufen, wird das Programm nach dessen Rücksprunganweisung beendet, und die Kontrolle an das Laufzeitsystem oder das Betriebssystem zurückgegeben, von wo aus das Hauptprogramm aufgerufen worden war.

Mehrfache und insbesondere vorzeitige Rücksprunganweisungen in einem Unterprogramm sind unstrukturiert und daher zu unterlassen, auch wenn die Programmiersprache dies nicht zwingend fordert. Vorzeitige Unterprogrammabbrüche ('''Break'''-Anweisungen) verhindern, dass nachfolgende Programmsequenzen ausgeführt werden können, obwohl sie bei einer Ausführung das Ergebnis für den Rückgabewert beeinflussen würden. Dies kann zur Verwirrung führen, weil das Unterprogramm bei einer Überprüfung oder einer Analyse immer vollständig auf potentielle vorzeitige Unterprogrammabbrüche durchsucht werden muss.

Der folgende unstrukturierte Java-Code, der den in der Variablen '''ergebnis''' gespeicherten Wert vor dessen Rückgabe als Text ausgeben soll, verdeutlicht dies:

&lt;syntaxhighlight lang=&quot;java&quot;&gt;
private static double unterprogramm (double parameter)
{
   double ergebnis = parameter;
   boolean ganzzahlig = (parameter % 1 == 0);
   if (ganzzahlig) return ergebnis;
   ergebnis = ergebnis + 1;
   java.lang.System.out.println (&quot;Ergebnis = &quot; + ergebnis);
   return ergebnis;
}
&lt;/syntaxhighlight&gt;

Die Erhöhung des Wertes der Variablen '''ergebnis''' sowie die Textausgabe mit dem Aufruf der Methode '''println''' unmittelbar vor der Rücksprunganweisung erfolgen wegen der beiden vorhandenen Rücksprunganweisungen nur, wenn der Wert des Parameters '''parameter''' nicht ganzzahlig ist. Demzufolge erzeugen die folgenden beiden Unterprogrammaufrufe

&lt;syntaxhighlight lang=&quot;java&quot;&gt;
   unterprogramm (0);
   unterprogramm (0.5);
&lt;/syntaxhighlight&gt;

die Textausgabe:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
Ergebnis = 1.5
&lt;/syntaxhighlight&gt;

Dieses formal korrekte, aber unerwünschte Verhalten wird nur nachvollziehbar, wenn der gesamte Code des Unterprogramms analysiert wird, was bei komplexeren Unterprogrammen und beim Vorhandensein mehrerer Rücksprunganweisungen sehr aufwendig werden kann..

Das folgende Unterprogramm implementiert den eigentlich gewünschten Algorithmus in strukturierter Form mit einer einzigen Rücksprunganweisung am Ende des Unterprogramms:

&lt;syntaxhighlight lang=&quot;java&quot;&gt;
private static double unterprogramm (double parameter)
{
   double ergebnis = parameter;
   boolean ganzzahlig = (parameter % 1 == 0);
   if (! ganzzahlig)
   {
      ergebnis = ergebnis + 1;
   }
   java.lang.System.out.println (&quot;Ergebnis = &quot; + ergebnis);
   return ergebnis;
}
&lt;/syntaxhighlight&gt;

Die Textausgabe bei den oben angegebenen  Aufrufen des Unterprogramms erfolgt nun wie gewünscht:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
Ergebnis = 0.0
Ergebnis = 1.5
&lt;/syntaxhighlight&gt;

Es empfiehlt sich grundsätzlich ebenfalls immer, innerhalb von Rücksprunganweisungen keine komplexen Ausdrücke, Kontrollstrukturen oder Unterprogrammaufrufe zu verwenden, um einfache und eindeutige Rückgabewerte zu erhalten sowie diese gegebenenfalls mit einer Textausgabe oder einem Debugger kontrollieren zu können. Im Idealfall wird in der Rücksprunganweisung nur der Wert einer zuvor berechneten lokalen Variable mit einem sprechenden Bezeichner zurückgegeben:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
   ergebnis ← f (a, b, c);
   return ergebnis;
&lt;/syntaxhighlight&gt;

In der Regel ergeben sich durch die zusätzliche explizite Zuweisung an die lokale Variable '''ergebnis''' keine Laufzeiteinbußen, da im übersetzten Maschinencode implizit für den Rückgabewert sowieso eine Zuweisung ausgeführt werden muss. Moderne Übersetzer berücksichtigen diesen Kontext automatisch, so dass in beiden Fällen derselbe Maschinencode erzeugt wird.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

===Fallunterscheidungen===
Die einfachste Fallunterscheidung ist die bedingte Anweisung. Verzweigungen enthalten mindestens zwei alternative Programmpfade.

====Bedingte Anweisung====
[[Datei:einfAusw.png|mini|rechts|hochkant=2|Struktogramm einer bedingten Anweisung.]]

Im folgenden Beispiel mit einer bedingten Anweisung (zum Beispiel if - then - end) wird die Dekrement-Anweisung a-- (der Wert der numerischen Variablen a soll um eins erniedrigt werden) nur dann ausgeführt, falls der boolesche Ausdruck a &gt; b wahr ist, die entsprechende Bedingung also erfüllt ist:

 falls a &gt; b dann a-- ende

Hier wird der Wert der Variablen a also nur dann dekrementiert, wenn der Wert der Variablen a größer ist als der Wert der Variable b. Ansonsten wird der Programmablauf sofort hinter der ende-Marke fortgeführt.

====Einfache Verzweigung====
[[Datei:zweifAusw.png|mini|rechts|hochkant=2|Struktogramm einer einfachen Verzweigung.]]

Die einfachste Verzweigung (zum Beispiel if - then - else - end) enthält genau zwei alternative Pfade, von denen in Abhängigkeit eines booleschen Ausdrucks nur einer ausgeführt wird, wie in diesem Beispiel:

 falls a &gt; b dann a-- ansonsten b-- ende

Je nachdem die entsprechende Bedingung erfüllt ist oder nicht, wird die eine oder die andere Anweisung ausgeführt. Im obigen Beispiel wird der Wert der Variablen a nur dann dekrementiert, falls der Wert der Variablen a größer ist als der Wert der Variable b, ansonsten wird hier im Vergleich zur bedingten Anweisung allerdings der Wert der Variablen b um eins erniedrigt. In beiden Fällen wird das Programm anschließend hinter der ende-Marke fortgeführt.

====Mehrfache Verzweigung====
[[Datei:Mehrseitige Auswahl.png|mini|rechts|hochkant=2|Struktogramm einer mehrfachen Verzweigung.]]

Eine mehrfache Verzweigung (zum Beispiel switch - case - else - end) enthält mehr als zwei alternative Programmpfade, die meist, wie auch im folgenden Beispiel, von ganzzahligen Ausdrücken gesteuert werden:

 verzweige mit dem Wert von a
    falls 1 : unterprogramm_A ()
    falls 2 : unterprogramm_B ()
    falls 3 : unterprogramm_C ()
    ansonsten unterprogramm_D ()
 ende

In Abhängigkeit des in der ganzzahligen Variablen a gespeicherten Zahlenwertes wird genau eines der vier angegebenen Unterprogramme aufgerufen; beim Wert 1 unterprogramm_A, beim Wert 2 unterprogramm_B, beim Wert 3 unterprogramm_C und ansonsten unterprogramm_D. Danach wird der Programmablauf hinter den ende-Marke fortgeführt.

In manchen weniger stakt strukturierten Programmiersprachen wie C sind Vorsicht und Aufmerksamkeit geboten, weil beispielsweise dort die verschiedenen Fälle der entsprechenden switch-Anweisung nur optional mit einer break-Anweisung und nicht immer und obligatorisch abgeschlossen werden. Dies nutzen einige Programmierer, um in bestimmten Situationen mehrere Fälle hintereinander abarbeiten zu lassen. Dieses Vorgehen ist jedoch hochgradig unstrukturiert und führt sehr schnell und unübersichtlichem Programmcode und somit sehr leicht zu Programmierfehlern. Dies kann vermieden werden, wenn in diesen Programmiersprachen hinter jedem unterschiedenem Fall kategorisch die break-Anweisung implementiert wird, auch wenn die Programmiersprache oder der Übersetzer dies nicht fordern.

[[Datei:MehrfAusw.png|mini|rechts|hochkant=2|Struktogramm mit verschachtelten einfachen Verzweigungen, um eine mehrfache Verzweigung zu implementieren.]]

Mehrfache Verzweigungen mit aufeinanderfolgenden numerischen oder aufzählbaren Werten, wie im obigen Beispiel 1, 2 und 3, können rechnerintern unter Umständen effizient genutzt werden, weil die Sprungadressen arithmetisch berechnet werden können. Dies ist bei modernen Laufzeitsystemen in der Regel aber nicht mehr so relevant, und diese mehrfachen Verzweigungen können auch immer durch mehrfache Fallunterscheidungen programmiert werden. Durch eine eigene Anweisung für die mehrfache Verzweigung kann die Übersichtlichkeit des Quelltextes allerdings oft gesteigert werden. Auf der anderen Seite können die Übersichtlichkeit und die Nachvollziehbarkeit in der Regel auch hier mit entsprechenden Unterprogrammaufrufen gesteigert werden.

===Schleifen===
Bei Schleifen wird eine Anweisungsfolge nur dann ausgeführt, wenn die entsprechende boolesche, im Sinne der Schleife lokale Laufvariable den Wert &quot;wahr&quot; hat. Alle Schleifen können auf eine grundlegende Form zurückgeführt werden, bei der ein wesentliches Merkmal ist, ob die Laufvariable '''zu Beginn''' der Schleifenanweisungen den initialen Wert &quot;wahr&quot; erhält (fußgesteuert) oder in der Anfangsbedingung durch einen variablen booleschen Ausdruck bestimmt ist (kopfgesteuert). Es ist sinnvoll, dass diese Laufvariable nur zum Zwischenspeichern der Abbruchbedingung dient und ausschließlich im Zusammenhang mit der Schleife verwendet wird.

Bei wohlstrukturierter Programmierung mit zählenden Schleifen können numerische Laufvariablen verwendet werden, die innerhalb der Schleife vorzugsweise erst in der letzten Anweisung der Schleife aktualisiert werden, damit es innerhalb des Schleifendurchlaufs nicht zu Inkonsistenzen, Verwechslungen oder Mehrdeutigkeiten kommen kann.

Ferner gibt es in der strukturierten Programmierung keine expliziten Sprunganweisungen, die irgendwo innerhalb einer Schleife zum Beispiel mit dem Kommando '''continue''' den Rest der Schleife überspringen und sofort die nächstfolgende Abbruchbedingung der Schleife prüfen lassen. Innerhalb von Schleifen ist es ohne Weiteres möglich, alle Zwischenschritte mit Verzweigungen zu steuern beziehungsweise alle Zwischenergebnisse in lokalen Variablen zu speichern, ohne dass es in modernen Computersystemen zu längeren Ausführungszeiten kommt.

Im Folgenden soll dies mit der Programmiersprache Java an sehr einfachen Schleifen, die alle Zahlen außer der Fünf von Eins bis Zehn ausgeben sollen, erläutert werden.

Unstrukturiertes Beispiel:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
long i = 1;
do
{
  if (i == 5)
  {
    i++; // Die Schleifenendanweisung zum Hochzaehlen der Laufvariable muss hier dupliziert werden, damit es nicht zu einer Fehlfunktion kommt.
    continue; // Die Schleife wird durch diese explizite Sprunganweisung unstrukturiert abgebrochen.
  }
  java.lang.System.out.println (i);
  i++;
} while (i &lt;= 10);
&lt;/syntaxhighlight&gt;

Strukturiertes Beispiel:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
long i = 1;
do
{
  if (i != 5)
  {
     java.lang.System.out.println (i);
  }
  i++;
} while (i &lt;= 10);
&lt;/syntaxhighlight&gt;

====Kopfgesteuerte Schleifen====
[[Datei:KopfgesteuerteSchleife.png|mini|rechts|hochkant=2|Struktogramm einer kopfgesteuerten Schleife.]]

Kopfgesteuerte Schleifen werden auch als '''While'''-Anweisungen bezeichnet.

{| class=&quot;wikitable&quot; style=&quot;text-align:center&quot;
| rowspan=&quot;4&quot; | Kopfgesteuerte Schleife
| colspan=&quot;2&quot; | Setze Laufvariable auf boolesche Anfangsbedingung
|-
| rowspan=&quot;3&quot; | Solange wie die Laufvariable den Wert &quot;wahr&quot; hat führe aus
|-
|Anweisungsfolge
|-
| Setze Laufvariable auf boolesche Endbedingung
|}

Wenn die boolesche Anfangsbedingung zu Beginn den Wert &quot;falsch&quot; hat, wird die Schleife '''nicht durchlaufen'''.

====Fußgesteuerte Schleifen====
[[Datei:FussgesteuerteSchleife.png|mini|rechts|hochkant=2|Struktogramm einer fußgesteuerten Schleife.]]

Die fußgesteuerte Schleife, die auch '''Repeat'''-Anweisung genannt wird, ist ein Sonderfall der kopfgesteuerten Schleife, bei der die boolesche Anfangsbedingung immer auf &quot;wahr&quot; gesetzt wird. Daher wird eine fußgesteuerte Schleife '''immer mindestens einmal durchlaufen'''.

{| class=&quot;wikitable&quot; style=&quot;text-align:center&quot;
| rowspan=&quot;4&quot; | Fußgesteuerte Schleife
| colspan=&quot;2&quot; | Setze Laufvariable auf &quot;wahr&quot;
|-
| rowspan=&quot;3&quot; | Solange wie die Laufvariable den Wert &quot;wahr&quot; hat führe aus
|-
|Anweisungsfolge
|-
| Setze Laufvariable auf boolesche Endbedingung
|}

Da der Ausdruck der booleschen Anfangs- und Endbedingung oft identisch formuliert ist, bietet es sich an, dafür einen Funktionsaufruf zu verwenden, um eine Codewiederholung zu vermeiden.

Aus Gründen der Laufzeiteffizienz wird das Setzen der Laufvariablen zu Beginn und die erstmalige Überprüfung der Laufvariablen oft weggelassen, was für die allermeisten Anwendungen heute jedoch unwesentlich ist. Da die Laufvariable in diesem Fall zu Beginn jedoch nicht definiert werden muss und daher gegebenenfalls auch gar nicht definiert wird, birgt dieses Vorgehen die Gefahr in sich, dass die Laufvariable ihren undefinierten Zustand behält. Insbesondere tritt dies ein, wenn das Setzen der Laufvariable auf eine boolesche Endbedingung nicht erfolgt, weil dies in der verwendeten Programmiersprache nicht obligatorisch ist beziehungsweise vom Programmierer vergessen wurde, oder weil dies wegen eines zwangsläufig unstrukturierten Abbruchs innerhalb der Schleife (zum Beispiel mit einer Break-Anweisung) gar nicht erfolgen kann.

====Endlosschleifen====
'''Endlosschleifen''' sind unstrukturiert, da das Programm nicht regelgerecht beendet werden kann. Daher sind diese sogenannten Loop-Anweisungen, wie zum Beispiel

 for (;;)
 {
    ...
 }

 while (true)
 {
    ...
 }

 repeat
 {
    ...
 }
 until (false)

beziehungsweise

 do
 {
    ...
 }
 while (true)

oder

 loop
 {
    ...
 }

zu unterlassen. Insbesondere das Verlassen von Endlosschleifen mit einer '''Sprunganweisung''' oder gar mehreren potentiellen Sprunganweisungen, wie zum Beispiel ''break'' oder ''exit'', ist hochgradig unstrukturierte Programmierung, da der Ausstiegszeitpunkt oder die Stelle des Ausstiegs aus der Schleife (wenn überhaupt) nur schwierig nachzuvollziehen oder zu bestimmen ist.

====For-Schleifen====
Die For-Schleifen-Anweisung

 int i
 for (i ← 0; i &lt; max; i++)
 {
  ...
 }

ist identisch mit der kopfgesteuerten while-Anweisung:

 int i
 i ← 0
 while (i &lt; max)
 {
  ...
  i = i + 1
 }

Es ist im Sinne eines einfachen Sprachumfangs und eines einheitlichen Sprachstils unter Umständen nützlich, für kopfgesteuerte Schleifen keine For-Schleifen, sondern ausschließlich While-Schleifen zu benutzen.

Wenn die Programmiersprache es erlaubt, Zählvariablen ausschließlich für eine Schleife zu definieren, dann hat dies den Vorteil, dass das Prinzip der Lokalität für diese Zählvariablen sehr gut erfüllt ist, da die Zählvariable dann außerhalb der Schleife nicht sichtbar ist und somit auch nicht verwendet werden kann:

 for (int i ← 0; i &lt; max; i++)
 {
  ...
 }

Die äquivalente Schreibweise mit einer while-Schleife sieht wie folgt aus, wobei die äußere Blockanweisung dafür sorgt, dass die Zählvariable &quot;i&quot; innerhalb der Blockanweisung deklariert ist und nur in Verbindung mit der Schleife sichtbar respektive verwendbar ist:

 {
    int i
    i ← 0
    while (i &lt; max)
    {
     ...
     i++
    }
 }

Bei Algorithmen, die aus mehreren Kontrollstrukturen bestehen, ist es im Sinne der besseren Strukturierung vorzuziehen, alle Schleifen in eigene Methoden auszulagern, die aufgerufen werden und deren Schnittstellen über ihre Parameter eindeutig festgelegt sind. Hierbei können die Schleifen verschachtelt sein (innere und äußere Schleife) oder hintereinander ausgeführt werden. In jedem Fall sind alle Parameter und Variablen (also auch die jeweiligen Zählvariablen) innerhalb der entsprechenden Methoden lokal verfügbar.

==Codewiederholungen==
Codewiederholungen gehören insbesondere bei Anfängern sehr häufig zu den kapitalen Fehlern beim Softwareentwurf. Es ist nur scheinbar bequem, bereits vorhandenen Quelltext zu kopieren und für eine ähnliche Aufgabe geringfügig anzupassen. Es ist Größenordnungen besser, den bereits vorhandenen Quelltext so anzupassen, dass er für alle ähnlichen oder zumindest mehrere ähnliche Aufgabenstellungen eingesetzt werden kann. Erfahrene Programmierer wittern schon von Anfang an, dass eine bestimmte Methode auch in einem ähnlichen Kontext eingesetzt werden könnte und entwerfen den Code von vornherein so allgemein wie möglich.

===Symbolische Konstanten===
Konstante Ausdrücke werden in der Regel als '''symbolische Konstanten''' definiert, wie zum Beispiel mit der symbolischen Konstante &quot;Pi&quot; für die Kreiszahl oder die symbolische Konstante &quot;Title&quot; für den Text &quot;Programmierung&quot;:

 const double Pi ← 3.141592654
 const String Title ← &quot;Programmierung&quot;

Statt konstante Ausdrücke zu wiederholen – und sei es nur eine ganze Zahl – ist es erheblich besser, stattdessen eine symbolische Konstante mit einem „sprechenden“ Bezeichner zu verwenden.

Also nicht mit der ganzen Zahl 3:

 int inputNumber ← 3
 ...
 if (inputNumber = 3) ...

Sondern besser mit der symbolischen Konstante &quot;Exit&quot; mit dem unveränderlichen, ganzzahligen Wert 3:

 const int Exit ← 3
 
 int inputNumber ← Exit
 ...
 if (inputNumber = Exit) ...

Oder nicht zweimal mit derselben ganzen Zahl 3:

 if (a &gt; 3) and (b &gt; 3) ...

Sondern besser mit zwei verschiedenen symbolischen Konstanten &quot;Limit_a&quot; und &quot;Limit_b&quot;:

 const int Limit_a ← 3
 const int Limit_b ← 3
 
 if (a &gt; Limit_a) and (b &gt; Limit_b) ...

Auf diese Weise kann auch leicht vermieden werden, dass gleichlautende Ausdrücke mit unterschiedlicher Bedeutung verwechselt werden können, insbesondere wenn sie später einmal geändert werden müssen:

 if (numberOfConstellation &gt; 12)
 {
    Ausgabe (&quot;Diese Sternbildnummer ist ungültig.&quot;)
 }
 
 if (numberOfHalftones &gt; 12)
 {
    Ausgabe (&quot;Das Intervall ist größer als eine Oktave.&quot;)
 }

Die beiden konstanten Zahlensymbole &quot;12&quot; haben nichts außer ihrem Zahlenwert gemeinsam, und daher ist der folgende Code erheblich besser nachvollziehbar:

 const int Number_Of_Constellations ← 12
 const int Number_Of_Halftones_Per_Octave ← 12
 
 ...
 
 if (numberOfConstellation &gt; Number_Of_Constellations)
 {
    Ausgabe (&quot;Diese Sternbildnummer ist ungültig.&quot;)
 }
 
 if (numberOfHalftones &gt; Number_Of_Halftones_Per_Octave)
 {
    Ausgabe (&quot;Das Intervall ist größer als eine Oktave.&quot;)
 }

===Aufruf von Unterprogrammen===
[[Datei:Aufruf.png|mini|rechts|hochkant=2|Struktogramm eines Unterprogrammaufrufs.]]

Unterprogramme, die in vielen Programmiersprachen auch Methoden, Prozeduren oder Funktionen genannt werden, beinhalten sequenzielle Rechenvorschriften (Algorithmen) zum Bearbeiten von Daten, die zu einer Einheit zusammengefasst sind.

So kann zum Beispiel die Rechenvorschrift für die Berechnung des Kreisumfangs aus dem Kreisradius als Folge von Programmanweisungen formuliert werden, aber auch in eine Methode ausgelagert werden. Dieses Unterprogramm kann dann irgendwo im Programmcode aufgerufen werden. Dies gewinnt besonders dann Bedeutung, wenn das Unterprogramm an verschiedenen Stellen aufgerufen werden soll, so dass dann diese Programmanweisungen nicht mehrfach programmiert oder kopiert werden müssen.

Insbesondere wenn die ursprünglichen, an mehreren Stellen auftauchenden Programmanweisungen einen Fehler enthalten, muss dieser nach dem Entdecken des Fehlers - also möglicherweise zu einem viel späteren Zeitpunkt - zur Fehlerbehebung zwangsweise an mehreren Stellen im Programmcode korrigiert werden. Das ist nicht nur mühsam, sondern einzelne relevante Stellen können leicht übersehen werden, so dass der entdeckte Fehler gar nicht vollständig ausgemerzt wird.

Die mehrfach eingegebenen Programmanweisungen zur Berechnung des Kreisumfangs werden beim Auftreten von '''Codewiederholung''' an drei Stellen des Quelltextes programmiert:

 const double Pi ← 3.141592654
 
 double perimeter1 ← radius1 * 2 * Pi
 double perimeter2 ← radius2 * 2 * Pi
 double perimeter3 ← radius3 * 2 * Pi

Mithilfe des im Unterprogramm &quot;perimeter&quot; nur einmal implementierten Algorithmus' zur Ermittlung des Kreisumfangs und dessen dreimaligem Aufruf kann die Wiederholung der Implementierung der Rechenvorschrift leicht vermieden werden:

 /* &quot;perimeter&quot; computes and returns the perimeter of a circle with radius &quot;radius&quot; */
 double perimeter (radius)
 {
    const double Pi ← 3.141592654
    double perimeter ← radius * 2 * Pi
    return perimeter
 }
 
 double perimeter1 ← perimeter (radius1)
 double perimeter2 ← perimeter (radius2)
 double perimeter3 ← perimeter (radius3)

==Zuweisungskompatibilität==
'''Zuweisungskompatibilität''' liegt vor, wenn Ausdrücke und Variablen aufgrund hinreichend kompatibler Datentypen einander zugewiesen, miteinander verglichen oder eindeutig miteinander verknüpft werden können.

Es kann bereits im Quelltext überprüft werden, ob eine hinreichende Zuweisungskompatibilität vorliegt. Liegt diese nicht vor, handelt es sich um eine Typverletzung, und es muss eine explizite Typumwandlung programmiert werden. In diesem Fall kann es sehr leicht zu Programmfehlern kommen.

Programmiersprachen, die für die maschinennahe Programmierung konzipiert wurden, wie zum Beispiel Assemblersprachen oder die Programmiersprache C, haben oft gar keine oder nur eine sehr schwache Typprüfung, was sehr leicht zu Programmfehlern führen kann.

In manchen Programmiersprachen, wie zum Beispiel C, ist es sogar erlaubt, beliebige Zeiger einer Zeigervariablen zuzuweisen, ohne dass geprüft wird oder überhaupt geprüft werden kann, ob die Datentypen der referenzierten Daten kompatibel sind.

===Zeichenketten===
Ein weiteres schwerwiegendes Problem kann sich bei der Verwendung von Zeichenketten (englisch: string) ergeben, die in der Regel zum Speichern von Texten Verwendung finden und die aus einer Sequenz von einzelnen Zeichen respektive Buchstaben (englisch: character) bestehen.

Eine strukturierte Programmiersprache, die Zeichenkettenverarbeitung und einen entsprechenden Datentyp zur Verfügung stellt, sollte fordern, dass jede Zeichenkette mit einem Zeichen abgeschlossen wird, das das Ende der Zeichenkette markiert (englisch: string terminator). Hierfür wird allgemein das Zeichen mit dem numerischen Wert null verwendet, das keinen Buchstaben repräsentiert und in Quelltexten häufig mit den Symbolen NUL, 0X oder \0 kodiert wird.

Manche unstrukturierte Programmiersprachen fordern nicht, dass eine solche Kennzeichnung des Endes der Zeichenkette verwendet werden muss. Bei der Implementation von Zeichenkettenfunktionen in Programmbibliotheken, insbesondere wenn die dazugehörige Programmiersprache gar keinen Datentyp für Zeichenketten zur Verfügung stellt, ist auch bei strukturierten Programmiersprachen nicht unbedingt gewährleistet, dass eine entsprechende Kennzeichnung des Zeichenkettenendes obligatorisch ist. Bei der Implementierung von Vergleichsfunktionen oder Zeichenkettenmanipulationen in unstrukturierten Programmiersprachen oder Programmbibliotheken muss die Tatsache, ob das Nullzeichen vorhanden ist oder nicht, regelmäßig untersucht und berücksichtigt werden. Einfacher und sicherer ist es, mit einer strukturierten Programmiersprache oder einer entsprechenden Programmbibliothek zu arbeiten, bei der immer gewährleistet ist und vorausgesetzt werden kann, dass alle Zeichenketten mit einem Endezeichen abgeschlossen sind.

===Strenge Zuweisungskompatibilität===
Zuweisungen sind uneingeschränkt zulässig, wenn eine strenge Zuweisungskompatibilität gegeben ist. Dazu müssen die Datentypen eines zuzuweisenden Ausdrucks und einer Variable exakt übereinstimmen, wie in folgendem Beispiel mit dem Datentyp &quot;Mann&quot; und den beiden Instanzen &quot;otto&quot; und &quot;emil&quot;:

 TYPE Mann = Verbund von alter und groesse
 
 VARIABLE otto, emil: Mann
 
 otto.alter   ← 50
 otto.groesse ← 1.80
 
 emil ← otto

Alle Attribute von „otto“, nämlich „alter“ und „groesse“, können „emil“ eindeutig zugewiesen werden.

Zwei Instanzen sind streng zuweisungskompatibel, wenn sie derselben Klasse angehören, wie in diesem Beispiel die beiden Objekte &quot;fenster1&quot; und &quot;fenster2&quot; aus der Klasse &quot;Rechteck&quot;:

 TYPE Rechteck = Klasse mit breite, hoehe und mit Methode flaechenberechnung&amp;nbsp;()
 
 VARIABLE fenster1, fenster2: Rechteck
 
 fenster1.breite ← 200
 fenster1.hoehe  ← 100
 fenster1.flaechenberechnung&amp;nbsp;() (Flächenberechnung für „fenster1“ ausführen)
 
 fenster2 ← fenster1
 fenster2.flaechenberechnung&amp;nbsp;() (Flächenberechnung für „fenster2“ ausführen)

Die Zuweisung in der vorletzten Programmzeile ist möglich, da beide Instanzvariablen &quot;fenster1&quot; und &quot;fenster2&quot; derselben Klasse &quot;Rechteck&quot; angehören, und daher liefert auch der Methodenaufruf in der letzten Programmzeile ein korrektes Ergebnis.

====Logische Kompatibilität====
Zwei übereinstimmende Definitionen von zwei Datentypen sind nicht zuweisungskompatibel. Die Daten können zwar eindeutig überführt werden (technische Kompatibilität), es liegen zwei formal zwar identische, aber dennoch verschiedene Definitionen vor, so dass diese keine logische Kompatibilität aufweisen. Folgendes Beispiel wäre demzufolge formal korrekt, aber nicht logisch:

 TYPE Mann = Verbund von alter und groesse
 TYPE Frau = Verbund von alter und groesse
 
 VARIABLE otto: Mann
 VARIABLE anna: Frau
 
 otto.alter   ← 50
 otto.groesse ← 1.80
 
 anna ← otto

Die Zuweisung in der letzten Programmzeile ist technisch zwar ohne Probleme möglich, aber logisch nicht korrekt, und sie birgt daher die Gefahr der Entstehung von Programmierfehlern. Um solche Fehler zu vermeiden, sind Zuweisungen mit impliziter Typumwandlung in einigen Programmiersprachen mit starker Typisierung nicht zulässig, und der Compiler verweigert die Übersetzung dieser Zuweisung.

In der objektorientierten Programmierung kann durch die Vererbung der gemeinsamen Eigenschaften von Datentypen leicht eine logische Kompatibilität hergestellt werden:

 TYPE Mensch = Verbund von alter und groesse
 
 TYPE Mann = Mensch
 TYPE Frau = Mensch
 
 VARIABLE otto: Mann
 VARIABLE anna: Frau
 
 otto.alter   ← 50
 otto.groesse ← 1.80
 
 anna ← otto

Die Objekteigenschaften &quot;alter&quot; und &quot;groesse&quot; sind hierbei Eigenschaften von Objekten des Datentyps &quot;Mensch&quot; und daher sowohl zuweisungskompatibel, als auch logisch korrekt; bei der Zuweisung können und werden nur die Attribute &quot;alter&quot; und &quot;groesse&quot; der gemeinsamen Basisklasse &quot;Mensch&quot; übertragen.

====Wahrheitswerte====
In einigen älteren Programmiersprachen, wie zum Beispiel C, gibt es keinen eigenen Datentyp für zweiwertige boolesche Variablen. Zur Behandlung und Verarbeitung entsprechender Information wird dann häufig der ganzzahlige Datentyp mit dem kleinsten Speicherbedarf verwendet, wobei der Zahlenwert null für den Wahrheitswert „Falsch“ und alle anderen Zahlenwerte für den Wahrheitswert „Wahr“ Verwendung finden. Auch hier ergeben sich logische Inkompatibilitäten und somit ein gefährliches Potential für Komplikationen, da mit binären Werten keine Arithmetik und mit Zahlen keine logischen Verknüpfungen oder logischen Operationen durchgeführt werden können. Im folgenden Beispiel wird dieser Missbrauch verdeutlicht:

 VARIABLE schlechteWahrheit1, schlechteWahrheit2, ergebnisWahrheit: INTEGER
 
 schlechteWahrheit1 ← 0
 schlechteWahrheit2 ← 1
 
 ergebnisWahrheit ← (schlechteWahrheit1 + schlechteWahrheit2)
 
 ergebnisWahrheit ← (schlechteWahrheit2 + schlechteWahrheit2)

Das Ergebnis der ersten arithmetischen Addition ist 1, was fälschlich als der Wahrheitswert „Wahr“ missinterpretiert werden könnte, der nicht dem Ergebnis der logischen Und-Verknüpfung entspricht. Noch offensichtlicher ist das Problem in der zweiten arithmetischen Addition, wo das Ergebnis 2 erzielt wird. Somit existieren ohne Not mehr als zwei Zustände für die binären (also zweiwertigen) Variablen, was schnell zu Missverständnissen und Programmierfehlern führen kann.

Eine eindeutige und korrekte Implementierung wird erreicht, wenn die Programmiersprache oder eine dazugehörige Programmbibliothek einen zweiwertigen Datentyp, wie zum Beispiel „BOOLEAN“ oder „bool“, zwei entsprechende Ausprägungen, wie zum Beispiel &quot;false&quot; und &quot;true&quot;, und die dazugehörigen eindeutigen booleschen Operatoren und Funktionen (beispielsweise &quot;and&quot;, &quot;or&quot; oder &quot;not&quot;) anbietet.

 VARIABLE richtigeWahrheit1, richtigeWahrheit2, ergebnisWahrheit: BOOLEAN
 
 richtigeWahrheit1 ← falsch
 richtigeWahrheit2 ← wahr
 
 ergebnisWahrheit ← (richtigeWahrheit1 und richtigeWahrheit2)
 
 ergebnisWahrheit ← (richtigeWahrheit2 und richtigeWahrheit2)

Sinngemäß gilt das Gleiche für die Verknüpfungen von Mengen. Wenn hier bei den Datentypen und zulässigen Operatoren nicht zwischen Bitmengen (englisch: (bit) sets) und Zahlen unterschieden wird, kommt es wie zum Beispiel bei der Bestimmung von Vereinigungs- oder Differenzmengen zu Interpretationsproblemen. Eine eindeutige und korrekte Implementierung verwendet Datentypen, die für Mengen und Mengenoperationen definiert sind. In einigen Programmiersprachen werden solche Datentypen im Sprachumfang implizit angeboten, in anderen gibt es dafür standardisierte Programmbibliotheken, auf die über Unterprogrammaufrufe zugegriffen werden kann.

===Zuweisungskompatibilität ohne Informationsverlust===
In einigen Fällen kann die Information, die mit einem Datentyp dargestellt werden kann, eindeutig und ohne Informationsverlust in einen anderen Datentyp überführt werden. Typische Beispiele sind ganze Zahlen mit unterschiedlicher Speichergröße. So kann ein Integer mit 16&amp;nbsp;Bit Speichergröße eindeutig in einer vorzeichenbehafteten Integer-Variablen mit 32&amp;nbsp;Bit Speichergröße abgelegt werden, ohne dass die ursprünglich nur mit 16&amp;nbsp;Bit gespeicherte Zahl verändert wird. Umgekehrt ist dies jedoch nicht allgemein möglich, insbesondere unter der Beachtung von Vorzeichen und großen Zahlen. Der folgende Programmierabschnitt zeigt ein Beispiel ohne Zuweisungskompatibilität, da der Datentyp „BYTE“ nur 8&amp;nbsp;Bit Speichertiefe hat und nur Werte zwischen -128 bis +127 und somit nicht die Zahl 555 repräsentieren kann, wohingegen der Datentyp „SHORTINT“ eine Speichertiefe von 16&amp;nbsp;Bit hat und ganze Zahlen von -32768 bis +32767 repräsentieren kann:

 zahl1: BYTE
 zahl2: SHORTINT
 
 zahl2 ← 555
 zahl1 ← zahl2

Die letzte Programmzeile stellt einen ungültigen Versuch der Zuweisung der ganzen Zahl&amp;nbsp;555 aus der Variablen „zahl2“ an die Variable „zahl1“ dar.

Bei einer solchen Programmanweisung kann bei typsicheren Programmiersprachen bereits der Compiler verhindern, dass ausführbarer Maschinencode erzeugt wird. Bei fehlender Überprüfung durch den Compiler kann unbemerkt Information verloren gehen, so dass bei nachfolgenden Berechnungen unter Umständen grobe Berechnungsfehler auftreten, die relativ schwierig zu analysieren sind.

===Zuweisungskompatibilität mit geringem Informationsverlust===
Ein Sonderfall ist die Zuweisung von ganzen Zahlen an Variablen, die Gleitkommazahlen repräsentieren. In der Regel kann ohne die Gefahr von Programmfehlern toleriert werden, große ganze Zahlen implizit in Gleitkommazahlen umzuwandeln, da der Rechenfehler (wenn überhaupt vorhanden) hierbei sehr klein ist. Auch dies kann an einem Beispiel verdeutlicht werden: ein „LONGINT“ mit 64&amp;nbsp;Bit Speichergröße kann die Zahl 9223372036854775807 mit 19 Dezimalstellen speichern. Der folgende Programmierabschnitt zeigt ein Beispiel mit Zuweisungskompatibilität mit einem in der Regel zu vernachlässigenden Informationsverlust, da der Datentyp „REAL“ nach IEEE 754 mit 64&amp;nbsp;Bit nur Zahlen mit einer Mantisse mit maximal 14 Nachkommastellen speichern kann:

 zahl1: LONGINT
 zahl2: REAL
 
 zahl1 ← 9223372036854775807
 zahl2 ← zahl1

Die letzte Anweisung stellt in fast allen Programmiersprachen einen gültigen Versuch der Zuweisung der ganzen Zahl&amp;nbsp;&lt;math&gt;{2}^{63} - 1&lt;/math&gt; aus der Variablen „zahl1“ an die Variable „zahl2“ dar, da diese gerundeten Zahlenwert &lt;math&gt;9{,}22337203685478 \cdot {10}^{18}&lt;/math&gt; enthält, und der Fehler durch das Abschneiden der letzten Nachkommastellen hier nur in einer Größenordnung von &lt;math&gt;{10}^{-14}&lt;/math&gt; liegt und daher für praktisch alle Anwendungen vernachlässigt werden kann.

Bei einer erneuten Datentypkonvertierung zurück zu einem geeigneten ganzzahligen Datentyp kommt es dann aber zu einer Abweichung zu der ursprünglichen ganzen Zahl. In solchen Fällen ist es daher besser, vorsichtshalber und mit Inkaufnahme etwas längerer Programmlaufzeiten ausschließlich mit Gleitkommazahlen zu operieren.

===Zuweisungskompatibilität mit definiertem Informationsverlust===
Zwei Instanzen sind mit definiertem Informationsverlust zuweisungskompatibel, wenn die zuzuweisende Klasse einer Klasse angehört, die von der zugewiesenen Klasse abgeleitet wurde. Alle Daten die in der zugewiesenen Klasse deklariert und somit erforderlich sind, können dann zugewiesen werden, jedoch werden die in der zuzuweisenden abgeleiteten Klasse möglicherweise hinzugefügten Attribute ignoriert, wie das folgende Beispiel verdeutlichen soll, in welchem der Datentyp „Mensch“ alle Eigenschaften vom Datentyp „Lebewesen“ erbt und zusätzlich das Attribut „intelligenzquotient“ bekommt:

 TYPE Lebewesen = Verbund von alter und gewicht
 
 TYPE Mensch = Lebewesen mit intelligenzquotient
 
 VARIABLE     otto: Mensch
 VARIABLE eukaryot: Lebewesen
 
 otto.alter               ← 50
 otto.gewicht             ← 75
 otto.intelligenzquotient ← 100
 
 eukaryot ← otto

Die Zuweisung in der letzten Zeile ist korrekt, das Attribut „intelligenzquotient“ der Variable „otto“ vom Datentyp „Mensch“ wird jedoch nicht an die Variable „eukaryot“ zugewiesen, da es beim Datentyp „Lebewesen“ der Basisklasse nicht deklariert ist.

==Komplexe Ausdrücke==
Zusammengesetzte Ausdrücke mit verschiedenartigen Operatoren können sehr unübersichtlich und somit fehleranfällig sein. Manche Programmiersprachen haben sehr viele Hierarchieebenen für Operatoren, die auch durch erfahrene Programmierer kaum durchschaut werden können, oder sogar dafür sorgen, dass bestimmte Teile des Quellcodes zur Laufzeit gar nicht erreicht werden können. Daher ist es dringend empfehlenswert, Anweisungen in kleine, überschaubare Einheiten zu untergliedern. In einigen Programmiersprachen ist es sogar möglich, die Zuweisung in andere Anweisungen zu integrieren, da sie selber als ein Ergebniswert interpretiert werden darf. Ferner ist nicht immer offensichtlich welchen Datentyp ein Ergebnis hat, was insbesondere in Ermangelung eines zweiwertigen Datentyps ''Boolean'' zu Missverständnissen führen kann.

Also zum Beispiel nicht:

 if (a ← b – c = 0) ...

In dieser bedingten Anweisung (if) ist nicht klar, in welcher Reihenfolge der Zuweisungsoperator (←), der Differenzoperator (-) und der Vergleichsoperator (=) ausgeführt werden (sollen). 

Es ist erheblich besser, die Anweisungen klar zu trennen:

 a ← (b – c)
 if (a = 0) ...

Die folgenden beiden Beispiele mit dem Zuweisungsoperator &quot;=&quot; und dem Vergleichsoperator &quot;==&quot; zeigen Programmsequenzen in der Programmiersprache C, die zu sehr leicht zu übersehenden Programmierfehlern führen können:

&lt;syntaxhighlight lang=&quot;C&quot;&gt;
 /* Programmiersprache C */
 int i = 0;
 if (i = 1)
 {
    /*
       Dieser Block wird immer ausgeführt,
       weil die Zuweisung i = 1 immer das numerische Ergebnis 1 hat,
       was als der boolesche Wert &quot;wahr&quot; interpretiert wird.
    */
 }
 
 int i = 0;
 if (i == 1)
 {
    /*
       Dieser Block wird nie ausgeführt,
       weil die Vergleichsoperation i == 1 immer das numerische Ergebnis 0 hat,
       was als der boolesche Wert &quot;falsch&quot; interpretiert wird.
    */
 }
&lt;/syntaxhighlight&gt;

Die folgende Rückgabe-Anweisung (&quot;return&quot;) in der Programmiersprache Java ist nicht nur verwirrend, sondern sinnfrei:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 2;
 long y = 1;
 return y + x--;
&lt;/syntaxhighlight&gt;

Der Dekrement-Operator &quot;- -&quot; wird in vielen Programmiersprachen gar nicht ausgeführt, weil er hierarchisch erst nach einer Zuweisung ausgeführt wird oder nach einer die Code-Sequenz beendende Return-Anweisung noch ausgeführt werden müsste, aber de facto gar nicht mehr ausgeführt wird. Deswegen ist die folgende Anweisungsfolge nicht nur weniger komplex, gut strukturiert und korrekt, sondern auch sinnvoll und leicht sowie eindeutig nachvollziehbar:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 2;
 long y = 1;
 x--;
 long summe = y + x;
 return summe;
&lt;/syntaxhighlight&gt;

Beeindruckend sinnlos, verwirrend und komplex sind Monster-Ausdrücke (nach Niklaus Wirth: ''notational monsters''), die in einigen Programmiersprachen wie zum Beispiel C erlaubt sind, wie zum Beispiel bei der Kombination einer Rücksprunganweisung (&quot;return&quot;) mit einer Zuweisung (&quot;=&quot;), zwei verschiedenen Inkrement-Operatoren (&quot;++&quot;) und einem Additionsoperator (&quot;+&quot;). Es ist sehr schwierig durchschaubar, in welcher Reihenfolge diese fünf Anweisungen ausgeführt werden und ob diese überhaupt ausgeführt werden. Selbst wenn die Zuweisung oder die nachrangige Inkrementierung ausgeführt würden, wären sie völlig sinnlos, da auf die lokale Variable i nach der Return-Anweisung gar nicht mehr zugegriffen werden kann:

&lt;syntaxhighlight lang=&quot;C&quot;&gt;
/* Programmiersprache C */
int i = 0;
return i = ++i+i++;
&lt;/syntaxhighlight&gt;

Auch im folgenden Java-Beispiel ist die Sachlage nicht wesentlich besser. Das Ergebnis dieser Anweisungsfolge für die Variable y ergibt den Wert 2 + 2 = 4 , weil der letzte Inkrementoperator die Variable x vor der Ausführung aller anderen Operatoren auf den Wert 2 erhöht, und der erste Inkrementoperator die Variable x erst nach der Addition und der Zuweisung auf den Wert 3 erhöht:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 1;
 long y = x++ + ++x;
&lt;/syntaxhighlight&gt;

Es ist ebenfalls nicht leicht zu durchschauen, dass das Ergebnis dieser Anweisungsfolge in Java für die Variable y den Wert 2 + 3 = 5 ergibt, weil die Variable x vor der Auswertung des arithmetischen Summe zweimal inkrementiert wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 1;
 long y = ++x + ++x;
&lt;/syntaxhighlight&gt;

Ferner ist das Ergebnis der nächsten Anweisungsfolge in Java für die Variable y der Wert 2 + 2 = 4, weil die Variable x vor der Auswertung der arithmetischen Summe nur beim ersten Inkrementoperator für die Summenbildung wirksam verändert wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 1;
 long y = ++x + x++;
&lt;/syntaxhighlight&gt;

Auf der anderen Seite ist das Ergebnis der nächsten Anweisungsfolge in Java für die Variable y der Wert 1 + 2 = 3, weil die Variable x während der Auswertung des arithmetischen Ausdrucks nur beim ersten Inkrementoperator für die Summenbildung wirksam verändert wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 1;
 long y = x++ + x++;
&lt;/syntaxhighlight&gt;

Noch gefährlicher wird es, wenn die Reihenfolge der Auswertung von arithmetischen Ausdrücken mit gleichwertigen Operanden für den Compiler oder Interpreter nicht definiert ist:

&lt;syntaxhighlight lang=&quot;C&quot;&gt;
/* Programmiersprache C */
 int x = 1;
 long y = ++x * --x;
&lt;/syntaxhighlight&gt;

Wird die Multiplikation von links nach rechts ausgewertet, ergibt sich für die Variable y der Wert 2, wird die Multiplikation von rechts nach links ausgewertet, ergibt sich für die Variable y der Wert 0. Derselbe Quelltext kann auf zwei verschiedenen Systemen also völlig andere Rechenergebnisse hervorrufen.

In anderen Programmiersprachen werden die Inkremente und Dekremente von ganzzahligen Variablen daher mit Prozeduraufrufen bewerkstelligt (beispielsweise INC() und DEC()), die fester Bestandteil der Programmiersprache sind, wie zum Beispiel in Pascal, wo der Zuweisungsoperator aus zwei verschiedenen Zeichen besteht (&quot;:=&quot;), damit es keine Verwechslungen mit einem Identitätsoperator oder Vergleichsoperator geben kann:

&lt;syntaxhighlight lang=&quot;pascal&quot;&gt;
(* Programmiersprache Pascal *)
 VAR
    x, y, produkt: integer;
 BEGIN
    x := 1;
    INC (x);
    y := x;
    DEC (x);
    produkt := y * x;
 END;
&lt;/syntaxhighlight&gt;

Die Aufrufe der Inkrement- beziehungsweise Dekrementprozeduren dürfen und können –&amp;nbsp; genauso wie Zuweisungen&amp;nbsp;– in der Programmiersprache Pascal also gar nicht Bestandteil eines arithmetischen Ausdrucks sein, so dass der Zeitpunkt der Ausführung immer eindeutig aus der Reihenfolge der Anweisungen hervorgeht.

===Ternäre Operatoren===
Ein '''ternärer Operator''' hat als Ergebnis einen beliebigen Wert und verknüpft hierzu drei Ausdrücke:

* Der erste Ausdruck ein '''binärer Ausdruck''', der wahr oder falsch ist.
* Der zweite Ausdruck beschreibt den Ergebniswert, wenn der erste Ausdruck '''wahr''' ist.
* Der dritte Ausdruck beschreibt den Ergebniswert, wenn der erste Ausdruck '''falsch''' ist.

In vielen Programmiersprachen werden die drei Ausdrücke mit den Begrenzungszeichen ? und : voneinander getrennt, und der binäre Ausdruck wird eingebettet in runde Klammern vorangestellt:

 (binärer Ausdruck) ? zweiter Ausdruck : dritter Ausdruck

Jeder dieser drei Ausdrücke kann sich wiederum aus mehreren anderen Ausdrücken zusammensetzen, so dass der Überblick schnell verloren gehen kann.

Die Ergebniswerte von Ausdrücken mit ternären Operatoren sollten besser nicht in andere Ausdrücke eingesetzt werden, sondern in einer lokalen Variable zwischengespeichert und erst danach weiterverwendet werden:

 variable ergebnis;
 ergebnis ← (binärer Ausdruck) ? zweiter Ausdruck : dritter Ausdruck

Grundsätzlich ist es wegen der größeren Übersichtlichkeit, Transparenz und einfacheren Modifikation vorzuziehen, für das Ergebnis gar '''keine ternären Operatoren''' zu verwenden, sondern eine '''bedingte Anweisung mit Blockanweisungen''' zu verwenden:

 variable ergebnis;
 falls (binärer Ausdruck)
 dann
    Block für ergebnis ← zweiter Ausdruck
 ansonsten
    Block für ergebnis ← dritter Ausdruck
 ende

===Blockanweisungen===
'''Blockanweisungen''' sind ein elegantes Mittel, um Programmcode zu strukturieren sowie die Sichtbarkeit von lokalen Variablen zu begrenzen. In vielen Programmiersprachen werden eindeutige Symbole für die Kennzeichnung von Programmblöcken verwendet, wie zum Beispiel geschweifte Klammern:

 {
    ...
 }

Die drei Punkte stehen hierbei für beliebige Anweisungsfolgen.

In anderen Programmiersprachen werden Schlüsselwörter für die Begrenzung von Blockanweisungen verwendet, wie zum Beispiel &quot;BEGIN&quot; und &quot;END&quot;:

 BEGIN
    ...
 END

Der Blockinhalt mit Anweisungen -&amp;nbsp;in beiden obenstehenden Beispielen durch die drei aufeinanderfolgenden Punkte symbolisiert&amp;nbsp;-, wird in der Regel eingerückt, um die Lesbarkeit des Quelltextes für die Programmierer zu erleichtern.

Blockanweisungen können geschachtelt, dürfen -&amp;nbsp;sofern in der Syntax einer Programmiersprache überhaupt möglich&amp;nbsp;- jedoch nicht verschränkt werden. Dies bedeutet, dass bei geschachtelten Blöcken ein begonnener Block immer erst vollständig abgearbeitet werden muss, bevor der nächstäußere weitergeführt und abgeschlossen werden kann:

 {
    ... /* Äußerer Block */
    {
       ... /* Mittlerer Block */
       {
          ... /* Innerer Block */
       }
       ... /* Mittlerer Block */
    }
    ... /* Äußerer Block */
 }

Verschränkte Blockanweisungen sind unsinnig, unstrukturiert sowie überflüssig und daher in den meisten Programmiersprachen nicht zulässig:

 BEGIN1
    ...
    BEGIN2
       ...
    ...
 END1
 ...   ...
    END2

Die Implementationen von allen Modulen, Klassen und Unterprogrammen sowie auch von allen Kontrollstrukturen (also Fallunterscheidungen und Schleifen) sollten '''kategorisch mit Blockanweisungen''' strukturiert werden.

=== Blockanweisungen bei Kontrollstrukturen ===
[[Datei:lineareAnw.png|mini|rechts|hochkant=2|Struktogramm einer Anweisungsfolge.]]

Auch wenn die Programmiersprache die Verwendung von Blockanweisungen für Anweisungsfolgen in einer Kontrollstruktur nicht vorschreibt, ist es sehr ratsam, die Blockanweisung kategorisch einzusetzen, um Programmierfehler zu vermeiden. Wenn zum Beispiel eine if-Anweisung so wie in den Programmiersprachen C und Java so strukturiert ist, dass genau eine Folgeanweisung ausgeführt wird, wenn die Bedingung wahr ist, kann es ohne Blockanweisungen bei der Programmentwicklung oder -wartung leicht zu übersehenden Programmierfehlern kommen. Im folgenden korrekt formulierten Java-Programmbeispiel wird die Variable v1 auf den Wert null zurückgesetzt, falls sie den gleichen Zahlenwert wie max hat:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
    v1 = 0;
&lt;/syntaxhighlight&gt;

Soll zudem auch noch eine Textausgabe erfolgen, kann diese zusätzlich programmiert werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
    v1 = 0;
    java.lang.System.out.println (&quot;Der Maximalwert wurde erreicht.&quot;);
&lt;/syntaxhighlight&gt;

Die unterste Programmierzeile ist zwar eingerückt, was suggeriert, dass sie nur ausgeführt wird, wenn die darüberstehende Bedingung erfüllt ist. Ein Java-Interpreter führt jedoch nur eine einzige unmittelbar nach der Bedingung aufgeführte Anweisung aus, wenn die Bedingung wahr ist. Mit anderen Worten: die Textausgabe erfolgt im obigen Programmbeispiel immer, also insbesondere auch wenn die Variablen v1 und max nicht den gleichen Zahlenwert haben. Im Quelltext sollte das daher besser folgendermaßen formuliert werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
    v1 = 0;
 java.lang.System.out.println (&quot;Der Maximalwert wurde erreicht.&quot;);
&lt;/syntaxhighlight&gt;

Ähnlich tückisch ist die Tatsache, dass in manchen weniger streng strukturierten Programmiersprachen, auf die Bedingung der if-Anweisung eine beliebige Anweisung folgen darf, die nicht notwendigerweise eine Blockanweisung sein muss, sondern auch eine einzelne Anweisung sein darf, die zum Beispiel mit einem Semikolon abgeschlossen wird und auch eine '''leere Anweisung''' sein kann. Dies führt zu leicht zu übersehenden Programmierfehlern, wie im folgenden Beispiel:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max);
 {
    v1 = 0;
    java.lang.System.out.println (&quot;Der Maximalwert wurde erreicht.&quot;);
 }
&lt;/syntaxhighlight&gt;

Die Blockanweisung wird immer ausgeführt, obwohl ihre Darstellung mit korrekter Einrückung suggeriert, dass sie nur dann ausgeführt wird, wenn die boolesche Bedingung (v1 == max) erfüllt ist. Dies ist allerdings nicht der Fall, da direkt hinter den runden Klammern der if-Anweisung ein Semikolon steht, welches eine '''leere Anweisung''' implementiert, die bei der Erfüllung der Bedingung ausgeführt wird.

All diese Missverständnisse können leicht vermieden werden, indem bei der Programmierung von Kontrollstrukturen '''kategorisch Blockanweisungen''' verwendet werden, selbst wenn die Programmiersprache dies nicht fordert:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
 {
    v1 = 0;
 }
&lt;/syntaxhighlight&gt;

Beziehungsweise:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
 {
    v1 = 0;
    java.lang.System.out.println (&quot;Der Maximalwert wurde erreicht.&quot;);
 }
 else
 {
    java.lang.System.out.println (&quot;Der Maximalwert wurde nicht erreicht.&quot;);
 }
&lt;/syntaxhighlight&gt;

==== Verschachtelung ====
In noch stärkerem Maße leidet die Verständlichkeit von Quellcode, wenn mehrere Kontrollstrukturen ohne die Verwendung von Blockstrukturen verschachtelt werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long v1, v2, v3;
 v1 = 3;
 v2 = 3;
 v3 = 7;
 if ((v1 &gt; 0) &amp;&amp; (v2 &gt; 0))
    if (v1 &gt; v2)
       v3 = v1 - v2;
 else
    v3 = v2 - v1;
 java.lang.System.out.println (&quot;v3 = &quot; + v3);
&lt;/syntaxhighlight&gt;

Beim Lesen des Quellcodes mit einer solchen &quot;baumelnden&quot; ''else''-Anweisung (englisch: ''dangling else'') kann schnell der Eindruck entstehen, dass sie zur ersten ''if''-Anweisung gehört und das Ergebnis für die Variable ''v3'' 7 bleibt, da ''v1'' und ''v2'' positive Zahlen sind. Tatsächlich wird der Quellcode jedoch so ausgeführt, so dass die Variable ''v3'' den Wert 0 erhält.

Um solche Missverständnisse zu vermeiden, ist es -&amp;nbsp;wie oben bereits erwähnt&amp;nbsp;- dringend geboten, Blockanweisungen kategorisch einzusetzen, auch wenn sie durch die Definition der Programmiersprache nicht sowieso vorgeschrieben sind:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long v1, v2, v3;
 v1 = 3;
 v2 = 3;
 v3 = 7;
 if ((v1 &gt; 0) &amp;&amp; (v2 &gt; 0))
 {
    if (v1 &gt; v2)
    {
       v3 = v1 - v2;
    }
    else
    {
       v3 = v2 - v1;
    }
 }
 java.lang.System.out.println (&quot;v3 = &quot; + v3);
&lt;/syntaxhighlight&gt;

==Wertebereiche==
===Division durch null===
Im Zusammenhang mit dem '''Divisionsoperator''' gibt es in allen Programmiersprachen das Problem, dass der Divisor nicht null werden darf.

Die Division durch null kann und sollte kategorisch durch eine geeignete Kontrollstruktur mit dem Vergleichsoperator &quot;&lt;&gt;&quot; verhindert werden, der nur bei Ungleichheit der beiden Operanden den Ergebniswert &quot;wahr&quot; erzeugt:

 if (divisor &lt;&gt; 0)
 {
    quotient ← dividend / divisor
 }
 else
 {
    /* Ausnahmebehandlung / Fehlermeldung */
 }

===Wertebereichsprüfung===
Bei Parametern mit eingeschränktem zulässigen Wertebereich kann eine allgemeine und an allen entsprechenden Stellen verwendbare Funktion programmiert werden, die den gültigen Wertebereich überprüft und einen entsprechenden (häufig zweiwertigen respektive booleschen) Funktionswert zurückgibt, wie zum Beispiel die folgende Funktion &quot;waterIsLiquid &quot;, die überprüft, ob die Wassertemperatur zwischen 0° und 100° Celsius liegt, bevor das spezifische Gewicht des Wassers berechnet werden darf:

 boolean waterIsLiquid (double temperature) /* temperature in degrees Celsius */
 {
    final long freezingPoint ← 0;
    final long boilingPoint  ← 100;
    boolean waterIsLiquid ← (temperature &gt; freezingPoint) and (temperature &lt; boilingPoint);
    return waterIsLiquid;
 }
 
 ...
 
 double temperature, density;
 
 ...
 
 if waterIsLiquid (temperature)
 {
    /* function computes an approximation of the density of air-free liquid water in kilograms per cubic metre */
    density ←
       (    999.83952
          + (16.945176 * temperature)
          - (0.0079870401 * temperature * temperature)
          - (0.000046170461 * temperature * temperature * temperature)
          + (0.00000010556302 * temperature * temperature * temperature * temperature)
          - (0.00000000028054253 * temperature * temperature * temperature * temperature * temperature)
       ) / ((0.01689785 * temperature) + 1);
 }
 else
 {
    /* exception handling, because water is not liquid */
 }

===Parameterkombinationen===
Es ist wichtig, dass immer alle auftretenden Parameterkombinationen berücksichtigt und vom Programmcode verarbeitet werden, wenn aus diesen Parametern valide berechnete Werte abgeleitet werden sollen.

Um zum Beispiel das Argument (also den Phasenwinkel zwischen -180° und +180°) einer komplexwertigen Zahl mit den reellwertigen Komponenten x und y über den Arcustangens (&quot;arctan&quot;) zu berechnen, muss geprüft werden, ob der Parameter x gleich null ist, und welche Vorzeichen die Parameter x und y haben:

 double x
 double y
 
 ...
 
 double argument
 
 if (x = 0)
 {
    if (y &gt; 0)
    {
       argument ← 90
    }
    elseif (y &lt; 0)
    {
       argument ← -90
    }
    else /* y is equal to 0, too */
    {
       stop /* argument is not defined */
    }
 }
 else /* x is not equal to 0 */
 {
    argument ← arctan (y / x)
    if (x &lt; 0)
    {
       if (y &gt;= 0)
       {
          argument ← argument + 180
       }
       else /* both, x and y are less than 0 */
       {
          argument ← argument - 180
       }
    }
 }

==Schnittstellen==
Schnittstellen definieren die Sichtbarkeits- und Zugriffsregeln zwischen verschiedenen Bestandteilen eines Programms und ermöglichen so die Interaktion zwischen diesen. Dabei ist es keineswegs sinnvoll, alle Bezeichner überall sichtbar zu machen, da dadurch die Übersichtlichkeit und Nachvollziehbarkeit insgesamt drastisch eingeschränkt wird. Dies führt letztlich zu Programmfehlern, da der Programmierer wegen der großen zu berücksichtigenden Datenmenge nicht mehr in der Lage ist, alle Implikationen seiner Arbeit zu überschauen.

Alle Eigenschaften (Attribute) und Methoden (Werkzeuge), die zusammengehören (aber auch nur diese), sollen in jeweils einer Einheit zusammengefasst werden, wie zum Beispiel einer Klasse oder einem Modul. Oft wird eine solche Einheit in einer Quelltextdatei zusammengefasst, was sinnvoll ist und die Nachvollziehbarkeit erleichtert.

Nur diejenigen Eigenschaften und Methoden, die außerhalb dieser Einheiten benutzt werden sollen oder müssen, dürfen mit einem Modifikator versehen werden, der dies ermöglicht (zum Beispiel &quot;public&quot;). Alle anderen Eigenschaften und Methoden sollten explizit als intern (zum Beispiel &quot;private&quot;) deklariert sein. ''packages'' sind wegen der unübersichtlichen Sichtbarkeitsregeln (zum Beispiel durch den Modifikator &quot;protected&quot;) als Zwischenebene entbehrlich und eher zu vermeiden. Alternativ können ohne weiteres längere, zusammengesetzte Klassennamen verwendet werden, um die Zugehörigkeit zu einem bestimmten Themenbereich zu kennzeichnen, wie zum Beispiel mit einfachen Bezeichnern:

 StatisticsMyEvaluation
 StatisticsMyAssessment

Diese Bezeichner sind in der Regel unmittelbar mit den Programmdateien im Dateisystem korreliert. Hierbei sind also keine '''qualifizierten Bezeichner''' auf verschiedene Konstrukte erforderlich, die hier im Beispiel aus mehreren Bezeichnern mit zwischengestellten Punkten zusammengesetzt sind. Links vom Punkt steht der Bezeichner der Programmbibliothek (Modulsammlung, Paket), und rechts vom Punkt steht der Bezeichner für ein Programmbaustein (Modul, Klasse):

 package statistics
 
 statistics.MyEvaluation
 statistics.MyAssessment

===Importe===
====Import-Anweisungen====
'''Import-Anweisungen''' werden häufig nicht dazu benutzt anzumelden und anzuzeigen, welche externen Module (respektive Klassen) in einer Quelldatei verwendet werden, sondern werden als Möglichkeit missbraucht, den Quelltext möglichst kurz zu fassen.

Nicht:

 import MyModule
 ...
 drawLine ()
 ...

Sondern eindeutig mit qualifiziertem Bezeichner:

 ...
 MyModule.drawLine ()
 ...

Mit diesen qualifizierten Bezeichnern ist es dann auch einfach und eindeutig möglich, gleichnamige Bezeichner, wie zum Beispiel für die Methode ''drawLine'', aus verschiedenen Klassen zu benutzen:

 ...
 MyModule.drawLine ()
 YourModule.drawLine ()
 ...

Die Erkennbarkeit der Herkunft eines importierten Bezeichners an jeder Stelle des Auftretens in einem Quelltext ist in der Regel von großer Nützlichkeit, insbesondere wenn andere Programmierer den Quelltext nachvollziehen können sollen oder wenn der Quellcode nach längerer Zeit gewartet werden soll.

Insbesondere Import-Anweisungen mit Wildcards sind schlecht nachvollziehbar (auch wenn viele Entwicklungssysteme Funktionen für eine gewisse Transparenz bieten), so wie zum Beispiel:

 import myPackage.*
 import yourPackage.*
 
 drawLine () /* To which package does the method &quot;drawLine&quot; belong? */
 
 Class var ← new Class () /* To which package does the class &quot;Class&quot; belong? */

====Zyklische Importe====
[[Datei:Zyklischer.Import.png|mini|rechts|hochkant=2|Zyklische Importe durch Aufruf (&quot;call&quot;) des Unterprogramms (&quot;procedure&quot;) '''sum''' aus der Klasse '''B''' in das Unterprogramm '''add''' der Klasse A sowie Aufruf des Unterprogramms '''add''' aus der Klasse '''A''' in das Unterprogramm '''sum''' der Klasse '''B'''.]] 

'''Zyklische Importe''' beziehungsweise Zirkelbezüge sind nicht nur unübersichtlich, sondern auch unstrukturiert und können zu Speicherüberläufen führen, da sich Programmteile immer wieder gegenseitig aufrufen, ohne beendet zu werden. Ferner kann die Funktion des übersetzten Programms bei einer Optimierung des Codes von der Reihenfolge der Übersetzung der Quelltexte abhängen. Die Schnittstellen der Klassen und Module können im Allgemeinen weder unabhängig voneinander noch eindeutig überprüft werden.

'''Beispiel''': Die beiden Funktionen Funktionen ''add'' aus der Klasse ''A'' und ''sum'' aus der Klasse ''B'' rufen sich endlos gegenseitig auf, um die Summe zweier Zahlenwerte zu berechnen, bis der Speicher überlaufen würde und das Laufzeitsystem die Ausführung deswegen abbricht oder der Speicher überläuft, das Programm unkontrolliert und ohne (nachvollziehbare) Fehlermeldung abstürzt.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

 public class A
 {
    public int procedure add (int a, int b)
    {
       int result ← B.sum (a, b);
       return result;
    }
 }

 public class B
 {
    public int procedure sum (int x, int y)
    {
       int result ← A.add (x, y);
       return result;
    }
 }

[[Datei:Circular Reference.svg|mini|rechts|hochkant=1|Variante von Abhängigkeiten zwischen Modulen oder Klassen, in denen die zyklischen Bezüge weniger offensichtlich sind, wenn nur der nächste Nachbar betrachtet wird. Der dunkelrote Pfeil oben rechts zeigt nach unten auf ein bereits vorher definiertes Element, das sich rechts in der Mitte befindet. Die Definition dieses Elements darf bei einem strukturierten Aufbau der Programmteile allerdings nicht von dem Element ober rechts abhängig sein.]]

Solche zyklischen Abhängigkeiten können durch Verzweigungen und indirekte Aufrufe wesentlich weniger offensichtlich sein, und sind dann nur sehr schwierig zu erkennen und zu beheben. Sichere Programmiersprachen überprüfen solche zyklischen Zusammenhänge daher und lassen sie nicht zu.

In der Regel ist es bei der Anwendung von rekursiven Programmiertechniken mit wohldefinierten Abbruchbedingungen möglich, ohne zyklische Modulabhängigkeiten auszukommen. Ein Übersetzer kann in den Metadaten von Programm-Modulen Zeitstempel verwenden, um bei der Interpretation eines Programmteils herausfinden zu können, ob alle anderen importierten Programmteile bereits vorher gültig übersetzt wurden.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Nebeneffekte==
'''Nebeneffekte''' treten auf, wenn der Programmierer von naheliegenden, jedoch falschen Annahmen ausgeht, die die Programmiersprache betreffen. Solche Nebeneffekte sind unerwünscht und können durch ein strukturiertes Vorgehen oft leicht vermieden werden.

===Durch arithmetischen Überlauf===
Als Indiz für solche Nebeneffekte möge folgendes Beispiel in Java dienen, bei dem die Dezimalzahl 127 (die hexadezimale Repräsentation dieses Zahlenwerts ist durch die acht Ziffern 7F gegeben) um eins erhöht wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 byte zahl = 127;
 java.lang.System.out.println (&quot;zahl = &quot; + zahl);
 zahl++;
 java.lang.System.out.println (&quot;zahl = &quot; + zahl);
&lt;/syntaxhighlight&gt;

Diese Anweisungsfolge erzeugt die Ausgabe:

:zahl = 127
:zahl = -128

Wenn die größte mit dem Datentyp &quot;byte&quot; darstellbare Zahl 127 mit dem Inkrement-Operator ++ um eins erhöht wird, ergibt sich durch arithmetischen Überlauf als Ergebnis die kleinste darstellbare ganze Zahl 128.

Dass solche Nebeneffekte auch in Standard-Bibliotheken versteckt sein können, möge das folgende Beispiel in Java zeigen, bei dem die Dezimalzahl -1 (die hexadezimale Repräsentation dieses Zahlenwerts ist durch die acht Ziffern FFFFFFFF gegeben) mit zwei verschiedenen Unterprogrammen ausgegeben werden soll (Stand 2026):

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 long zahl = 0xFFFFFFFF;
 java.lang.System.out.println (&quot;dezimal: &quot; + zahl);
 java.lang.System.out.print (&quot;hexadezimal: &quot;);
 java.lang.System.out.printf (&quot;%h\n&quot;, zahl);
&lt;/syntaxhighlight&gt;

Diese Anweisungsfolge erzeugt die Ausgabe:

:dezimal: -1
:hexadezimal: 0

Die Methode &quot;printf&quot; für die Ausgabe im hexadezimalen Format (Steuersequenz h%), ruft die statische Methode &quot;formatUnsignedLong0&quot; aus der Klasse &quot;Long&quot; aus dem package &quot;java.lang&quot; im Modul &quot;java.base&quot; der Java-Standardbibliothek auf und gibt den Wert 0 aus, obwohl der korrekte hexadezimale Wert FFFFFFFF lautet. Der Fehler entsteht bei der internen Berechnung, bei der es einen arithmetischen Überlauf gibt, der nicht explizit abgefangen wird.

===Durch Rundung===
Manchmal ist es schwierig zu erkennen, dass das Ergebnis einer Operation nicht dem exakten Ergebnis entspricht, das mathematisch zu erwarten wäre, weil es Rundungsfehler gibt. Gleitkommazahlen können nicht mit beliebig hoher Präzision gespeichert werden, und daher können sich dadurch solche Rundungsfehler auch mit einer völlig unerwarteten Wirkung ergeben. Hier ein Beispiel in der Programmiersprache Java für ein System mit einer Speichertiefe von 64 Bit:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 double a = 4.4;
 double b = 3.3;
 java.lang.System.out.println (a - b);
&lt;/syntaxhighlight&gt;

Die Ausgabe lautet nicht &quot;1.1&quot; wie zu erwarten wäre, sondern:

:1.1000000000000005

Noch schwieriger ist es, wenn das Kommutativ-, das Distributiv- oder das Assoziativgesetz nicht zu gelten scheinen, wie in diesem Beispiel, bei dem die Variable &quot;b&quot; einmal zur Variable &quot;a&quot; und einmal zur Variable &quot;c&quot; assoziiert ist:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 double a = 4.4;
 double b = 3.3;
 double c = 1.1;
 java.lang.System.out.println ((a - b) - c);
 java.lang.System.out.println (a - (b + c));
&lt;/syntaxhighlight&gt;

Mathematisch kommt in beiden Fällen exakt der Wert null heraus, die Ausgabe lautet jedoch:

:4.440892098500626E-16
:0.0

Die Wirkung von derartigen Nebeneffekten sind nur sehr schwierig zu beherrschen, und daher sollte beim Vergleichen von Gleitkommawerten die Präzision respektive die Maschinengenauigkeit der gespeicherten Werte berücksichtigt werden. Manche Programmiersprachen stellen hierfür einen Wert für die kleineste relative Genauigkeit von Gleitkommazahlen &lt;math&gt;\epsilon&lt;/math&gt; (epsilon) zur Verfügung. Das folgende Beispiel für den Datentyp double mit 64 Bit Speichertiefe nach dem Standard IEEE 754 in der Programmiersprache Java mit einem Wert für &lt;math&gt;\epsilon = 10^{-15}&lt;/math&gt; nach der Formel:

:&lt;math&gt;\Bigg| {\frac {differenzBerechnet - differenzErwartet} {differenzErwartet}} \Bigg| &lt; \epsilon&lt;/math&gt;

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 double a = 4.4;
 double b = 3.3;
 double differenzBerechnet = a - b;
 double differenzErwartet = 1.1;

 boolean gleichheit1 = (differenzBerechnet == differenzErwartet);
 java.lang.System.out.println (gleichheit1);

 double epsilon = 1.0E-15;
 boolean gleichheit2 = java.lang.Math.abs ((differenzBerechnet - differenzErwartet) / differenzErwartet) &lt; epsilon;
 java.lang.System.out.println (gleichheit2);
&lt;/syntaxhighlight&gt;

Die Ausgabe lautet hier:

:false
:true

===Durch Reihenfolge===
In einigen Programmiersprachen ist die Reihenfolge der Abarbeitung von kombinierten Ausdrücken nicht explizit definiert und führt daher zu einem solchen Nebeneffekt.

Die Anweisungen

 h ← f (x) + g (x)

oder

 h ← g (x) + f (x)

können je nach Compiler zu unterschiedlichen Ergebnissen für die Summe h führen. Die Methodenaufrufe f oder g können nämlich unter Umständen die als Parameter verwendete (lokale) Variable x verändern und somit gegebenenfalls verschiedene Werte für h erzeugen, je nachdem, ob zuerst f&amp;nbsp;(x) oder g&amp;nbsp;(x) ausgewertet wird. In solchen Programmiersprachen sind sogenannte Durchgangsparameter in kombinierten Ausdrücken zu vermeiden.

Ferner ist es denkbar, dass durch den ersten Funktionsaufruf globale Variablen oder Instanzen verändert und beim zweiten Funktionsaufruf verwendet werden.

Die erwünschte Reihenfolge von Funktionsaufrufen kann leicht durch entsprechende Code-Sequenzen mit sequentiellen Anweisungen erzwungen werden:

 result_f ← f (x)
 result_g ← g (x)
 h ← result_f + result_g

Dieses Vorgehen erzeugt darüberhinaus den günstigen Umstand, dass die Zwischenergebnisse in lokalen Variablen gespeichert und somit abgefragt werden können. Diese sind nach einem Programmabbruch dann auch mit einem Post-Mortem-Debugger analysierbar.

===Durch Kombination von Operatoren===
Manche Programmiersprachen -&amp;nbsp;insbesondere in der C-Sprachfamilie&amp;nbsp;- erlauben die Kombination von Zuweisungsoperatoren und arithmetischen Operatoren.

 Zuweisungsoperator: =
 Arithmetische Operatoren: + - * /
 Kombinierte Operatoren: += -= *= /=

Die kombinierten Operatoren sollen für die scheinbar äquivalenten Formulierungen mit getrenntem Zuweisungsoperator und arithmetischem Operator stehen:

 a += 1; steht für a = a + 1;
 a -= 1; steht für a = a - 1;
 a *= 1; steht für a = a * 1;
 a /= 1; steht für a = a / 1;

Diese Schreibweisen sollen wohl vor allem ein wenig Schreibarbeit bei der Programmierung ersparen, können aber zu schwer zu identifizierenden Programmierfehlern führen, wie das folgende Java-Beispiel verdeutlichen soll:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
	long a = 1;
	double b = 1.5;
	a *= b;
	java.lang.System.out.println (a);
	a += b;
	java.lang.System.out.println (a);
	a -= b;
	java.lang.System.out.println (a);
&lt;/syntaxhighlight&gt;

Dieser Code erzeugt die Ausgabe:

 1
 2
 0

Die nur scheinbar äquivalenten Formulierungen für die kombinierten Operatoren

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
	a = a * b;
	a = a + b;
	a = a - b;
&lt;/syntaxhighlight&gt;

werden in Java wegen der mangelnden Zuweisungskompatibilität der arithmetischen Ausdrücke hinter dem Zuweisungsoperator vom Datentyp &quot;double&quot; zum Datentyp &quot;long&quot; der Variable &quot;a&quot; gar nicht übersetzt.

Die tatsächlichen äquivalenten Formulierungen für die kombinierten Operatoren lauten nämlich wie folgt:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
	a = (long) (a * b);
	a = (long) (a + b);
	a = (long) (a - b);
&lt;/syntaxhighlight&gt;

Durch die impliziten Datentypumwandlungen erklären sich auch die falschen numerischen und gegebenenfalls nicht erwarteten ganzzahligen Ergebnisse. Wenn bei der Programmierung diese Tatsachen nicht bewusst sind oder übersehen werden, ergeben sich numerische Fehler in den arithmetischen Berechnungen. Dies kann einfach vermieden werden, indem kombinierte Operatoren zugunsten der expliziten sowie transparenten Formulierungen mit separaten Operatoren nicht verwendet werden.

=== Durch Sprachdefinition ===
Als Beispiel dient hier die scheinbar falsche Ausgabe eines Java-Programms, weil die Definition der Programmiersprache der Intuition widerspricht:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long i = 01234567;
 java.lang.System.out.println (i);
&lt;/syntaxhighlight&gt;

Dieser Code erzeugt die Ausgabe:

 342391

Das Literal &quot;01234567&quot; wird trotz der ausschließlichen Verwendung von gültigen dezimalen Ziffern nicht als die Dezimalzahl 1234567&lt;sub&gt;10&lt;/sub&gt; interpretiert und ausgegeben, sondern entsprechend der Definition der Programmiersprache Java wegen der einleitenden Null als Oktalzahl zur Basis Acht, also als 1234567&lt;sub&gt;8&lt;/sub&gt; = 342391&lt;sub&gt;10&lt;/sub&gt;.

=== Durch Überladen ===
Eine Überladung liegt vor, wenn eine Operator oder ein Bezeichner mehrfach in verschiedenen Bedeutungen auftritt, die leicht zu Verwechslungen führen können. Streng strukturierte Programmiersprachen erlauben das polymorphe Überladen nicht, wenn es dadurch zu Programmierfehlern kommen kann.

Das '''Überladen''' muss in der objektorientierten Programmierung vom '''Überschreiben''' unterschieden werden, wobei auch überschriebene Methoden in weniger strukturierten Programmiersprachen überladen werden dürfen, was ebenfalls zu unübersichtlichem Programmcode und schnell zu übersehenden Programmierfehlern führen kann. Siehe hierzu unten unter [[Strukturierte Programmierung#Überladung|Überladung]].

==== Überladung von Divisionsoperatoren ====
Die Divisionsoperatoren sind in vielen Programmiersprachen leider überladen, wenn nämlich formal keine Unterscheidung zwischen Division mit ganzen Zahlen (Datentyp zum Beispiel &quot;long&quot; oder &quot;int&quot;) und Gleitkommazahlen (Datentyp zum Beispiel &quot;real&quot; oder &quot;double&quot;) gemacht wird. In diesen Fällen muss der Divisionsoperator sehr aufmerksam verwendet werden:

 int i ← 2;
 int j ← 1;
 real k ← j / i; /* Ueberladener Divisionsoperator mit zwei ganzzahligen Operanden */

Verwendet die Programmiersprache im arithmetischen Ausdruck die ganzzahlige Division, hat dies zur Folge, dass die Variable k den Wert '''0''' erhält. Verwendet die Programmiersprache stattdessen die reelwertige Division, bekommt die Variable k den Wert 0,5 zugewiesen.

Einige Programmiersprachen unterscheiden daher sinnvollerweise explizit zwischen einem Operator für die ganzzahlige Division (&quot;div&quot; oder &quot;DIV&quot;) und einem Operator für die Gleitkommadivision (&quot;/&quot;).

&lt;syntaxhighlight lang=&quot;pascal&quot;&gt;
(* Programmiersprache Pascal *)
 i, j : integer;
 k : real;
 i := 2;
 j := 1;
 k := j / i; (* Gleitkommazahliger Divisionsoperator mit zwei ganzzahligen Operanden *)
&lt;/syntaxhighlight&gt;

In der letzten Anweisung wird der Variablen &quot;k&quot; der Zahlenwert der reellwertigen Division '''0,5''' zugewiesen.

&lt;syntaxhighlight lang=&quot;pascal&quot;&gt;
(* Programmiersprache Pascal *)
 i, j, k : integer;
 i := 2;
 j := 1;
 k := j div i; (* Ganzzahliger Divisionsoperator mit zwei ganzzahligen Operanden *)
&lt;/syntaxhighlight&gt;

In der letzten Anweisung wird der Variablen &quot;k&quot; der Zahlenwert der ganzzahligen Division '''0''' zugewiesen.

Bei Programmiersprachen, die die Unterscheidung der Divisionsoperatoren nicht unterstützen, ist die Verwendung der expliziten und zuweisungskompatiblen Datentypumwandlung (englisch: ''type cast'') nicht nur sinnvoll, sondern sogar zwingend erforderlich:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long i = 2;
 long j = 1;
 double k = ((double) j) / ((double) i) /* Ueberladener Divisionsoperator mit zwei gleitkommazahligen Operanden */
&lt;/syntaxhighlight&gt;

In der Regel ist es für eine Gleitkommadivision hierbei ausreichend, wenn nur einer der beiden Operanden, also nur der Nenner (Dividend) oder der nur Zähler (Divisor) der Division, eine Gleitkommazahl darstellt.

Entsprechende Überlegungen gelten auch für alle '''Modulo-Operatoren''' (wie zum Beispiel &quot;%&quot;, &quot;mod&quot; oder &quot;MOD&quot;).

==== Überladung von Variablen ====
Oft ist es in einer Programmiersprache erlaubt, dieselben Bezeichner für Variablen mit verschiedenen Sichtbarkeitsbereichen zu verwenden. Dies kann sehr einfach zur Verwechslung dieser Variablen führen, wie im folgenden Java-Beispiel verdeutlicht wird, wo es sowohl eine globale Klassenvariable (Sichtbarkeit in der Klasse &quot;OverloadedVariables&quot;) als auch eine lokale Variable (Sichtbarkeit in der Methode &quot;main&quot;) mit dem Namen &quot;bezeichner&quot; gibt:&lt;syntaxhighlight lang=&quot;java&quot;&gt;
public class OverloadedVariables
{
	// globale Klassenvariable &quot;bezeichner&quot;
	private static long bezeichner = 1;

	// Hauptprogramm (Methode &quot;main&quot;)
	public static void main (java.lang.String [] argumente) 
	{
		// lokale Variable &quot;bezeichner&quot;
		long bezeichner = 2; 
		// Ausgabe der globalen Klassenvariable &quot;bezeichner&quot;
		java.lang.System.out.println (&quot;Wert der globalen Variable = &quot; + OverloadedVariables.bezeichner);
		// Ausgabe der lokalen Variable aus der Methode &quot;main&quot;
		java.lang.System.out.println (&quot;Wert der  lokalen Variable = &quot; + bezeichner);
	}
}
&lt;/syntaxhighlight&gt;Falls die Klassenvariable referenziert werden soll, muss sie in Java qualifiziert bezeichnet werden, indem der Name der Klasse vorangestellt wird.

==== Überladung von Methoden ====
Viele Programmiersprachen erlauben die Deklaration von mehreren Methoden mit gleichem Bezeichner, die sich in der Anzahl oder den Datentypen ihrer Parameter unterscheiden. Das folgende Java-Beispiel mit zwei Methoden demselben Namens, von denen die mit der passenden Datentyp des Parameters &quot;zahl&quot; aufgerufen wird, verdeutlicht dies:&lt;syntaxhighlight lang=&quot;java&quot;&gt;
	private static long kehrwert (long zahl)
	{
		long kehrwert = 1 / zahl;
		return kehrwert;
	}

	private static double kehrwert (double zahl)
	{
		double kehrwert = 1 / zahl;
		return kehrwert;
	}

	public static void main (java.lang.String [] argumente)
	{
		double kehrwert1 = kehrwert (2);
		double kehrwert2 = kehrwert (2.0);
		java.lang.System.out.println (&quot;Kehrwert 1 = &quot; + kehrwert1);
		java.lang.System.out.println (&quot;Kehrwert 2 = &quot; + kehrwert2);
	}
&lt;/syntaxhighlight&gt;Die Ausgabe ergibt zwei verschiedene Ergebnisse für den Kehrwert der Zahl Zwei:&lt;syntaxhighlight&gt;
Kehrwert 1 = 0.0
Kehrwert 2 = 0.5
&lt;/syntaxhighlight&gt;Durch die kategorische Verwendung verschiedener Bezeichner für verschiedene Methoden kann die Verwechslungsgefahr leicht und ohne Probleme verhindert werden, und die Erzeugung der beiden verschiedenen Ergebnisse wird transparent:&lt;syntaxhighlight lang=&quot;java&quot;&gt;private static long kehrwertLong (long zahl)
	{
		long kehrwert = 1 / zahl;
		return kehrwert;
	}

	private static double kehrwertDouble (double zahl)
	{
		double kehrwert = 1 / zahl;
		return kehrwert;
	}

	public static void main (java.lang.String [] argumente)
	{
		double kehrwert1 = kehrwertLong (2);
		double kehrwert2 = kehrwertDouble (2.0);
		java.lang.System.out.println (&quot;Kehrwert 1 = &quot; + kehrwert1);
		java.lang.System.out.println (&quot;Kehrwert 2 = &quot; + kehrwert2);
	}&lt;/syntaxhighlight&gt;

===Durch falsche Spezifikation===
In Programmiersprachen, die dynamische Variablen ausschließlich als Zeiger behandeln (wie zum Beispiel C oder C++), kann trotz exakter Übereinstimmung der referenzierten Datentypen bei einer Zuweisung des Ergebnisses einer Funktion ein Zeiger auf den lokalen Stapelspeicher der Funktion zurückgegeben werden, der nur während der Ausführung der Funktion, aber nicht mehr nach dem Rücksprung aus der Funktion gültig ist. Während der weiteren Programmausführung kann der Speicherbereich jederzeit überschrieben werden, ohne dass der Programmierer dies wünscht oder absehen kann.

Im folgenden Beispiel in der Programmiersprache C wird innerhalb der Funktion ''function'' der Wert 5 dem Datenfeld ''a'' der Variablen ''data'' zwar korrekt zugewiesen, kann aber nach dem Rücksprung aus der Funktion im Stapelspeicher jederzeit unbeabsichtigt verändert werden, wie zum Beispiel beim erneuten Aufruf einer Funktion oder anderen Operationen, die den Stapelspeicher verwenden:

&lt;syntaxhighlight lang=&quot;C&quot;&gt;
/* Programmiersprache C */

struct DataType { int a }; // Definition des Datentyps ''DataType'' mit einem ganzzahligen Datenfeld ''a''

// Deklaration der Funktion ''function'' mit einem Zeiger auf eine Variable vom Datentyp ''DataType'' als Speicheradresse für den Rückgabewert
DataType* function ()
{
  DataType data;           // Deklaration der lokalen Variable ''data'' vom Datentyp ''DataType''
  data.a = 5;              // Zuweisung des Wertes ''5'' zum Datenfeld ''a'' der Variablen ''data''
  return &amp;data;            // Rückgabe der lokalen, temporären Speicheradresse von ''data'', die nach der Beendigung des Funktionsaufrufs gar nicht mehr gültig ist.
}
&lt;/syntaxhighlight&gt;

Der Programmierer muss zur Abwendung dieses Übels darauf achten, dass Rückgabewerte durch Allokation einer entsprechenden Variablen in einem dauerhaft verfügbaren dynamischen Speicherbereich (also zum Beispiel im Heap-Speicher) auch nach dem Aufruf der Funktion noch gültig und korrekt aufrufbar sind.

Bei der Verwendung von vollständig typsicheren Programmiersprachen ist die Rückgabe von lokal definierten Adressen nicht zulässig, und die Übersetzung des entsprechenden Codes wird vom Complier von vornherein verweigert, so dass es gar nicht zu einem solchen Nebeneffekt kommen kann.

Alternativ kann der Datentyp ''DataType'' nicht direkt als Verbund, sondern als Zeiger auf einen entsprechenden Verbund deklariert werden. In diesem Fall muss in der Funktion zunächst eine Instanz erzeugt werden (beispielsweise mit dem Kommando ''new'' oder ''allocate''). Diese Instanz ist dann nicht mehr im lokalen Stapelspeicher (Stack) der Funktion gespeichert, sondern es kann im dynamischen Speicherbereich (Heap) global - also auch außerhalb der Funktion und nach Beendigung des Funktionsaufrufs - darauf zugegriffen werden.

===Durch Verwechslung von Speicherinhalt und Speicheradresse===
Die Werte von Variablen werden unter einer bestimmten Speicheradresse eines Computers gespeichert, wo vom Laufzeitsystem die für den entsprechenden Datentyp erforderliche Datenmenge der entsprechende Speicherplatz reserviert und bereitgehalten wird. Diese Speicheradresse wird in modernen Systemen in der Regel automatisch verwaltet, so dass sie im Allgemeinen gar nicht bekannt ist und auch gar nicht bekannt sein muss.

Daraus ergeben sich unter Umständen jedoch wichtige Implikationen. In manchen Programmiersprachen, wie zum Beispiel Java, ist nämlich nicht unmittelbar erkennbar, ob bei bestimmten Operationen der Speicherinhalt oder die Speicheradresse einer Variablen verwendet wird. So werden bei bei logischen Vergleichen mit Operanden, die aus Variablen mit einfachen Datentypen bestehen (etwa boolean, long oder double), die unter der Speicheradresse gespeicherten '''Werte''' verglichen, also die Inhalte. Bei Variablen mit komplexen Datentypen (beispielsweise eine abzählbare Liste von Daten eines Datentyps (array), ein Verbund (record / struct), der sich aus verschiedenen Datentypen zusammensetzen kann, oder allgemein in der objektorientierten Programmierung die Instanz eines Objekts) werden jedoch gar nicht unbedingt die gespeicherten Inhalte, sondern lediglich die Speicheradressen der beiden Operanden verglichen. Hier wird also beim Gleichheitsoperator nur geprüft, ob es sich um dasselbe Speicherobjekt (dieselbe Instanz) handelt, und nicht, ob zwei verschiedene Speicherobjekte den gleichen Inhalt haben. Bei strenger Strukturierung wird (hoffentlich schon vor der Ausführung bereits im Quelltext) zusätzlich geprüft, ob die zu vergleichenden komplexen Datentypen überhaupt zuweisungskompatibel und somit sinnvoll vergleichbar sind.

Unter welchen Umständen welche Speicheradressen für gleiche Speicherinhalte verwendet werden, ist insbesondere für unerfahrene Programmierer keineswegs immer naheliegend oder leicht nachzuvollziehen. Dies wird im Folgenden anhand des logischen Vergleichs auf Gleichheit von Zeichenketten (Java-Klasse java.lang.String) in der Programmiersprache Java verdeutlicht. Die Wirkungsweise des Gleichheitsoperators  == wird der Wirkungsweise des Funktionsaufrufs der Methode '''java.lang.String.equals''' gegenübergestellt, die einen booleschen Rückgabewert hat.

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
	boolean vergleich;

	// Die symbolische Konstante für die Zeichenkette &quot;abc&quot; wird in einer Variablen mit dem Bezeichner text verwaltet
	// Die Zeichenkette &quot;abc&quot; wird von Java unter der Speicheradresse #MEM1 abgelegt
	// Die Variable text und die symbolische konstante Zeichenkette &quot;abc&quot; haben dieselbe Speicheradresse #MEM1
	java.lang.String text = &quot;abc&quot;;

	// Vergleich der Speicheradresse #MEM1 mit der Speicheradresse #MEM1
	vergleich = (&quot;abc&quot; == &quot;abc&quot;);
	java.lang.System.out.println (&quot;1. Vergleich \&quot;abc\&quot; == \&quot;abc\&quot;: &quot; + vergleich);

	// Vergleich der Speicheradresse #MEM1 mit der Speicheradresse #MEM1 !!!
	vergleich = (text == &quot;abc&quot;);
	java.lang.System.out.println (&quot;2. Vergleich text == \&quot;abc\&quot;: &quot; + vergleich);

	// Vergleich des Inhalts bei der Speicheradresse #MEM1 mit dem Inhalt bei der Speicheradresse #MEM1
	vergleich = text.equals (&quot;abc&quot;);
	java.lang.System.out.println (&quot;3. Vergleich text.equals (\&quot;abc\&quot;): &quot; + vergleich);

	// Neue Instanz fuer die bereits oben deklarierte Zeichenkette text 
	// Die neue Instanz wird mit dem new-Operator unter der Speicheradresse #MEM2 erzeugt
	// Der Speicherinhalt wird mit dem Konstruktor java.lang.String und dem Wert &quot;abc&quot; initialisiert
	// Die Variable text bekommt durch die Zuweisung die Speicheradresse #MEM2
	text = new java.lang.String (&quot;abc&quot;);

	// Vergleich der Speicheradresse #MEM2 mit der Speicheradresse #MEM1 !!!
	vergleich = (text == &quot;abc&quot;);
	java.lang.System.out.println (&quot;4. Vergleich text == \&quot;abc\&quot;: &quot; + vergleich);

	// Vergleich des Inhalts bei der Speicheradresse #MEM2 mit dem Inhalt bei der Speicheradresse #MEM1
	vergleich = text.equals (&quot;abc&quot;);
	java.lang.System.out.println (&quot;5. Vergleich text.equals (\&quot;abc\&quot;): &quot; + vergleich);
&lt;/syntaxhighlight&gt;

Die Textausgabe dieses Programms sieht wie folgt aus:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
1. Vergleich &quot;abc&quot; == &quot;abc&quot;: true
2. Vergleich text == &quot;abc&quot;: true
3. Vergleich text.equals (&quot;abc&quot;): true
4. Vergleich text == &quot;abc&quot;: false
5. Vergleich text.equals (&quot;abc&quot;): true
&lt;/syntaxhighlight&gt;

Symbolisch konstante Zeichenketten, wie zum Beispiel der Ausdruck &quot;abc&quot;, werden unter einer verdeckten Speicheradresse abgelegt und von Java für gleichlautende Ausdrücke automatisch wiederverwendet. Wird jedoch mit dem new-Operator eine Instanz eines Objekts erzeugt, so bekommt diese unabhängig davon, welcher Inhalt dort gespeichert wird, stets eine andere neue Speicheradresse zugeordnet. Für den Vergleich des Inhalts von Zeichenketten auf Gleichheit ist in Java also immer die generische typengebundene Methode &quot;equals'' zu verwenden. Diese typengebundene Methode &quot;equals&quot; gibt es auch in vielen anderen Java-Klassen, um den Inhalt der entsprechenden Objektinstanzen auf Gleichheit vergleichen zu können.

==Strukturierte objektorientierte Programmierung==
===Vermeidung von Codewiederholung durch Vererbung===
Die Vermeidung von Codewiederholung durch Vererbung kann beispielsweise an den beiden graphischen Objekten '''Kreis''' und '''Dreieck''' deutlich gemacht werden. Diese beiden Objekte können unabhängig voneinander als Datentyp modelliert werden, wobei ihre gemeinsamen Eigenschaften '''Farbe''' und '''Strichstärke''', sowie die jeweilige Methode zum '''Zeichnen''' beide Male unabhängig behandelt werden (dies kann eindeutig durch '''Hat'''-Beziehungen ausgedrückt werden: ein Kreis oder ein Dreieck '''hat''' eine Farbe, eine Strickstärke sowie eine Methode zum Zeichnen), was eine Codewiederholung darstellt. Der '''Kreis''' hat zusätzlich das Attribut '''Radius''', und das '''Dreieck''' hat zusätzlich die drei Attribute '''SeiteA''', '''SeiteB''' und '''SeiteC''':

 Kreis   hat: Farbe, Strichstärke, Methode zum Zeichnen, Radius
 Dreieck hat: Farbe, Strichstärke, Methode zum Zeichnen, SeiteA, SeiteB, SeiteC

Mithilfe von Vererbung kann die Codewiederholung vermieden werden, indem die Attribute '''Farbe''' und '''Strichstärke''', sowie die Methode zum '''Zeichnen''' nur einmal mithilfe des abstrakten Objekts '''GraphischesObjekt''' deklariert werden. Die konkreten Objekte '''Kreis''' und '''Dreieck''' erben alle gemeinsamen Eigenschaften und Methoden (respektive typengebundenen Prozeduren) von '''GraphischesObjekt''' (dies kann eindeutig durch '''Ist'''-Beziehungen ausgedrückt werden: ein Kreis '''ist''' ein GraphischesObjekt, und ein Dreieck '''ist''' ein GraphischesObjekt) und werden nur durch die jeweils fehlenden Attribute ergänzt:

 GraphischesObjekt hat: Farbe, Strichstärke, Methode zum Zeichnen

 Kreis   ist GraphischesObjekt, hat zusätzlich: Radius
 Dreieck ist GraphischesObjekt, hat zusätzlich: SeiteA, SeiteB, SeiteC

===Überladung===
Das '''Überladen''' von Methoden, Konstruktoren oder Variablen ist auch bei objektorientierter Programmierung überflüssig, erschwert die Nachvollziehbarkeit vom Quellcode und birgt die Gefahr von Programmierfehlern, die unter Umständen erst lange nach der Entwicklung der Software bei deren Wartung entstehen. Das folgende Beispiel verdeutlicht einen leicht zu übersehenden Programmierfehler durch die Veränderung bei den überladenen Funktionen während der Programmentwicklung oder Programmwartung:

 double quotient (double a, double b)
 {
  return a / b; /* Gleitkommazahlige Division */
 }
 
 long i ← 1;
 long j ← 2;
 double q ← quotient (i, j); /* q ist 0,5 da die gleitkommazahlige Definition der Funktion 'quotient' verwendet wird */

Wird die Funktion 'quotient' später mit einer ganzzahligen Variante überladen, ergibt sich beim bestehenden Aufruf der Funktion unbeabsichtigt ein anderes Ergebnis für die Variable 'q':

 double quotient (long a, long b)
 {
  return a DIV b; /* Ganzzahlige Division */
 }
 
 double quotient (double a, double b)
 {
  return a / b; /* Gleitkommazahlige Division */
 }
 
 long i ← 1;
 long j ← 2;
 double q ← quotient (i, j); /* q ist 0 da die ganzzahlige Definition der Funktion 'quotient' verwendet wird */

Noch unübersichtlicher wird die Lage, wenn zusätzlich auch noch Überladungen mit gemischten Datentypen für die Funktionsparameter definiert werden:

 double quotient (long a, long b)
 
 double quotient (double a, long b)
 
 double quotient (long a, double b)
 
 double quotient (double a, double b)

Deswegen werden Methoden oder Attribute besser nicht überladen, auch nicht, wenn die Programmiersprache dies zulässt. Auch jede Klasse bekommt daher maximal einen einzigen '''Konstruktor''', der alle erforderlichen Parameter zur Initialisierung der Instanzvariablen enthält. Als günstige Nebeneffekte stellen sich kürzere Übersetzungszeiten ein.

Wenn die ursprünglichen Deklarationen in der Basisklasse oder einer der von ihr erbenden Klassen überladen werden, indem zum Beispiel weitere gleichnamige Methoden mit abweichenden Parametern definiert werden, dann kann es zu verändertem Verhalten von Software kommen. Ohne dass die Anwendung selbst geändert wurde, kann es allein durch die Aktualisierung einer verwendeten Klasse zu völlig anderen Rechenergebnissen kommen, weil automatisch eine andere, neu überladene Methode aufgerufen wird, ohne dass dies im Quelltext des Anwendungsprogramms sichtbar wird. Die Folge können schwerwiegende Programmierfehler sein, die schwierig zu analysieren sind.

Als ein Beispiel diene hier die Methode java.lang.Math.ulp zur Bestimmung der &quot;'''u'''nits in the '''l'''ast '''p'''lace&quot; (&quot;Einheiten in der letzten Stelle&quot;), die in der Klasse java.lang.Math aus historischen Gründen mit zwei Parametern deklariert und somit überladen ist:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 public class Math;
 {
    public static double ulp​ (double d)
    public static float  ulp​ (float f)
 }
&lt;/syntaxhighlight&gt;

Der folgende Java-Code

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 double zahl;
 zahl = java.lang.Math.ulp (1L); // Datentyp long
 java.lang.System.out.println (zahl);
 zahl = java.lang.Math.ulp (1F); // Datentyp float
 java.lang.System.out.println (zahl);
 zahl = java.lang.Math.ulp (1D); // Datentyp double
 java.lang.System.out.println (zahl);
&lt;/syntaxhighlight&gt;

erzeugt folgende Ausgabe, da die ganze Zahl Eins mit dem Datentyp long (64 Bit) in der Programmiersprache Java implizit offensichtlich nicht in den Datentyp double (64 Bit), sondern in den Datentyp float (32 Bit) umgewandelt wird, und somit die mit dem Parameter des Datentyps float deklarierte Methode aufgerufen wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 1.1920928955078125E-7
 1.1920928955078125E-7
 2.220446049250313E-16
&lt;/syntaxhighlight&gt;

Falls bei einer neueren Version der Klasse java.lang.Math die Methode ulp mit einem Parameter des Datentyps long überladen würde, wäre das Ergebnis mit dem ganzzahligen Parameter des Werts &quot;1L&quot; (long) nicht mehr vorhersagbar, obwohl der oben angegebene Methodenaufruf sich formal gar nicht geändert hätte.

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 public class Math;
 {
    public static double ulp ​(double d)
    public static float  ulp​ (float f)
    public static double ulp ​(long l)
 }
&lt;/syntaxhighlight&gt;

Das Ergebnis des Aufrufs 

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 double zahl = java.lang.Math.ulp (1L);
 java.lang.System.out.println (zahl);
&lt;/syntaxhighlight&gt;

würde dann allein von der tatsächlichen Implementierung der neuen überladenen Methode mit dem Parameter des Datentyps long abhängen, die mit den alten beiden ulp-Methoden nichts mehr zu tun hat, außer, dass sie den gleichen Namen hat.

===Überschreibung===
Das '''Überschreiben''' von geerbten Methoden oder Konstruktoren ist etwas völlig anderes als das Überladen und kann sehr sinnvoll sein.

Beim Überschreiben muss die Signatur der Methode (oder des Konstruktors) unter strikter Beachtung der Zuweisungskompatibilität, der Anzahl und der Reihenfolge aller Parameter sowie der Rückgabewerte berücksichtigt werden. Wenn die Programmiersprache dies nicht automatisch unterstützt, sind wenigstens entsprechend aufwendige Maßnahmen im Quelltext sicherzustellen, wie zum Beispiel explizite Typenprüfungen oder hinreichend ausführliche Hinweise in Kommentaren.

Wenn Methoden oder Konstruktoren einer Basisklasse von der überschreibenden Klasse aufgerufen werden (englisch ''super call'') kann es zum ''Fragile Base Class Problem'' (zu Deutsch ''Problem der anfälligen Basisklasse'') kommen, da bei der Implementierung der Basisklasse die möglichen Auswirkungen in den später implementierten, überschreibenden Klassen nicht berücksichtigt werden konnten. Zur Abwendung dieser Gefahr sind ein besonders sorgfältiger und strukturierter Programmierstil sowie eine lückenlose Dokumentation des Quelltextes sehr hilfreich.

Das fehlerfreie und robuste Überschreiben von Klassen beziehungsweise die Vererbung von implementierten Klassen erfordern eine hohe Fähigkeit zum abstrakten Denken und eine umfangreiche Programmiererfahrung.

===Mehrfachvererbung===
Durch [[w:Mehrfachvererbung|Mehrfachvererbung]], also das Erben von Methoden und Instanzvariablen aus mehreren Basisklassen, führt zu komplexen, und schwierig zu durchschauenden Abhängigkeiten, die im Rahmen des [[w:Diamond-Problem|Diamond-Problems]] sogar zu unerwünschten Mehrdeutigkeiten führen kann. Die Vererbung aus zwei Basisklassen kann bei Bedarf ohne weiteres durch die Verwendung von [[w:Zwillingsklasse|Zwillingsklassen]] vermieden werden, was den Programmieraufwand ein wenig erhöht, aber dafür solche Mehrdeutigkeiten verhindert und außerdem die Übersetzungszeiten der Quelltexte reduziert.

In der Programmiersprache Java ist es zum Beispiel möglich, mehrere Basisklassen zu erben. Dabei ist zwar nur eine konkrete Vererbung aus einer Basisklasse (in Java: class) zulässig, aber zusätzlich dürfen noch beliebig viele weitere Basisklassen (in Java: interface) abstrakt geerbt werden. Dabei werden alle Attribute und Methoden aller Basisklassen auf die erbende Klasse übertragen. Auch die konkret vererbte Basisklasse kann wiederum selber mehrere abstrakte Basisklassen implementieren. Falls es in mehreren Basisklassen gleichlautende öffentliche Bezeichner gibt, kommt es unweigerlich zu Konflikten. 

Es ist in der Implementierung insbesondere bei fehlenden entsprechenden Kommentaren nicht ohne Weiteres erkennbar, zu welchen Basisklassen die zu überschreibenden Instanzvariablen oder Methoden gehören.

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/**
 * Die Klasse Mehrfachvererbung erbt Attribute und Methoden aus drei Basisklassen:
 *    Sie ist eine Instanz der Klasse (class = konkrete Klasse) javax.swing.JFrame.
 *    Sie implementiert die Schnittstelle (interface = abstrakte Klasse) java.awt.event.KeyListener.
 *    Sie implementiert die Schnittstelle (interface = abstrakte Klasse) java.awt.event.ActionListener.
 */

public class Mehrfachvererbung
extends javax.swing.JFrame
implements java.awt.event.KeyListener, java.awt.event.ActionListener
{
	/**
	 *  Konstante serialVersionUID aus der Basisklasse java.io.Serialization fuer die Serialisation,
	 *  die in der Klasse javax.swing.JFrame implementiert ist
	 */
	private final static long serialVersionUID = 1L;

	/**
	 *  Instanzvariable fuer den zuletzt von einer Instanz der Klasse javax.swing.JFrame gesendeten Tastaturcode
	 */
	private int keyCode;

	/**
	 *  Zu ueberschreibende Methode aus der geerbten Klasse java.awt.event.KeyListener
	 *  Speichert den Tastaturcode der zuletzt betaetigten Taste fuer eine Instanz
	 *  @param event: aufgetretenes Tastaturereignis aus der Klasse java.awt.event.KeyEvent
	 */
	@Override
	public void keyPressed (java.awt.event.KeyEvent event)
	{
		this.keyCode = event.getKeyCode ();
	}

	/**
	 *  Zu ueberschreibende Methode aus der geerbten Klasse java.awt.event.KeyListener
	 *  Ungenutzt
	 *  @param event: aufgetretenes Tastaturereignis aus der Klasse java.awt.event.KeyEvent
	 */
	@Override
	public void keyReleased(java.awt.event.KeyEvent event)
	{
	}

	/**
	 *  Zu ueberschreibende Methode aus der geerbten Klasse java.awt.event.KeyListener
	 *  Ungenutzt
	 *  @param event: aufgetretenes Tastaturereignis aus der Klasse java.awt.event.KeyEvent
	 */
	@Override
	public void keyTyped (java.awt.event.KeyEvent event)
	{
	}

	/**
	 *  Zu ueberschreibende Methode aus der vererbten Klasse java.awt.event.ActionListener
	 *  Der Inhalt einer Instanz der Klasse javax.swing.JFrame wird erneut dargestellt,
	 *  wenn die Eingabetaste (Enter) betaetigt wurde.
	 *  @param event: aufgetretenes Aktionsereignis aus der Klasse java.awt.event.ActionEvent
	 */
	@Override
	public void actionPerformed (java.awt.event.ActionEvent event)
	{
		if (this.keyCode == java.awt.event.KeyEvent.VK_ENTER)
		{
			this.repaint ();
		}
	}
}
&lt;/syntaxhighlight&gt;

==Nachwort==
Ein sehr häufig auftretender „Programmierfehler“ - wiederum insbesondere bei Anfängern - ist das Unterlassen der Herstellung von Sicherungskopien der Quelltexte. Noch besser ist eventuell sogar eine Versionierung der Quelldateien, damit gegebenenfalls auf beliebige ältere Versionen zurückgegriffen werden kann. Die Auswirkungen dieses Fehlers sind hinreichend naheliegend, so dass hier nicht weiter darauf eingegangen werden muss.

Sollte der Leser nach der Lektüre dieser Beiträge zu dem verständlichen und naheliegenden Schluss gekommen sein, dass die Programmiersprachen C oder C++ ziemlich schlecht strukturiert sind, möge er sich auch einmal andere Programmiersprachen näher ansehen, wie zum Beispiel C#, Component Pascal oder auch Java.

Mit der Beherzigung der Vorschläge aus diesem Buch möge es dem Leser in seinem Programmier-Team in jeder Programmiersprache gelingen, in kürzerer Entwicklungszeit besser strukturierte und funktionierende Programme zu schreiben.

===Vergleich===
In der folgenden Tabelle werde einige imperative, objektorientierte Programmiersprachen hinsichtlich ihrer Strukturiertheit verglichen:

{| class=&quot;wikitable&quot;
|- class=&quot;hintergrundfarbe6&quot;
!Veröffentlichungsdatum!!1985!!1994!!1995!!2001
|-
!Programmiersprache!!C++!!Component&lt;br/&gt;Pascal!!Java!!C#
|-
| style=&quot;text-align:left&quot;| Vollständig strukturierte Syntax || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | nein
|-
| style=&quot;text-align:left&quot;| Datentypsicherheit bei Basistypen || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | ja
|-
| style=&quot;text-align:left&quot;| Datentypsicherheit bei komplexen Datentypen || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja
|-
| style=&quot;text-align:left&quot;| Modulsicherheit || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja
|-
| style=&quot;text-align:left&quot;| Keine zyklischen Importe || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | nein
|-
| style=&quot;text-align:left&quot;| Keine mehrfache Schnittstellenvererbung || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | nein
|-
| style=&quot;text-align:left&quot;| Keine mehrfache Implementationsvererbung || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja
|}

==Literatur==
* Niklaus Wirth:
** ''Programming in Modula 2'', Springer, 3. Auflage, 1985, ISBN 3-540-15078-1
** Mit Martin Reiser: ''Programming in Oberon – Steps beyond Pascal and Modula'', Addison-Wesley,1992, ISBN 0-201-56543-9
** ''Algorithmen und Datenstrukturen mit Modula - 2'', Teubner Leitfäden der Informatik, 5. Auflage, Teubner, Stuttgart, 1996, ISBN 9783519122609
* Herbert Schildt: ''Professionelles Modula-2'', McGraw-Hill, Hamburg, 1988, ISBN 3-89028-113-3
* Lászlo Böszörmény, Jürg Gutknecht, Gustav Pomberger: ''The School of Niklaus Wirth – The Art of Simplicity'', dpunkt, Heidelberg, 2000, ISBN 3-932588-85-1
* Hanspeter Mössenböck:
** ''Objektorientierte Programmierung in Oberon-2'', Springer, 1998, ISBN 9783540646495
** ''Sprechen Sie Java?: Eine Einführung in das systematische Programmieren'', dpunkt, Heidelberg, 2005, ISBN 9783898643627
** ''Kompaktkurs C# 4.0'', dpunkt, Heidelberg, 2009, ISBN 9783898646451

==Weblinks==
*{{w|Niklaus Wirth}}:
**Interessantes Interview: [http://www.simple-talk.com/opinion/geek-of-the-week/niklaus-wirth-geek-of-the-week/ Geek of the Week] vom 2. Juli 2009
**Ein noch interessanteres Interview (2009): [http://www.youtube.com/watch?v=wrGytM2YTQY An Interview with Niklaus Emil Wirth, Part 3]
*{{w|Frederick P. Brooks}}: [[w:en:The_Mythical_Man-Month|The Mythical Man-Month]]
*{{w|Benutzer:Bautsch|Markus Bautsch}}: [[:en:User:Bautsch/Capsula|Draft of the graphical programming language '''Capsula''']] (Wikibooks)

== Einzelnachweise ==
&lt;references&gt;&lt;/references&gt;

==Zusammenfassung des Projekts==
{{Vorlage:StatusBuch|10}}
* '''Zielgruppe:''' Programmierer, Software-Entwickler, Informatik-Lehrende
* '''Lernziele:''' Vermeidung von Fehlern, die leicht und unbemerkt zur unstrukturierten Programmierung führen können. Schnelle und sichere Erstellung leicht zu wartender Software.
* '''Buchpatenschaft/Ansprechperson:''' [[Benutzer:Bautsch]]
* '''Sind Co-Autoren gegenwärtig erwünscht?''' Ja, sehr gerne. Korrekturen von offensichtlichen Fehlern direkt im Text; Inhaltliches bitte per Diskussion.
* '''Richtlinien für Co-Autoren:''' Wikimedia-like.

[[Kategorie:Buch]]
[[Kategorie:Studium]]</text>
      <sha1>p3njimatgog1cegdbaanbzfaddhf1ag</sha1>
    </revision>
    <revision>
      <id>1088585</id>
      <parentid>1088584</parentid>
      <timestamp>2026-07-03T12:55:59Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <comment>/* Methoden */ Unterprogramme</comment>
      <origin>1088585</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="181366" sha1="2oatpkiogvv8b37ty5wbz3tomcfc35q" xml:space="preserve">{{Regal | ort=Programmierung}}
[[Datei:Programmierung.Java.Julia-Menge.png|mini|rechts|hochkant=2|Bildschirmaufnahme des mit Tastatursteuerung interaktiven Java-Programms [[Das Apfelmännchen/ FraktaleMengeAusgabe|FraktaleMengeAusgabe]] zur Berechnung und Darstellung von Julia-Mengen oder der Mandelbrot-Menge. Siehe auch '''Wikibook [[Das Apfelmännchen]]'''.]]
[[Datei:Programmierung.Java.Maze.png|mini|rechts|hochkant=2|Bildschirmaufnahme des Java-Programms [[Rekursive Labyrinthe/ MazeGraphs|Maze]] zur rekursiven Erstellung und Darstellung von Labyrinthen. Siehe auch '''Wikibook [[Rekursive Labyrinthe]]'''.]]
[[Datei:Programmierung.Java.SimForestFrame.png|mini|rechts|hochkant=2|Bildschirmaufnahme des Java-Programms [[Waldbrandsimulation/ SimForestFrame|SimForestFrame]] zur Simulation und Darstellung von sich ausbreitenden Waldbränden. Siehe auch '''Wikibook [[Waldbrandsimulation]]'''.]]
[[Datei:Programmierung.Java.Campingplatzraetsel.png|mini|rechts|hochkant=2|Bildschirmaufnahme des mit Maussteuerung interaktiven Java-Programms [[Campingplatzrätsel/ CampingplatzGraphs|CampingplatzGraphs]] zur Erstellung und Darstellung von Campingplatzrätseln. Siehe auch '''Wikibook [[Campingplatzrätsel]]'''.]]
[[Datei:Programmierung.Java.GameOfLife.png|mini|rechts|hochkant=2|Bildschirmaufnahme des Java-Programms &quot;GameOfLife&quot; zur Anzeige von Conways Spiel des Lebens. Siehe auch '''Wikibook [[Game of Life]]'''.]]

==Einleitung==
Das Buch '''Strukturierte Programmierung''' ist kein Lehrbuch zum Erlernen einer Programmiersprache, sondern soll als kleiner Leitfaden dazu dienen, besser strukturierte Programme erstellen zu können, selbst wenn die eingesetzten Programmiersprachen die strukturierte Programmierung weniger stark unterstützen.

&lt;big&gt;Warum lohnt es sich überhaupt, strukturiert zu programmieren&amp;nbsp;?&lt;/big&gt;

Es gibt eine ganze Reihe von naheliegenden Gründen, aber auch einige Vorteile, die nicht auf der Hand liegen oder jedermann sofort ersichtlich sind. Anfänger und Fortgeschrittene profitieren gleichermaßen von gut strukturierter Programmierung. Die Vorteile sind so erheblich, dass es unbedingt sinnvoll ist, gut strukturiert zu programmieren. Im Folgenden werden einige wichtige Vorteile aufgeführt und erläutert:

*'''Strukturierte Programme sind leichter nachvollziehbar.''' Dies erleichtert die Arbeit im Team und vereinfacht die Wartung, wenn der Quellcode ergänzt, geändert oder korrigiert werden muss.
*'''Strukturierte Programme haben weniger Programmierfehler.''' Dies reduziert die Entwicklungszeiten und erhöht die Akzeptanz bei den Auftraggebern und Nutzern der Software.
*'''Strukturierte Programme können ohne Laufzeit-Debugger erstellt werden.''' Dies spart enorm viel Zeit und Nerven bei der Entwicklung von Software.

Die geringen Laufzeiteinbußen, die bei hoch strukturierter Programmierung von Anwendungssoftware gegenüber laufzeitoptimiertem Code entstehen können, spielen –&amp;nbsp;sofern sie überhaupt existieren sollten&amp;nbsp;– bei den heutzutage zur Verfügung stehenden modernen und schnellen Rechenmaschinen praktisch keine Rolle mehr. Programmcode wegzulassen, der der inhärenten Betriebssicherheit von Software oder der inhärenten Datenintegrität dient, macht nur in sehr wenigen, extrem zeitkritischen Anwendungen Sinn, keineswegs jedoch bei herkömmlichen oder gar sicherheitskritischen Anwendungsprogrammen.

Die Ratschläge aus diesem Buch beruhen auf jahrzehntelanger Erfahrung mit der Softwareentwicklung komplexer Systeme und dem Hochschulunterricht im Fach Programmierung mit verschiedenen Programmiersprachen.

Die folgende Check-Liste enthalt eine Reihe von wichtigen Kriterien, die bei strukturierter Programmierung berücksichtigt werden sollten:

* &lt;big&gt;&lt;big&gt;'''[[Strukturierte Programmierung/ Checkliste|Checkliste]]'''&lt;/big&gt;&lt;/big&gt;

Übrigens: ''In der Kürze der Quelltextdatei liegt nicht die wahre Würze des Programmierens&amp;nbsp;!''

Und noch wichtiger:

:''So ists mit aller Bildung auch beschaffen:''
:''Vergebens werden ungebundne Geister''
:''Nach der Vollendung reiner Höhe streben.''

:''Wer Großes will, muß sich zusammenraffen;''
:''In der Beschränkung zeigt sich erst der Meister,''
:''Und das Gesetz nur kann uns Freiheit geben.''

::Johann Wolfgang von Goethe, Ende von ''Das Sonett''

Viel Erfolg beim strukturierten Programmieren wünscht [[Benutzer:Bautsch]]&amp;nbsp;!
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Quelltextgestaltung==
In diesem Abschnitt stehen einige Vorschläge zur allgemeinen Gestaltung der Quelltexte, die keine unmittelbare Auswirkung auf die Lauffähigkeit und die Funktion der Programme haben, aber dazu führen, dass der Quelltext besser verständlich und nachvollziehbar ist.

===Anweisungen===
Der Quelltext wird bei imperativen Programmiersprachen durch Anweisungen gestaltet, die ganz unterschiedlich geartet sein können. Zu den typischen und wichtigen Anweisungen gehören:

* Deklaration (declaration)
* Blockanweisung (block, begin / end)
* Zuweisung (assignment)
* Aufruf (call)
* Rücksprung (return)
* Verzweigung (branch)
* Schleife (loop)
* Sicherstellung (assertion)

Bei Kommentaren und Leerräumen (Leerzeichen, Tabulatoren, Zeilenumbrüche, ...) in Quelltexten handelt es sich nicht um Anweisungen, da sie vom Übersetzer (compiler) beziehungsweise Interpreter des Programmcodes ignoriert werden.

===Kommentare===
Jeder Quelltext sollte zu Beginn der Datei in einem von Compiler zu ignorierenden '''Kommentar''' für die Klarstellung des Inhalts einige Mindestangaben zum Inhalt und Ursprung machen. Dazu gehören beispielsweise die Autoren, Urheber oder Rechteinhaber, deren beabsichtigte Nutzungsarten/-rechte und Nutzungsbedingungen und weitere Angaben zur Lizenzierung, das Datum der Erstellung oder Veränderung, eine Versionsangabe und Angaben zur verwendeten Programmiersprache und gegebenenfalls zu den eingesetzten Programmbibliotheken (gegebenenfalls ebenfalls mit Versionsangaben). Ferner soll beschrieben werden, für welchen Zweck oder für welche Aufgabenstellungen das Programm eingesetzt werden kann. Darüber hinaus können und sollen auch weitere sinnvolle oder nützliche Angaben in diesem '''Kopfkommentar''' festgehalten werden.

Der Kommentartext wird bei vielen Programmiersprachen im Quelltext mit dem Symbolpaar &quot;/*&quot; und &quot;*/&quot; oder dem Symbolpaar &quot;(*&quot; und &quot;*)&quot; eingeschlossen.

Beispiel:

 /*
   Program: generation of pseudorandom numbers
   Author: Bautsch
   License: public domain
   Date: 7th January 2011
   Version: 1.0
   Programming language: Java
   Description: This program uses a primitive polynomial sequence with large prime coefficients to efficiently generate uniformly distributed pseudorandom numbers.
 */

Alle Methoden und Variablen werden ausreichend kommentiert, sofern sie nicht durch die Wahl „sprechender” Bezeichner selbsterklärend sind.

Bei Methoden werden insbesondere die Bedeutung aller Parameter und Rückgabewerte dokumentiert:

 /* The method &quot;add&quot; computes and returns the sum of &quot;summand1&quot; and &quot;summand2&quot; */
 double add (double summand1, double summand2)
 {
    double sum ← summand1 + summand2
    return sum
 }

Viele Entwicklungssysteme bieten Funktionen, die die Dokumentation der Quelltexte mit Kommentaren unterstützen.

Bei einigen Programmiersprachen ist Aufmerksamkeit geboten, wenn in der Sprachdefinition geschachtelte Kommentare nicht vorgesehen sind. Wird zum Beispiel während der Programmentwicklung Quelltext auskommentiert, um das Verhalten des modifizierten Programms zu überprüfen, und enthält dieser Quelltext einen Kommentar, ist dann nicht sofort erkennbar, welcher Abschnitt des Quelltextes tatsächlich auskommentiert werden soll. Dabei kann es auch vorkommen, dass einige Compiler die geschachtelten Kommentare erkennen und im eigentlichen Sinne des Programmierers berücksichtigen; andere Compiler, die sich streng an die standardisierten Sprachdefinitionen halten, jedoch nicht, so dass es bei der Portierung von Quellcode unweigerlich zu Übersetzungsfehlern kommt.

Das folgende Beispiel zeigt einen Programmabschnitt, bei dem hinter der letzten Anweisung zwischen den Zeichenfolgen &quot;/*&quot; und &quot;*/&quot; ein Textkommentar hinzugefügt wurde, der vom Compiler ignoriert werden soll.

 int i ← 1
 i ← i * i /* die Variable i wird quadriert. */

Wird zusätzlich mit den gleichen Zeichenfolgen &quot;/*&quot; und &quot;*/&quot; die gesamte Programmzeile auskommentiert, gibt es einen Übersetzungsfehler, wenn der Compiler die allerletzte Zeichenfolge &quot;*/&quot; als Kommentarende ohne Kommentaranfang interpretiert, sofern der zweite und nunmehr auskommentierte Kommentaranfang &quot;/*&quot; in der Zeile mit dem Textkommentar ignoriert wurde und die erste auftretende Zeichenfolge &quot;*/&quot; bereits als Kommentarende interpretiert wurde:

 int i ← 1
 /*
    i ← i * i /* die Variable i wird quadriert. */
 */

===Leerräume===
'''Leerräume''', also zum Beispiel Leerzeichen, Zeilen- und Seitenumbrüche oder Tabulatoren, werden - genauso wie Kommentare - von vielen Compilern überlesen und dienen in diesen Fällen ausschließlich zur Verbesserung der Lesbarkeit für die Programmierer. Daher sollten diese Leerräume sorgfältig eingesetzt werden, um die Nachvollziehbarkeit des Quellcodes für Programmierer zu erleichtern. Bei einigen Programmiersprachen werden allerdings bestimmte Formatierungen in der Sprachdefinition gefordert und müssen dann natürlich den Vorgaben entsprechend eingehalten werden.

Viele Entwicklungssysteme bieten sehr nützliche, unterstützende Funktionen zur einheitlichen Formatierung der Quelltexte, die sehr einfach anzuwenden sind und benutzt werden sollten. So ist es zum Beispiel allgemein üblich, Programmblöcke so zu formatieren, dass die Inhalte gegenüber dem Kopf und dem Fuß etwas eingerückt und durch Zeilenumbrüche voneinander getrennt werden:

 Blockkopf
    eingerückter Inhalt 1
    eingerückter Inhalt 2
 Blockfuß

Für die Einrückungen werden heute meist mehrere Leerzeichen oder ein Tabulatorzeichen verwendet. Neuerdings wird in manchen Programmiersprachen empfohlen, vier Leerzeichen zu verwenden. Manche Editoren fügen bei der Betätigung der Tabulatortaste eine gewünschte Anzahl von Leerzeichen ein. Das Mischen von mehreren Leerzeichen und Tabulatorzeichen für die Einrückungen kann nicht empfohlen werden, da dies bei der Bearbeitung mit verschiedenen Editoren zur uneinheitlichen Darstellung der Einrückungen führen kann. Moderne Editoren haben Funktionen, mit denen der gesamte Programmcode oder Teile davon einheitlich und korrekt eingerückt werden können (Englisch: &quot;correct indentation&quot;).

Siehe hierzu auch [[Strukturierte Programmierung#Blockanweisungen|Blockanweisungen]].

===Bezeichner===
In den meisten Programmiersprachen gibt es '''Bezeichner''' (oder '''Identifikatoren''', englisch: '''identifier''') für ganz unterschiedliche Dinge, wie für symbolische '''Konstanten''', für '''Variablen''', für '''Parameter''' oder '''Attribute''', für '''Unterprogramme''' (respektive für '''Methoden''', '''Prozeduren''' oder für '''Funktionen'''), für '''Module''' (respektive für '''Klassen''') oder für '''Bibliotheken'''. Zur Strukturierung von Daten werden auch '''Pakete''' (englisch: '''packages''') eingesetzt.

In der Regel stehen alle Buchstaben ohne Diakritika zur Verfügung. Oft sind auch noch Ziffern und der Unterstrich &quot;_&quot; erlaubt. Das erste Zeichen muss üblicherweise immer ein Buchstabe sein. Leerzeichen sind innerhalb von Bezeichnern im Allgemeinen nicht zulässig.

Beim Lesen und Analysieren von Quelltexten ist es sehr hilfreich, wenn einem Bezeichner nicht nur beim ersten Auftauchen bei der Deklaration, sondern an jeder Stelle im Programm sofort angesehen werden kann, wofür er steht. Meist bildet sich für eine Gruppe von Programmiersprachen ein bestimmter Usus aus, wie die entsprechenden Bezeichner gestaltet werden sollen. Der Compiler stellt in der Regel keine Ansprüche an die Schreibweise von Bezeichnern, solange der definierte Zeichenvorrat verwendet wird. Eine Ausnahme stellen die vorgegebenen Schlüsselwörter dar, die häufig und je nach Programmiersprache nur aus Großbuchstaben oder nur aus Kleinbuchstaben bestehen, wie zum Beispiel:

* '''IMPORT''', '''CONST''', '''TYPE''', '''VAR''', '''PROCEDURE''', '''NIL''', '''LONG''', '''REAL''', '''BEGIN''', '''END''', '''WHILE'''
versus
* '''import''', '''final''', '''void''', '''static''', '''null''', '''long''', '''double''', '''while'''

In vielen Programmiersprachen haben sich für die frei definierbaren Bezeichner bestimmte Praktiken herausgebildet, damit die Bedeutung der Bezeichner im Quelltext von den beteiligten Programmierern leichter erkannt werden kann. Dieses Vorgehen ist allerdings nicht immer einheitlich gestaltet, wie anhand der folgenden, beispielhaften Liste gesehen werden kann:
* Die Bezeichner von übergeordnet verfügbaren Konstanten, Variablen, Datentypen, Klassen oder Modulen beginnen mit '''einem Großbuchstaben'''.
* Die Bezeichner von Konstanten werden '''vollständig mit Großbuchstaben''' geschrieben.
* Die Bezeichner von lokal verfügbaren Variablen, Attributen oder Parametern werden '''vollständig mit Kleinbuchstaben''' geschrieben.
* Die Bezeichner von Methoden werden '''vollständig mit Kleinbuchstaben''' geschrieben.

====Variablen und Methoden====
So ist es zum Beispiel üblich, Variablen und Methoden mit Kleinbuchstaben zu benennen. Dabei ist der Unterschied zwischen Variable und Methode immer und einfach anhand der obligatorischen Parameterliste von Methoden zu erkennen, die beim Fehlen von Parametern leer ist und in vielen Programmiersprachen durch runde Klammern begrenzt ist und direkt hinter dem Methodennamen steht:

 /* &quot;diameter&quot; is variable of the data type integer */
 int diameter
 
 /* &quot;radius&quot; is variable (parameter of the function &quot;calcDiameter&quot;) of the data type integer */
 /* &quot;calcDiameter&quot; is a function */
 /* the result of the function call has the data type integer */
 int calcDiameter (int radius)

&quot;calcDiameter&quot; ist hierbei mit dem Binnenmajuskel &quot;D&quot; versehen (umgangssprachlich auch &quot;Kamelhöcker-Notation&quot; genannt, englisch &quot;camel case&quot;), um den Anfang eines neuen Wortes ohne die Verwendung eines Leerzeichens erkennbar zu machen.

Es ist im Sinne der guten Lesbarkeit des Quelltextes allgemein hilfreich, in Bezeichnern immer passende grammatische Formen zu verwenden, wie zum Beispiel:
* für booleschen Variablen und Funktionen: Partizipien oder Adjektive
* für andere Variablen und Funktionen: Substantive
* für Methoden und Kommandos: Verben im Imperativ

In manchen Programmiersprachen ist es üblich, lokale Variablen mit einem Kleinbuchstaben zu beginnen und globale Variablen - also in mehreren Programmodulen, Klassen oder Methoden sichtbare Variablen - mit einem Großbuchstaben zu beginnen, um deren Sichtbarkeiten unmittelbar erkennbar zu machen.

====Konstanten====
Die Werte von Konstanten können zur Laufzeit nicht mehr verändert werden. Dieser Umstand wird dem Compiler bei der Deklaration der Konstanten durch entsprechende Deklarationen (wie zum Beispiel &quot;CONST&quot;) oder Modifikatoren (wie zum Beispiel &quot;final&quot;) mitgeteilt.

Damit an jeder Stelle des Quelltextes, also auch nach der Deklaration, erkannt werden kann, dass es sich um eine Konstante handelt, ist es hilfreich Konstanten mit einem '''Großbuchstaben''' beginnen zu lassen; manchmal werden für Konstanten sogar ausschließlich Großbuchstaben verwendet.

Es ist empfehlenswert, die Initialisierung einer Konstanten immer unmittelbar im Kontext der Deklaration vorzunehmen, damit es keine Mehrdeutigkeiten und somit auch keine Verwechslungen durch undefinierte Werte geben kann. Wenn dies nicht sinnvoll erscheint, sollte vorzugsweise keine Konstante verwendet werden. In vielen modernen Programmiersprachen ist es möglich, Klassenvariablen beziehungsweise globale Variablen zu schützen, indem diese nur innerhalb einer Klasse beziehungsweise innerhalb eines Moduls verändert werden dürfen. In diesem Fall gibt es von Außerhalb nur einen Lesezugriff auf den Wert der Variablen (&quot;read-only&quot;), oder der aktuelle Wert der Variablen kann durch den Aufruf eines Unterprogramms zurückgegeben werden (&quot;get&quot;-Methoden).

&lt;syntaxhighlight lang=&quot;Pascal&quot;&gt;
(* Programmiersprache Component Pascal *)

MODULE Zahlen;

(* Auf die globale ganzzahlige Konstante &quot;Konstante&quot; kann nur lesend zugegriffen werden. *)
(* Die globale Konstante &quot;Konstante&quot; ist durch Deklaration und Initialisierung vollständig definiert. *)
CONST
	Konstante = 7;

(* Auf die globale ganzzahlige Variable &quot;zahl&quot; kann von außerhalb des Moduls &quot;Zahlen&quot; nur lesend zugegriffen werden. *)
(* Die globale Variable &quot;zahl&quot; wird mit dem Zusatz &quot;-&quot; als &quot;read-only&quot; deklariert. *)
VAR
	zahl-: LONGINT;

BEGIN
	(* Die globale Variable &quot;zahl&quot; wird mit einem Wert initialisiert. *)
	zahl := 8;
END Zahlen.
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Zahlen;
{
	// Auf die öffentliche ganzzahlige Klassenkonstante &quot;Konstante&quot; kann nur lesend zugegriffen werden.
	// Die Klassenkonstante &quot;Konstante&quot; ist durch Deklaration und Initialisierung vollständig definiert.
	// Die Klassenkonstante &quot;Konstante&quot; wird mit dem Zusatz &quot;final&quot; deklariert.
	public static final long Konstante = 7;

	// Auf die nicht-öffentliche ganzzahlige Klassenvariable &quot;zahl&quot; kann von außerhalb der Klasse
	// nur über die öffentliche Methode &quot;getZahl ()&quot; lesend zugegriffen werden.
	// Die Klassenvariable &quot;zahl&quot; wird mit dem Zusatz &quot;private&quot; deklariert.
	private static long zahl = 8;

	public static long getZahl ()
	{
		return zahl;
	}
}
&lt;/syntaxhighlight&gt;

Im folgenden Java-Beispiel wird eine als konstant deklarierte lokale Variable erst innerhalb einer Fallunterscheidung (if-Anweisung) und zudem mit zwei verschiedenen optionalen Werten initialisiert. Wenn die Deklaration und die optionalen Initialisierungen im Quelltext weiter auseinanderliegen, ist es schwierig, den definierten Zustand der vermeintlich eindeutig definierten Variablen vollständig zu erfassen.

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
private static boolean boolescherAusdruck ()
{
	java.util.Random zufall = new java.util.Random ();
	boolean zufaelligerBoolescherWert = zufall.nextBoolean ();
	return zufaelligerBoolescherWert;
}

public static void main (java.lang.String [] arguments)
{
	// Deklaration der lokalen Konstante &quot;Zahl&quot;,
	// die wegen fehlender Initialisierung nicht definiert ist.
	final long Zahl;

	if (boolescherAusdruck ())
	{
		Zahl = 7;
	}
	else
	{
		Zahl = 8;
	}
	java.lang.System.out.println (&quot;Konstante Zahl = &quot; + Zahl);
}
&lt;/syntaxhighlight&gt;

====Klassen und Module====
Auch Unterprogrammeinheiten wie '''Module''' oder '''Klassen''' werden in der Regel mit eindeutigen Bezeichnern benannt, die üblicherweise mit einem '''Großbuchstaben''' beginnen.

Im Kontext eines Quellcodes ist es immer möglich, diese Unterprogrammeinheiten von anderen zu unterscheiden, die ebenfalls mit einem Großbuchstaben beginnen (beispielsweise Konstanten), weil die Bezeichner von Unterprogrammeinheiten von einer Blockanweisung (zum Beispiel geschweifte Klammern) für die Implementation von Programmcode oder von einem Separator (beispielsweise &quot;.&quot;) zur qualifizierten Bezeichnung von Teilen der Unterprogrammeinheiten gefolgt werden.

Das Konzept von Unterprogrammeinheiten ist, dass mehrere Unterprogramme (Methoden, Prozeduren, Funktionen, Kommandos) sowie mehrere Konstanten, Variablen oder Datenstrukturen (Verbunde (struct, record), Arrays) in einer speicherbaren Datei zusammengefasst werden. Insofern handelt es sich bei solchen Unterprogrammeinheiten um die '''kleinsten dauerhaft speicherbaren Einheiten''' in einem Software-Projekten.

Unterprogrammeinheiten werden in strukturierten Programmiersprachen unter der Verwendung von Schlüsselwörtern wie zum Beispiel &quot;program&quot;, &quot;MODULE&quot; oder &quot;class&quot; '''deklariert''':

&lt;syntaxhighlight lang=&quot;Pascal&quot;&gt;
(* Die Unterprogrammeinheit &quot;Programmeinheit&quot; in der Programmiersprache Pascal *)
program Programmeinheit;
begin
end.
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;modula2&quot;&gt;
(* Die Unterprogrammeinheit &quot;Programmeinheit&quot; in den Programmiersprachen Modula-2, Oberon oder Component Pascal *)
MODULE Programmeinheit;
BEGIN
END Programmeinheit.
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
// Die Unterprogrammeinheit &quot;Programmeinheit&quot; in der Programmiersprache Java
public class Programmeinheit;
{
}
&lt;/syntaxhighlight&gt;

====„Sprechende” Bezeichner====
Die Wahl '''„sprechender“ Bezeichner''' hilft beim Lesen, Verstehen und Nachvollziehen von Quelltext ungemein. Häufig erübrigt sich sogar ein erläuternder Kommentar, wenn mit hinreichend „sprechenden“ Variablen- beziehungsweise Methodennamen gearbeitet wird.

Also nicht eine solche Anweisung:

 h ← (t – b)

Sondern besser:

 height ← (top - bottom)

Die verpasste Chance, einen Bezeichner sprechend zu benennen, kann in vielen Entwicklungssystemen durch sogenanntes ''Refactoring'' zentral für den gesamten Quelltext durch Umbenennung geheilt werden.

====Parameter====
Bei Methodenaufrufen werden '''alle Parameter''' mit Variablen oder mit Konstanten übergeben, also nicht mit '''komplexen Ausdrücken''' (beispielsweise arithmetische Berechnungen und Aufrufe von Unterprogrammen) oder mit '''Literalen''' (also direkt eingegebene Werte, wie 100 oder &quot;Text&quot;).

Hier ein schlechtes Beispiel mit dem Aufruf des Java-Unterprogramms &quot;zeichneRechteck&quot; mit fünf kryptischen Parameterausdrücken in den runden Klammern. Jedes der fünf Literalen 50 hat eine eigene unabhängige Bedeutung, die bei dieser Schreibweise nicht unterschieden oder nachvollzogen werden können, was deswegen schnell zu Verwechslungen führen kann:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   zeichneRechteck (50, 50, 50, berechneHoehe (50), 50);
&lt;/syntaxhighlight&gt;

Ein strukturiertes Programm weist die Werte für alle fünf Parameter vor dem Aufruf des Unterprogramms an eigene Variablen mit sprechenden Bezeichnern zu:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   int x = 50;
   int y = 50;
   int breite = 50;
   int hoehe = berechneHoehe (breite);
   int helligkeitProzent = 50;
   zeichneRechteck (x, y, breite, hoehe, helligkeitProzent);
&lt;/syntaxhighlight&gt;

Diese Anweisungsfolge ist im Gegensatz zu der Anweisung darüber auch ohne die explizite Kenntnisnahme der '''Deklaration des Unterprogramms''' verständlich:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   /**
   * Zeichnet ein Rechteck in das Bildschirmfenster
   * @param x: x-Koordinate vom linken Bildschirmfensterrand nach rechts
   * @param y: y-Koordinate vom oberen Bildschirmfensterrand nach unten
   * @param breite: Breite des Rechtecks von x nach rechts
   * @param hoehe: Hoehe des Rechtecks von y nach unten
   * @param helligkeitProzent: Helligkeit des Rechtecks in Prozent (0 = schwarz, 100 = weiss)
   */
   public static void zeichneRechteck (int x, int y, int breite, int hoehe, int helligkeitProzent)
&lt;/syntaxhighlight&gt;

====Qualifizierte Bezeichner====
=====Programmeinheiten=====
Damit der sich hinter einem Bezeichner verborgene Inhalt eindeutig einer Programmeinheit zugeordnet werden kann, muss dieser '''qualifiziert bezeichnet''' werden.

In manchen Programmiersprachen geschieht dies für bestimmte Bezeichner inhärent, obwohl es eine explizite import-Anweisung für die entsprechenden Bezeichner gibt, so dass die Programmierer in diesen Sonderfällen also wissen müssen, worauf sich der unqualifizierte Bezeichner bezieht. In der Programmiersprache Java dürfen häufig verwendete Bezeichner wie beispielsweise die zur Textausgabe verwendete Methode &quot;print&quot; aus der Klasse &quot;System&quot; oder die für Zeichenketten verwendete Klasse &quot;String&quot; ohne eine vollständige und qualifizierte Bezeichnung in den Programmtext geschrieben werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   String text = &quot;Hallo Welt!&quot;;
   System.out.print (text);
&lt;/syntaxhighlight&gt;

In der Variablen &quot;text&quot; der Klasse &quot;String&quot; wird die Zeichenkette &quot;Hallo Welt!&quot; gespeichert und mit der klassengebundenen Methode &quot;print&quot; der Klassenvariablen &quot;out&quot; aus der Klasse &quot;System&quot; ausgegeben. Hier ist allerdings nicht ohne weiteres ersichtlich, wo sich die Deklarationen oder die Implementierungen beiden Klassen &quot;String&quot; und &quot;System&quot; befinden.

Die '''qualifizierte Bezeichnung''' dieser beiden Anweisungen hat folgendes Aussehen:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   java.lang.String text = &quot;Hallo Welt!&quot;;
   java.lang.System.out.print (text);
&lt;/syntaxhighlight&gt;

Durch die qualifizierte Bezeichnung wird klar, dass sich beide Klassen im Programmpaket &quot;java.lang&quot; des Programmmoduls &quot;java.base&quot; befinden. Jedes Modul (englisch &quot;module&quot;) und jedes Paket (englisch &quot;package&quot;) kann in der Systembibliothek der Programmiersprache beziehungsweise in der Programmbibliothek der Laufzeitumgebung eindeutig zugeordnet werden.

Alternativ wird die Qualifikation von bestimmten Bezeichnern durch eine Import-Anweisung zu Beginn des Programms vorgenommen:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   import java.lang.String;
   import java.lang.System;

//...

      String text = &quot;Hallo Welt!&quot;;
      System.out.print (text);
&lt;/syntaxhighlight&gt;

Dieses Vorgehen erlaubt innerhalb einer Programmdatei zwar grundsätzlich eine korrekte und eindeutige Zuordnung der weiter unten im Programmtext verwendeten '''unqualifizierten''' Bezeichner, bei der Analyse des Programmtextes sind sämtliche Import-Anweisungen jedoch stets und vollständig zu berücksichtigen, was die Sache für die Programmierer insbesondere bei langen oder komplexen Quelltexten sehr erschweren kann. Dies kann durch die ausschließliche und obligatorische Verwendung von qualifizierten Bezeichnern ausgeschlossen werden, und deswegen wird von streng strukturierten Programmiersprachen überall und immer eine qualifizierte Bezeichnung gefordert.

Leider dürfen diese qualifizierten Importe beziehungsweise Bezeichnungen in manchen Programmiersprachen für gängige Unterprogrammeinheiten weggelassen werden, wie im folgenden Beispiel in der Programmiersprache Java:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
public class Test
{
   public static void main (String [] args)
   {
   }
}
&lt;/syntaxhighlight&gt;

Ein Aufruf des formal korrekt deklarierten Hauptprogramms &quot;main&quot; kann zu folgender völlig irritierender Fehlermeldung führen, wenn gar nicht die dafür vorgesehene Standard-Java-Klasse &quot;java.lang.String&quot; referenziert wird, weil sich im Software-Projekt, in dem sich das Hauptprogramm befindet, eine gleichnamige Klasse &quot;String&quot; definiert ist, die durch die Regeln der Programmiersprache vorrangig referenziert wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
Error: Main method not found in class Test, please define the main method as: public static void main (String [] args)
&lt;/syntaxhighlight&gt;

=====Datenstrukturen=====
Auch bei Datenstrukturen müssen qualifizierte Bezeichner verwendet werden, damit eindeutig auf bestimmte Datenfelder zugegriffen werden kann. Im folgenden Beispiel in der Syntax der '''Pascal'''-Programmiersprachenfamilie wird dies anhand des komplexen Datentyps &quot;Postadresse&quot; mit den sechs Attributen &quot;vorname&quot;, &quot;nachname&quot;, &quot;strasse&quot;, &quot;hausnummer&quot;, &quot;postleitzahl&quot; und &quot;ort&quot; dargestellt:

&lt;syntaxhighlight lang=&quot;Pascal&quot;&gt;
   (* Datentyp &quot;Postadresse&quot; *)
   TYPE Postadresse =
      RECORD
         vorname: ARRAY OF CHAR;
         nachname: ARRAY OF CHAR;
         strasse: ARRAY OF CHAR;
         hausnummer: ARRAY OF CHAR;
         postleitzahl: LONGINT;
         ort: ARRAY OF CHAR;
      END;
&lt;/syntaxhighlight&gt;

In den Deklarationen der Attribute steht &quot;ARRAY OF CHAR&quot; für den Datentyp Zeichenkette, der zur Speicherung von Zeichenfolgen verwendet wird. Der Datentyp &quot;LONGINT&quot; dient zur Speicherung ganzer Zahlen.

Eine Instanz &quot;adresse&quot; dieses Datentyps &quot;Postadresse&quot; kann wie folgt mit der NEW-Prozedur erzeugt werden, wobei der dafür erforderliche Speicherplatz festgelegt und für andere Verwendungen gesperrt wird. Auf die sechs einzelnen Datenfelder der in &quot;adresse&quot; gespeicherten sechs Attribute des Datentyps &quot;Postadresse&quot; kann danach im Programm mit den entsprechenden qualifizierten Bezeichnern beispielsweise zugegriffen werden, indem die jeweiligen initialen Werte mithilfe des Zuweisungsoperators := zugewiesen werden. Auf die Prozeduren &quot;String&quot; und &quot;Int&quot; aus dem Modul &quot;Out&quot; wird über &quot;Out.String&quot; und &quot;Out.Int&quot; ebenfalls qualifiziert zugegriffen:

&lt;syntaxhighlight lang=&quot;Pascal&quot;&gt;
   IMPORT
      Out; (* Import des Moduls &quot;Out&quot; mit den Textausgabe-Prozeduren &quot;String&quot; für Zeichenketten und &quot;Int&quot; für ganze Zahlen *)
   VAR
      adresse: Postadresse; (* globale Variable &quot;adresse&quot; *)
   BEGIN
      NEW (adresse);  (* Speicherreservierung für den Bezeichner &quot;adresse&quot; *)
      adresse.vorname := &quot;Irgend&quot;;
      adresse.nachname := &quot;Jemand&quot;;
      adresse.strasse := &quot;Allee&quot;;
      adresse.hausnummer := &quot;100&quot;;
      adresse.postleitzahl := 10000;
      adresse.ort := &quot;Irgendwo&quot;;

      Out.String (adresse.vorname);
      Out.String (adresse.nachname);
      Out.String (adresse.strasse);
      Out.String (adresse.hausnummer);
      Out.Int (adresse.postleitzahl);
      Out.String (adresse.ort);
   END;
&lt;/syntaxhighlight&gt;

In einem weiteren Beispiel mit der Syntax der Programmiersprache '''Java''' wird die Datenstruktur dieses komplexen Datentyps als Klasse &quot;Postadresse&quot; mit den sechs Instanzvariablen &quot;vorname&quot;, &quot;nachname&quot;, &quot;strasse&quot;, &quot;hausnummer&quot;, &quot;postleitzahl&quot; und &quot;ort&quot; für diese sechs Attribute gebildet. Eine Instanz dieses Datentyps kann hier mit dem new-Operator erzeugt werden. Der öffentliche Konstruktor &quot;Postadresse ()&quot; ist eine Methode mit derselben Bezeichnung wie die Klasse selbst, die aufgerufen werden muss, um die sechs Datenfelder der jeweiligen Instanz &quot;this&quot; zu initialisieren. Auf die einzelnen Datenfelder der in der nicht-öffentlichen Klassenvariable &quot;adresse&quot; gespeicherten sechs Attribute des Datentyps &quot;Postadresse&quot; kann danach über die entsprechenden sechs qualifizierten Bezeichner zugegriffen werden. In der Methode &quot;main&quot; werden die Attribute zwischen den runden Klammern über die qualifizierten Bezeichner als Parameter bei den Aufrufen der allgemeinen Textausgabe-Methode &quot;println&quot; verwendet, die zur Klassenvariable &quot;out&quot; der Klasse &quot;System&quot; im Programmpaket &quot;java.lang&quot; gehört:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
public class Postadresse // Klasse &quot;Postadresse&quot;
{
   // Instanzvariablen
   java.lang.String vorname;
   java.lang.String nachname;
   java.lang.String strasse;
   java.lang.String hausnummer;
   long postleitzahl;
   java.lang.String ort;

   private static Postadresse adresse = new Postadresse (); // Klassenvariable &quot;adresse&quot;

   public Postadresse () // Konstruktor der Klasse &quot;Postadresse&quot;
   {
      this.vorname = &quot;Irgend&quot;;
      this.nachname = &quot;Jemand&quot;;
      this.strasse = &quot;Allee&quot;;
      this.hausnummer = &quot;100&quot;;
      this.postleitzahl = 10000;
      this.ort = &quot;Irgendwo&quot;;
   }

   public static void main (java.lang.String [] argumente) // main-Methode der Klasse &quot;Postadresse&quot;
   {
      java.lang.System.out.println (adresse.vorname);
      java.lang.System.out.println (adresse.nachname);
      java.lang.System.out.println (adresse.strasse);
      java.lang.System.out.println (adresse.hausnummer);
      java.lang.System.out.println (adresse.postleitzahl);
      java.lang.System.out.println (adresse.ort);
   }
}
&lt;/syntaxhighlight&gt;

====Komplexe Anweisungen====
In der Programmiersprache Java kann die Gestaltung eines softwaretechnischen Containers &quot;host&quot; beispielsweise mit der Variablen &quot;layout&quot; realisiert werden. Hierzu werden Instanzen von Objekten der Klassen &quot;Container&quot; und &quot;GroupLayout&quot; erzeugt:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   java.awt.Container host = new java.awt.Container ();
   javax.swing.GroupLayout layout = new javax.swing.GroupLayout (host);
&lt;/syntaxhighlight&gt;

Eine multiple qualifizierte Bezeichnung zur Referenzierung von Datenfeldern mit diversen Aufrufen typengebundener Methoden (Unterprogramme) kann dann mit einer einzigen hyperkomplexen Anweisung in einer Zeile zusammengefasst werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   layout.setVerticalGroup (layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING).addGroup (layout.createSequentialGroup ().addContainerGap ().addGroup(layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING).addGroup (layout.createSequentialGroup().addGroup (layout.createParallelGroup (javax.swing.GroupLayout.Alignment.BASELINE))))));
&lt;/syntaxhighlight&gt;

Mit Zeilenumbrüchen wird der inhaltlich identische Quelltext schon besser nachvollziehbar:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
   layout.setVerticalGroup
   (
      layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING)
      .addGroup (layout.createSequentialGroup ()
      .addContainerGap ()
      .addGroup (layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING)
      .addGroup (layout.createSequentialGroup()
      .addGroup (layout.createParallelGroup (javax.swing.GroupLayout.Alignment.BASELINE)))))
   );
&lt;/syntaxhighlight&gt;

Durch Verwendung von Hilfsvariablen mit sprechenden Bezeichnern wird der Quelltext zwar etwas länger, aber noch verständlicher. Die Komplexität ist deutlich reduziert, und die Anweisungsfolge kann viel einfacher nachvollzogen, überprüft oder angepasst werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
      javax.swing.GroupLayout.SequentialGroup sequentialGroup2 = layout.createSequentialGroup ();
      javax.swing.GroupLayout.ParallelGroup parallelBaselineGroup = layout.createParallelGroup (javax.swing.GroupLayout.Alignment.BASELINE);
      sequentialGroup2 = sequentialGroup2.addGroup (parallelBaselineGroup);

      javax.swing.GroupLayout.ParallelGroup parallelLeadingGroup2 = layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING);
      parallelLeadingGroup2 = parallelLeadingGroup2.addGroup (sequentialGroup2);

      javax.swing.GroupLayout.SequentialGroup sequentialGroup1 = layout.createSequentialGroup ();
      sequentialGroup1 = sequentialGroup1.addContainerGap ();
      sequentialGroup1 = sequentialGroup1.addGroup (parallelLeadingGroup2);

      javax.swing.GroupLayout.ParallelGroup parallelLeadingGroup1 = layout.createParallelGroup (javax.swing.GroupLayout.Alignment.LEADING);
      parallelLeadingGroup1 = parallelLeadingGroup1.addGroup (sequentialGroup1);

      layout.setVerticalGroup (parallelLeadingGroup1);
&lt;/syntaxhighlight&gt;

==Programmgestaltung==
Idealerweise kann die kontextfreie Grammatik der verwendeten Programmiersprache mit einer strukturierten Metasprache, wie zum Beispiel der '''Erweiterten Backus-Naur-Form''' ('''EBNF''') nach der Norm ISO/IEC 14977 dargestellt werden. Jedes strukturierte Programm und jede Datenstruktur kann damit eindeutig definiert werden. Leider trifft dies für viele Programmiersprachen nicht zu. Die Darstellung beliebiger ganzer Zahlen (sowohl negative, als auch positive und die Null) mit Zeichen kann in der Erweiterten Backus-Naur-Form zum Beispiel schrittweise so definiert werden:

&lt;syntaxhighlight lang=&quot;ebnf&quot;&gt;
 NatuerlicheZiffer = &quot;1&quot; | &quot;2&quot; | &quot;3&quot; | &quot;4&quot; | &quot;5&quot; | &quot;6&quot; | &quot;7&quot; | &quot;8&quot; | &quot;9&quot;;
 Ziffer = &quot;0&quot; | NatuerlicheZiffer;
 NatuerlicheZahl = NatuerlicheZiffer{Ziffer};
 GanzeZahl = &quot;0&quot; | [&quot;-&quot;]NatuerlicheZahl;
&lt;/syntaxhighlight&gt;

[[Datei:Nassi-Shneiderman diagram - InsertionSort.svg|mini|rechts|hochkant=2|Beispiel für einen Algorithmus mit zwei geschachtelten, kopfgesteuerten Schleifen in der Darstellung als Nassi-Shneidermann-Diagramm.]]

Programme können als '''Struktogramm''' (auch '''Nassi-Shneidermann-Diagramm genannt''') nach Norm DIN 66261 notiert werden. Alle Teilprogramme sind dabei so geartet, dass sie ausgehend von einem einfachen Hauptblock, der für das gesamte Programm und somit für mindestens einen Unterprogrammaufruf steht, durch schrittweise Verfeinerung hierarchisch zusammengesetzt werden können. Am Ende der Hierarchie stehen dann elementare Teilprogramme, die nicht weiter zerlegt werden können.

Die zyklomatische Komplexität der Software kann zum Beispiel mit der '''McCabe-Metrik''' untersucht und analysiert werden. Hierbei sollte darauf geachtet werden, dass die Komplexität beschränkt bleibt, damit der Quelltext überschaubar bleibt und gut nachvollzogen werden kann. Durch geeignete Strukturierung ist dies in modernen Programmiersprachen immer möglich, und mit einer McCabe-Metrik bis maximal 10 ist die Komplexität meist hinreichend niedrig.

Dies gilt nicht nur für den prozeduralen Programmablauf, sondern gleichermaßen für Datenstrukturen, bei denen komplexe Datentypen aus elementaren Datentypen übersichtlich und hierarchisch zusammengesetzt werden können.

Wichtig ist, dass die Anzahl der Programmzeilen ('''lines of code''') zwar gut als Maß für das zeitliche Wachstum einer bestimmten Software herangezogen werden kann, dies jedoch nicht geeignet ist, um eine Aussage über die Qualität oder Strukturiertheit des Programmcodes zu treffen. Weder eine besonders kleine noch eine besonders große Anzahl von Programmzeilen sind ein Garant für guten oder strukturierten Code.

Das Optimum ist nicht erreicht, wenn nichts mehr hinzugefügt werden kann, weil schon alles implementiert ist, sondern wenn nichts mehr entfernt werden kann, ohne dass die Implementierung hiervon beeinträchtigt wird (frei nach Antoine de Saint-Exupéry in ''Wind, Sand und Sterne - Terre des Hommes'' (1939)).

Programmieren ist nicht nur ein einfaches Handwerk, sondern eine anspruchsvolle Kunstfertigkeit (vergleiche auch Donald E. Knuth: ''The Art of Computer Programming'').
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

===Sichtbarkeiten===
Grundsätzlich gilt immer das '''Prinzip der Lokalität'''. Dies bedeutet, dass auf Programmkonstrukte nur dort zugegriffen werden kann und darf, wo es unbedingt erforderlich ist. Zum Datenaustausch zwischen verschiedenen Programmteilen dienen unter diesen Voraussetzungen Schnittstellen, die in der strukturierten Programmierung exakt definiert sein müssen.

Alle Klassenvariablen, Instanzvariablen und Parametervariablen sowie Rückgabewerte werden in Bezug auf ihre Teilprogramme zum Beispiel als '''lokale Variablen''' behandelt, so dass sie nur innerhalb dieser Teilprogramme aufgerufen und verändert werden können. Auf diese Weise können unbeabsichtigte und unerwünschte Seiteneffekte nachhaltig vermieden werden.

Je weniger lokal eine Variable definiert ist, desto größer ist die Gefahr, dass diese unbeabsichtigt oder sogar zuwider den Absichten des Programmierers verändert werden kann, was dann zu entsprechend dramatischen und schwer identifizierbaren Programmfehlern führen kann, die zudem erst zur Laufzeit auftreten und oft nur zufällig und somit umso schwerer zu entdecken sind. Variablen sollen also immer so '''lokal''' wie möglich definiert werden. Am besten sind Variablen lokalisiert, wenn sie innerhalb der Teilstruktur definiert werden, wo die Variablen üblicherweise „sichtbar” (und demzufolge verwendbar) sind. Außerhalb der Blöcke sind diese Variablen dann „unsichtbar” und somit auch nicht benutzbar.

Für Programmiersprachen die keine explizite Blockanweisung für Teilprogramme haben, ist die am stärksten lokalisierte Definition in der Regel innerhalb einer Methode respektive einer Prozedur oder einer Funktion. Die nächsthöhere Strukturebene ist dann - sofern möglich - das Modul beziehungsweise die Klasse (dies ist zwar häufig eine vom Compiler zu übersetzende Einheit, ist jedoch nicht unbedingt identisch mit einer Quelltextdatei). Innerhalb von Programmstrukturen sollten Variablen möglichst mit dem Sichtbarkeitsmodifikator für die ausschließlich interne Verwendbarkeit (zum Beispiel mit dem Modifikator ''private'' oder ''limited'') deklariert werden. Solche internen Variablen können dann gegebenenfalls mit entsprechend zu implementierenden Konstruktoren initialisiert, mit sogenannten Getter-Methoden abgefragt und mit Setter-Methoden verändert werden. Falls diese exportiert werden (beispielsweise mit dem Modifikator ''public'' oder ''export''), ist auch außerhalb der Deklarationsstruktur ein definierter indirekter Zugriff auf die internen Variablen möglich.

Manche Programmiersprachen erlauben eine Deklaration, die außerhalb des Deklarationsbereiches nur gesehen respektive gelesen werden können (zum Beispiel mit dem Modifikator ''read-only'' für Variablen oder ''implement-only'' für Methoden). In diesem Fall können die entsprechenden Variablen oder Methoden außerhalb der Deklarationsstruktur also nicht verändert, aber zumindest abgefragt oder aufgerufen werden.

'''Globale Variablen''', die überall innerhalb von großen Programmeinheiten verändert werden können, sind immer vermeidbar, erhöhen die Gefahr von Programmfehlern und erleichtern unter Umständen Cyber-Attacken.

Besondere Probleme ergeben sich, wenn innerhalb eines Sichtbarkeitsbereiches für verschiedene Dinge gleichlautende '''Bezeichner''' verwendet werden dürfen. Dies kann wegen der Wahlfreiheit bei der Benennung sehr leicht vermieden werden, indem einfach keine gleichlautenden Bezeichner benutzt werden. Im folgenden Beispiel wird verdeutlicht, wie in einem Java-Programm zwischen den Bezeichnern von lokalen und globalen Variablen sowie von Methoden formal dennoch eindeutig unterschieden werden kann:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
public class Bezeichner
{
	// globale Variable &quot;bezeichner&quot; (Klassenvariable)
	private static long bezeichner = 1;

	// Methode &quot;bezeichner&quot; (Unterprogramm)
	private static long bezeichner ()
	{
		// lokale Variable &quot;bezeichner&quot; in der Methode &quot;bezeichner&quot;
		long bezeichner = 3;
		return bezeichner;
	}

	// Hauptprogramm (Methode &quot;main&quot;)
	public static void main (java.lang.String [] argumente)
	{
		// Ausgabe der globalen Variable aus der Klasse &quot;Bezeichner&quot;
		java.lang.System.out.println (&quot;Wert der globalen Variable = &quot; + Bezeichner.bezeichner);

		// lokale Variable &quot;bezeichner&quot; in der Methode &quot;main&quot;
		long bezeichner = 2;
		// Ausgabe der lokalen Variable aus der Methode &quot;main&quot;
		java.lang.System.out.println (&quot;Wert der lokalen Variable = &quot; + bezeichner);

		// Ausgabe des Ergebnisses des Aufrufs der Methode &quot;bezeichner&quot;
		java.lang.System.out.println (&quot;Wert des Unterprogramms = &quot; + bezeichner ());
	}
}
&lt;/syntaxhighlight&gt;

In dieser Java-Klasse &quot;Bezeichner&quot; gibt es vier gleichlautende Bezeichner &quot;bezeichner&quot;:

* Der Name einer '''globalen Klassenvariable'''.
* Der Name einer '''Methode'''.
* Der Name einer '''lokalen Variable''' in der Methode &quot;bezeichner&quot;.
* Der Name einer '''lokalen Variable''' in der Methode &quot;main&quot;.

Nach den Regeln der Programmiersprache Java haben lokale Bezeichner bei der Referenzierung innerhalb einer Blockanweisung Vorrang, so dass bei der Verwendung dieser Bezeichner immer auf die lokale Variable zugegriffen wird. Im obigen Beispiel haben die beiden lokalen Variablen &quot;'''bezeichner'''&quot; nichts miteinander zu tun und können nur in ihrer entsprechenden Methode referenziert werden. Soll in einem lokalen Sichtbarkeitsbereich auf die globale Klassenvariable referenziert werden, so kann dies durch einen expliziten und '''qualifizierten Bezeichner''' erwirkt und sichergestellt werden, im obigen Beispiel mit &quot;'''Bezeichner.bezeichner'''&quot;. Der Bezeichner einer Methode kann durch das stets folgende runde Klammerpaar identifiziert werden, im obigen Beispiel &quot;'''bezeichner ()'''&quot;.

===Modularisierung===
Teilprogramme können Methoden oder ganze Sammlungen von Datenstrukturen und Methoden sein. Diese werden oft '''Klassen''' oder '''Module''' genannt und können in '''Paketen''' gruppiert werden. Alle Teilprogramme sollen eindeutige und sprechende Bezeichner und streng definierte Signaturen und Schnittstellen für die Namen und die Datentypen aller Parameter beziehungsweise Klassen- und Instanzvariablen haben. Bei diesen Teilprogrammen handelt es sich in der Regel um die kleinsten dauerhaft speicherbaren Programmeinheiten, die zum Beispiel in einer Datenbank oder einem Dateisystem zu größeren Einheiten wie Verzeichnissen, Paketen oder Bibliotheken zusammengefasst werden.

Solche Programmeinheiten werden durch ihre '''Signatur''' eindeutig gekennzeichnet. Die Signatur besteht zunächst aus dem '''Namen''' der Programmeinheit. Ferner kann mit einem Modifikator explizit definiert werden, dass diese Programmeinheit allgemein, also von allen und beliebigen anderen Programmeinheiten, verfügbar sein soll (Modifikator ''public'' / ''öffentlich''). Für eine Beschränkung nur auf die nächst höhere Programmeinheit, wie beispielsweise einem Paket (englisch &quot;package&quot;), kann der Modifikator ''private'' verwendet werden.

Eine typische Programmbibliothek hat in der Programmiersprache Java am Beispiel des Moduls &quot;java.base&quot; und der beiden Pakete &quot;java.io&quot; und &quot;java.lang&quot; folgende ausschnittsweise Struktur und Hierarchie:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
module java.base;

   package java.io;

      class Reader;
      {
         // Implementation der Klasse Reader
      }

      class Writer;
      {
         // Implementation der Klasse Writer
      }

   package java.lang;

      class String;
      {
         // Implementation der Klasse String
      }

      class System;
      {
         // Implementation der Klasse System
      }
&lt;/syntaxhighlight&gt;

===Unterprogramme===
Unterprogramme werden in Programmiersprachen ganz unterschiedlich genannt. Meistens werden die Begriffe '''Methode''', '''Prozedur''', '''Funktion''' oder '''Kommando''' verwendet. Unterprogramme werden durch ihre '''Signatur''' eindeutig deklariert, und alle Unterprogrammaufrufe müssen sich streng an diese Deklaration halten. Die Signatur besteht zunächst aus dem '''Namen''' des Unterprogramms.

Unterprogramme haben optional einen '''Rückgabewert''', für die der Datentyp ebenfalls festgelegt werden muss und der in streng strukturierten Programmiersprachen ebenfalls zur Signatur des Unterprogramms gehört und verwendet werden muss. Solche Unterprogramme mit Rückgabewert werden in Anlehnung an die mathematischen Funktionen in manchen Programmiersprache explizit '''Funktion''' genannt. Leider ist es in manchen Programmiersprachen erlaubt, Rückgabewerte von solchen Funktionen zu ignorieren und diese nicht in einer Variablen zu speichern oder im Rahmen eines Ausdrucks auszuwerten, was zu leicht zu übersehenden Programmierfehlern führen kann.

Ferner gibt es innerhalb der Signatur optionale '''Modifikatoren''', die die Regeln für die Sichtbarkeit (zum Beispiel ''öffentlich'' / ''privat'' / ''eingeschränkt'', englisch: ''public'' / ''private'' / ''limited'') festlegen.

In der objektorientierten Programmierung werden Unterprogramme oft als '''Methoden''' bezeichnet, da sie keine konkreten oder vollständigen Anweisungen enthalten müssen und durch Überschreiben erweitert oder angepasst werden dürfen. Die Überschreibbarkeit einer Methode wird mit einem weiteren Modifikator festgelegt (wie zum Beispiel mit ''statisch'' / ''erweiterbar'' / ''abstrakt'' / ''abgeschlossen'', englisch: ''static'' / ''extensible'' / ''abstract'' / ''final'').

Unterprogramme haben keinen, einen oder mehrere '''Parameter'''. Unterprogramme ohne Parameter werden auch parameterlose Unterprogramme genannt. Parameter verhalten sich innerhalb des Unterprogramms wie lokale Variablen, nur dass sie beim Aufruf der Unterprogramme angegeben werden müssen und gegebenenfalls zusammen mit dem Rückgabewert die Schnittstelle für den Datenaustausch zum aufrufenden Programm darstellen. Die Anzahl, die Namen, die Datentypen und die Reihenfolge der '''Parameter''' gehören ebenfalls zur Signatur einer Unterprogramms. Beim Aufruf eines Unterprogramms müssen alle Parameter in der richtigen Reihenfolge und zuweisungskompatibel angegeben werden. Parameter können unterschieden werden in:

* '''Eingangsparameter''' ('''in'''), die als Wert (englisch ''value'') übergeben (kopiert) und nur innerhalb des jeweiligen Unterprogramms verwendet werden. Nach Beendigung des Unterprogrammaufrufs sind sie ungültig und dürfen beziehungsweise können nicht mehr referenziert werden.
* '''Ausgangsparameter''' ('''out'''), die als Referenzen (Zeiger auf einen Speicherbereich, englisch ''pointer'') übergeben und deren Werte erst innerhalb des Unterprogramms ermittelt und zugewiesen werden. Nach Beendigung des Unterprogrammaufrufs sind die jeweiligen Werte über ihre Referenzen abrufbar. Die referenzierten Speicherbereiche müssen vor dem Unterprogrammaufruf allokiert worden sein (der Speicherort und die Speichergröße sind dadurch festgelegt), aber der Speicherinhalt muss noch nicht definiert worden sein, da er innerhalb des Unterprogramms nicht verwendet, sondern erst bestimmt und dann zugewiesen wird. Beim Programmieren ist große Sorgfalt darauf zu legen, dass die entsprechenden Zuweisungen innerhalb des Unterprogramms in jedem Fall erfolgen, falls die verwendete Programmiersprache dies nicht sowieso vorschreibt und erzwingt.
* '''Durchgangsparameter''' ('''var'''iable), die als Referenzen mit definierten Speicheradressen (Zeigern) an das Unterprogramm übergeben, innerhalb des Unterprogramms verwendet und nach einer möglichen Veränderung (respektive '''Var'''iation) während des Unterprogrammaufrufs weiterverwendet werden können. Nach Beendigung des Unterprogrammaufrufs sind ihre aktuellen Werte in den aufrufenden Programmteilen über die Referenzen abrufbar.

===Grundlegende Anweisungen===
Grundsätzlich kommt die strukturierte Programmierung in imperativen Programmiersprachen mit folgenden grundlegenden Anweisungen aus:

* '''Deklaration''', zum Beispiel bei Klassen, Methoden, Variablen oder Konstanten mit einer eindeutigen Signatur:
** '''Modifikatoren''' für die Sichtbarkeit, Verwendbarkeit oder Veränderbarkeit
** '''Bezeichner'''
** Optional (bei Methoden, Funktionen, Prozeduren): '''Parameter''' mit Deklaration der Bezeichner, der Veränderbarkeiten und der Datentypen
** Optional (bei Funktionen): Datentyp des '''Rückgabewertes'''
* '''Blockanweisung''', zum Beispiel BEGIN ... END oder { ... }
* '''Zuweisung''', zum Beispiel a := b - c; (das Gleichheitseichen ist nicht zu verwechseln mit einem Vergleichsoperator)
* '''Aufruf von Unterprogrammen''':
** '''Kommandos''' (ohne Parameter und ohne Rückgabewert)
** '''Prozeduren''' oder Methoden (ohne Rückgabewert)
** '''Funktionen''' (mit Rückgabewert)
* '''Rückgabe''' bei Funktionen, zum Beispiel return x;

Anweisungen werden häufig durch ein reserviertes Zeichen abgeschlossen, wie zum Beispiel mit einem Semikolon.

Das folgende Beispiel zeigt eine Java-Klasse mit 15 grundlegenden Anweisungen:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
// Deklaration der oeffentlichen Klasse &quot;Anweisungen&quot;
public class Anweisungen
// Implementation der Klasse mit einer Blockanweisung &quot;{}&quot;
{	
	// Deklaration der privaten, globalen Klassenvariable &quot;flaeche&quot; vom Datentyp &quot;double&quot;
	private static double flaeche;

	// Deklaration der privaten statischen Methode &quot;kreisflaeche&quot; (Unterprogramm) zur Berechnung der Flaeche eines Kreises mit dem Radius &quot;radius&quot;
	// mit dem Parameter &quot;radius&quot; vom Datentyp &quot;double&quot;
	// und mit einer Gleitkommazahl vom Datentyp &quot;double&quot; als Rueckgabewert
	private static double kreisflaeche (double radius)
	// Implementation der Methode &quot;kreisflaeche&quot; mit einer Blockanweisung &quot;{}&quot;
	{
		// Deklaration der lokalen Variable &quot;ergebnis&quot; vom Datentyp &quot;double&quot;
		double ergebnis;

		// Zuweisung eines Ausdrucks an die Variable &quot;ergebnis&quot; mit dem Zuweisungsoperator &quot;=&quot;
		// Syntax: &quot;Variablenname Zuweisungsoperator Ausdruck Semikolon&quot;
		// Der arithmetische Ausdruck verwendet zwei Multiplikationsoperatoren &quot;*&quot;
		// Die Kreiszahl pi aus der Klasse &quot;java.lang.Math&quot; wird qualifiziert bezeichnet: &quot;java.lang.Math.PI&quot;
		ergebnis = java.lang.Math.PI * radius * radius;

		// Ruecksprunganweisung &quot;return&quot; mit der Rueckgabe der Gleitkommazahl &quot;ergebnis&quot;
		return ergebnis;
	}

	// Deklaration der oeffentlichen statischen Methode main (Hauptprogramm)
	public static void main (java.lang.String [] arguments)
	// Implementation der Methode &quot;main&quot; mit einer Blockanweisung &quot;{}&quot;
	{
		// Deklaration der lokalen Variable &quot;raddurchmesser&quot; vom Datentyp double
		double raddurchmesser;

		// Initialisierung der lokalen Variable &quot;raddurchmesser&quot; durch Zuweisung des konstanten arithmetischen Zahlenausdrucks &quot;1.5&quot;
		raddurchmesser = 1.5;

		// Aufruf der Methode &quot;kreisflaeche&quot; mit dem arithmetischen Ausdruck &quot;raddurchmesser / 2&quot; als Parameter
		// Der Rueckgabewert des Methodenaufrufs ist ein Ausdruck und wird der globalen Klassenvariablen &quot;flaeche&quot; zugewiesen
		flaeche = kreisflaeche (raddurchmesser / 2);

		// Aufruf der Methode &quot;println&quot; mit dem Parameter &quot;flaeche&quot; zur Ausgabe der berechneten Kreisflaeche
		// Die Methode aus der Klasse &quot;java.lang.System&quot; wird qualifiziert bezeichnet: &quot;java.lang.System.out.println&quot;
		java.lang.System.out.println (flaeche);
	}
}
&lt;/syntaxhighlight&gt;

Diese Anweisungen sind in der Reihenfolge des Auftretens:
# '''Deklaration''' der Klasse &quot;Anweisungen&quot;
# '''Blockanweisung''' zur Implementation der Klasse &quot;Anweisungen&quot;
# '''Deklaration''' der Klassenvariable &quot;flaeche&quot;
# '''Deklaration''' der Methode &quot;kreisflaeche&quot; (Unterprogramm)
# '''Blockanweisung''' zur Implementation der Methode &quot;kreisflaeche&quot;
# '''Deklaration''' einer lokalen Variable &quot;ergebnis&quot; in der Methode &quot;kreisflaeche&quot; 
# '''Zuweisung''' an die lokale Variable &quot;ergebnis&quot; in der Methode &quot;kreisflaeche&quot;
# '''Rücksprung''' vom Unterprogramm &quot;kreisflaeche&quot; zum Hauptprogramm &quot;main&quot;
# '''Deklaration''' der Methode &quot;main&quot; (Hauptprogramm)
# '''Blockanweisung''' zur Implementation der Methode &quot;main&quot;
# '''Deklaration''' der lokalen Variable &quot;raddurchmesser&quot;
# '''Zuweisung''' an die lokale Variable &quot;raddurchmesser&quot;
# '''Aufruf''' des Unterprogramms &quot;kreisflaeche&quot;
# '''Zuweisung''' an die globale Klassenvariable &quot;flaeche&quot;
# '''Aufruf''' des Unterprogramms &quot;println&quot;

===Anweisungsstrukturen===
Anweisungesstrukturen setzen sich aus mehreren Anweisungen zusammen. Eine Methode besteht zum Beispiel aus einer Deklaration mit der Definition der Schnittstelle, der unmittelbar eine Blockanweisung mit der Implementierung folgt.

Zu den weiteren elementaren Anweisungsstrukturen für Teilprogramme gehören:

* '''Anweisungsfolgen'''
* '''Kontrollstrukturen'''
** '''Fallunterscheidungen'''
*** bedingte Anweisungen (if - then)
*** einfache Verzweigungen (if - then - else)
*** mehrfache Verzweigungen (switch - case - else)
** '''Wiederholungen (Schleifen)'''
*** kopfgesteuerte Schleifen (while-Schleifen, for-Anweisungen)
*** fußgesteuerte Schleifen (repeat - until, do - while)

Bei jedem elementaren Teilprogramm (respektive jeder Methode, Prozedur oder Funktion, aber auch bei jeder Definition von Datenstrukturen) sollte der Quelltext bequem und vollständig auf einer Bildschirmseite gelesen werden können, ohne dass der Text im Betrachtungsfenster verschoben werden muss. Dabei empfiehlt es sich, Methodenaufrufe und übersichtliche Blockanweisungen zu verwenden, mit denen der Quellcode in Unterabschnitte gegliedert werden kann (Verfeinerung).

Im folgenden Beispiel werden drei geschachtelte Blockanweisungen durch jeweils ein Paar geschweifter Klammern begrenzt. Die äußersten Klammern dienen zur Begrenzung der Implementation der Methode &quot;printMonth&quot;, die inneren Blockanweisungen sind ebenso wie alle anderen Anweisungen nach rechts eingerückt:

 printMonth ()
 {
    const int NumberOfWeekdays ← 7
    const int LastDay ← 31
 
    int column
    int day ← 1
 
    while (day &lt;= LastDay)
    {
       printInt (day)
       column ← day modulo NumberOfWeekdays
       if (column = 0)
       {
          printLine ()
       }
       day ← day + 1
    }
 }

Wächst die Länge einer Methode zu sehr an, können und sollen einzelne Blockanweisungen unter Berücksichtigung der entsprechenden Übergabeparameter in eigene, aufzurufende Methoden ausgelagert werden, wodurch der Code geringfügig länger, aber wesentlich besser verständlich wird:

 optionalNewLine (int day)
 {
    const int NumberOfWeekdays ← 7
 
    int column ← day modulo NumberOfWeekdays
 
    if (column = 0)
    {
       printLine ()
    }
 }
 
 void printMonth ()
 {
    const int LastDay ← 31
    int day ← 1
 
    while (day &lt;= LastDay)
    {
       printInt (day)
       optionalNewLine (day)
       day ← day + 1
    }
 }

Hierbei ist es hilfreich, wenn die aufzurufenden Programmteile vor ihrer ersten Verwendung implementiert werden, im Quelltext also zuerst definiert (also deklariert und implementiert) und erst weiter unten benutzt (respektive aufgerufen oder referenziert) werden.

Häufig wird behauptet, dass die Performanz der ausgeführten Programme durch die Aufteilung in solche Unterprogramme leiden würde, da die zahlreichen Aufrufe und Rücksprünge Rechenzeit und Speicherressourcen kosten. In den allermeisten Fällen ist dies auf modernen Rechenmaschinen jedoch zu vernachlässigen. Bei den meisten Anwendungen wird am Speicherbedarf und an der Rechenzeit nicht bemerkt werden können, ob ein strukturiertes oder ein unstrukturiertes Programm vorliegt. Bestenfalls bei extrem rechenintensiven Aufgaben (wie zum Beispiel beim sogenannten &quot;number crunching&quot; (&quot;Zahlenfressen&quot;), bei Monte-Carlo-Simulationen oder Big-Data-Analysen) kann dies bei den extrem häufig aufgerufenen Unterprogrammen einen nennenswerten Effekt haben. Hierbei kann eine wohlstrukturierte Parallelisierung von Programmen oder die Ausgliederung von Rechenaufgaben in spezialisierte Hardware (Graphikprozessoren, digitale Signalprozessoren (DSP), Field Programmable Gate Arrays (FPGA) oder Quantencomputer) wesentlich zu einer Beschleunigung der Programmabläufe beitragen.

Eine Software, die von den Anwendern als zu langsam empfunden wird, ist meist nur schlecht programmiert. Ferner kann gar nicht häufig genug betont werden, dass die Entwicklung und Wartung unstrukturierter Programme erheblich länger dauert und wesentlich fehleranfälliger ist.

=== Schrittweise Verfeinerung ===
Die Implementierung von Software geschieht in der Regel vom Großen ins Kleine. Grob entworfene Anweisungsfolgen und Datenstrukturen werden dabei im Rahmen einer '''schrittweisen Verfeinerung''' immer genauer den Anforderungen angepasst.

Die folgenden Aspekte sind bei der schrittweisen Verfeinerung nach wie vor typisch:&lt;ref&gt;Niklaus Wirth: [http://sunnyday.mit.edu/16.355/wirth-refinement.html Program Development by Stepwise Refinement], Communications of the Association for Computing Machinery, Band 14, Nummer 4, April 1971, Seiten 221 bis 227&lt;/ref&gt;

* In jedem Schritt wird eine Aufgabe (ein Programmteil / ein Datensatz) in Unteraufgaben (in Unterprogramme / in Unterdatensätze) aufgeteilt.
* Der Grad der Abkapselung von Unteraufgaben bestimmt, wie leicht oder schwer Programme und Datenstrukturen angepasst oder übertragen werden können.
* Die Notation für Programme und Daten sollte stets so weit wie möglich sowohl der natürlichen Sprache und der Natur der Sache als auch der Hardware und den Software-Werkzeugen angepasst sein.
* Die Berücksichtigung der Kriterien Laufzeiteffizienz und Speichereffizienz sowie Klarheit und Regelmäßigkeit der Strukturen ist in allen Entwicklungsschritten bis zur Fertigstellung relevant.
* Es muss immer erwogen werden, dass ein korrekt funktionierendes Programm durch eine bessere Version ersetzt werden kann und dass frühere Entscheidungen aus allen Entwicklungsschritten revidiert werden können.
* Die Entwicklung und Wartung guter Programme ist alles andere als trivial, wird aber durch den Einsatz streng strukturierter Programmiersprachen deutlich erleichtert.

== Datenstrukturen ==
Nicht nur der Programmcode, sondern auch die zu verarbeitenden Daten müssen gut strukturiert werden, um die Entwicklungszeiten zu reduzieren, die Qualität der Programme zu erhöhen und die Wartung der Quelltexte zu erleichtern. Gehören zum Beispiel ganz verschiedene Attribute zu einer Sache, sollen diese Attribute zu einer Datenstruktur zusammengefasst werden. Datenstrukturen können auch geschachtelt eingesetzt werden, so dass sehr umfangreiche und komplexe Datenstrukturen abgebildet werden können.

===Aufzählungen===
Eine '''Aufzählung''' (englisch &quot;enumeration&quot;) wird verwendet, wenn bestimmte Eigenschaften von Datenstrukturen abzählbar und endlich sind. Mit diesen thematisch zusammengehörigen Aufzählungen können im Programmtext an allen entsprechenden Stellen statt abstrakt zugeordneter Zahlen konkret zugeordnete symbolische Konstanten mit sprechenden und selbsterklärenden Bezeichnern verwendet werden. Manche Programmiersprachen bieten dafür sogar die Möglichkeit an, dafür eigene Datentypen zu erstellen, in vielen Programmiersprachen wird das jedoch auf sehr simple Weise mit ganzzahligen Basisdaten nachgebildet.

Im folgenden Beispiel wird erläutert, wie verschiedene Kalendersysteme als Aufzählung behandelt werden können. Hierbei werden die folgenden vier Kalendersysteme zu Auswahl:
* Jüdisches Kalendersystem, Kennzahl = 1
* Julianisches Kalendersystem, Kennzahl = 2
* Gregorianisches Kalendersystem, Kennzahl = 3
* Islamisches Kalendersystem, Kennzahl = 4

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Kalendersystem
{
   public final static long JUEDISCH = 1; // Lunisolarkalender
   public final static long JULIANISCH = 2; // Solarkalender bis 4. Oktober 1582 (Donnerstag)
   public final static long GREGORIANISCH = 3; // Solarkalender seit 15. Oktober 1582 (Freitag)
   public final static long ISLAMISCH = 4; // Lunarkalender
}
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;oberon2&quot;&gt;
(* Programmiersprache Oberon *)

MODULE Kalendersystem;

   CONST
      JUEDISCH = 1; (* Lunisolarkalender *)
      JULIANISCH = 2; (* Solarkalender bis 4. Oktober 1582 (Donnerstag) *)
      GREGORIANISCH = 3; (* Solarkalender seit 15. Oktober 1582 (Freitag) *)
      ISLAMISCH = 4; (* Lunarkalender *)
&lt;/syntaxhighlight&gt;

In manchen, meist älteren Programmiersprachen gibt es explizite Aufzählungstypen, bei denen der Compiler automatisch die dazugehörigen ganzen Kennzahlen festlegt, ohne dass diese im Quelltext auftauchen, weil ausschließlich die symbolischen Konstanten aus der Deklaration des Aufzählungstyps verwendet werden. Variablen des Datentyps &quot;Kalendersystem&quot; im folgenden Beispiel dürfen nur die vier zwischen den runden Klammern explizit angegebenen respektive aufgezählten symbolischen Konstanten und keine beliebigen ganzen Zahlen verwenden:

&lt;syntaxhighlight lang=&quot;modula2&quot;&gt;
(* Programmiersprache Modula-2 *)

   TYPE Kalendersystem = (JUEDISCH, JULIANISCH, GREGORIANISCH, ISLAMISCH);
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;cpp&quot;&gt;
/* Programmiersprache C++ */

   enum Kalendersystem = {JUEDISCH, JULIANISCH, GREGORIANISCH, ISLAMISCH};
&lt;/syntaxhighlight&gt;

===Verbunde===
Gehören mehrere verschiede Attribute zu einer Datenstruktur, spricht man auch von einem '''Verbund'''. Diese Datenstrukturen werden je nach Programmiersprache häufig &quot;struct&quot; oder &quot;record&quot; genannt. Alle Attribute können und müssen über einen zentralen Zugang adressiert werden. Dies soll im Folgenden anhand der Datenstruktur &quot;Kalenderdatum&quot; beispielhaft erläutert werden.

Ein Kalenderdatum möge aus einem '''Tag''', einem '''Monat''', einem '''Jahr''' und einem '''Kalendersystem''' bestehen:

Alle vier Attribute werden in vier unabhängigen Datenfeldern gespeichert. Im vorliegenden Beispiel sind zwar alle vier Datenfelder vom Basisdatentyp &quot;ganze Zahl&quot; (&quot;long&quot; oder &quot;INTEGER&quot;), die Bedeutung und die gültige Zahlenbereiche unterscheiden sich jedoch:
* Tag: ganze Zahl im Intervall [1..31]
* Monat: ganze Zahl im Intervall [1..12]
* Jahr: ganze Zahl
* Kalendersystem. ganze Zahl des Aufzählungstyps &quot;Kalendersystem&quot; mit den vier Optionen (JUEDISCH, JULIANISCH, GREGORIANISCH, ISLAMISCH)

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Kalenderdatum
{
   // Instanzvariablen
   private long tag;
   private long monat;
   private long jahr;
   private long kalendersystem;

   public Kalenderdatum (long tag, long monat, long jahr, long kalendersystem) // Konstruktor zur Initialisierung von Instanzvariablen der Klasse Kalenderdatum
   {
      this.tag = tag;
      this.monat = monat;
      this.jahr = jahr;
      this.kalendersystem = kalendersystem;
   }

   public static void main (java.lang.String [] argumente) // main-Methode der Klasse &quot;Kalenderdatum&quot;
   {
      Kalenderdatum kalenderdatum = new Kalenderdatum (10, 4, 2023, Kalendersystem.GREGORIANISCH); // Eine neue Instanz wird erzeugt und durch den Aufruf des Konstruktors initialisiert
      java.lang.System.out.print (kalenderdatum.tag);
      java.lang.System.out.print (&quot;.&quot;);
      java.lang.System.out.print (kalendekalenderdatum.monat);
      java.lang.System.out.print (&quot;.&quot;);
      java.lang.System.out.print (kalenderdatum.jahr);
      java.lang.System.out.println (); // Zeilenumbruch
   }
}
&lt;/syntaxhighlight&gt;

&lt;syntaxhighlight lang=&quot;oberon2&quot;&gt;
(* Programmiersprache Oberon *)

   IMPORT Out; (* Import des Moduls &quot;Out&quot; für die Textausgabe *)

   TYPE Kalenderdatum =
   RECORD
      tag: INTEGER;
      monat: INTEGER;
      jahr: INTEGER;
      kalendersystem: INTEGER;
   END;

   VAR kalenderdatum; (* Variable *)

   BEGIN
      kalenderdatum.tag = 10;
      kalenderdatum.monat = 4;
      kalenderdatum.jahr = 2023;
      kalenderdatum.kalendersystem = Kalendersystem.GREGORIANISCH;

      Out.Int (kalenderdatum.tag);
      Out.String (&quot;.&quot;);
      Out.Int (kalenderdatum.monat);
      Out.String (&quot;.&quot;);
      Out.Int (kalenderdatum.jahr);
      Out.Ln; (* Zeilenumbruch *)
   END;
&lt;/syntaxhighlight&gt;

Die Textausgabe lautet jeweils:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
23.4.2023
&lt;/syntaxhighlight&gt;

===Arrays===
In Arrays werden endlich viele und abzählbare Elemente eines bestimmten Datentyps in einer geordneten Reihe gespeichert. Die einzelnen Elemente können über einen ganzzahligen Index angesprochen werden. Der niedrigste Index ist meistens der Index Null, und dieser zeigt auf die erste Speicheradresse des Arrays. Da alle Elemente vom gleichen Datentyp sind, wird für jedes Element immer der gleiche Speicherplatz benötigt. Elemente mit komplexen Datentypen, werden nicht direkt im Array gespeichert, sondern dieses enthält als Verweise Zeiger mit den Speicheradressen der Inhalte der Elemente. Wenn der Speicherbedarf für ein Element (oder dessen Zeiger) &lt;math&gt;S_E&lt;/math&gt; Bytes beträgt und das Array insgesamt &lt;math&gt;N&lt;/math&gt; Elemente hat, dann berechnet sich der Speicherbedarf &lt;math&gt;S&lt;/math&gt; für das ganze Array aus dem Produkt:

&lt;math&gt;S = S_E \cdot N&lt;/math&gt;

Die Speicheradresse &lt;math&gt;A_i&lt;/math&gt; des i-ten Elements des Arrays berechnet sich dann mit einfacher und effizient ausführbarer Arithmetik aus der Speicheradresse des Arrays &lt;math&gt;A&lt;/math&gt;, dem Speicherbedarf für ein Element (oder dessen Zeiger) &lt;math&gt;S_E&lt;/math&gt; und dem Index &lt;math&gt;i&lt;/math&gt; :

&lt;math&gt;A_i = A + S_E \cdot i&lt;/math&gt; mit &lt;math&gt;0 \le i &lt; N&lt;/math&gt;

Die Speicheradresse des ersten Elements mit dem Index Null &lt;math&gt;A_0&lt;/math&gt; ist also stets identisch mit der Speicheradresse des Arrays &lt;math&gt;A&lt;/math&gt;.

Im folgenden Beispiel wird ein Array mit acht zufällig verteilten Gleitkommazahlen dargestellt, bei denen jede Gleitkommazahl einen Speicherplatz von '''8&amp;nbsp;Bytes''' (Datentyp '''double''' mit 64&amp;nbsp;Bits) belegt:

{| class=&quot;wikitable&quot;
|'''Länge des Arrays &lt;math&gt;N&lt;/math&gt;'''
|'''Speicheradresse des Arrays (dezimal) &lt;math&gt;A&lt;/math&gt;'''
|'''Speicheradresse des Arrays (hexadezimal) &lt;math&gt;A&lt;/math&gt;'''
|'''Speicherbedarf für eine Gleitkommazahl in Bytes &lt;math&gt;S_E&lt;/math&gt;'''
|-
|8
|10000000
|98 96 80
|8
|-
|'''Index &lt;math&gt;i&lt;/math&gt;'''
|'''Speicheradresse des Elements im Array (dezimal) &lt;math&gt;A_i = A + S_E \cdot i&lt;/math&gt;'''
|'''Speicheradresse des Elements im Array (hexadezimal) &lt;math&gt;A_i = A + S_E \cdot i&lt;/math&gt;'''
|'''Gespeicherter Inhalt des Elements (Gleitkommazahl)'''
|-
|0
|10000000
|98 96 80
|678,1495238
|-
|1
|10000008
|98 96 88
|317,4610959
|-
|2
|10000016
|98 96 90
|574,3131347
|-
|3
|10000024
|98 96 98
|673,9323679
|-
|4
|10000032
|98 96 A0
|854,6637912
|-
|5
|10000040
|98 96 A8
|764,4845853
|-
|6
|10000048
|98 96 B0
|335,5146962
|-
|7
|10000056
|98 96 B8
|545,0787382
|}

Das folgende Java-Programm implementiert ein solches Array mit acht Gleitkommazahlen:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Array
{
	
	// Klassenvariable zufallszahlen als Array mit acht Gleitkommazahlen
   private static double zufallszahlen [] = new double [8];

   public static void setzeZufallszahlen (long startwert) // Methode zur Bestimmung aller Gleitkommazahlen
   {
	   // Variable zufallszahl
	   java.util.Random zufallszahl = new java.util.Random (startwert); // Startwert für erste Zufallszahl

	   long anzahl = zufallszahlen.length;
	   int zaehler = 0; // der Index von Arrays darf nicht vom Datentyp long sein
	   while (zaehler &lt; anzahl)
	   {
		   zufallszahlen [zaehler] = zufallszahl.nextDouble ();
		   zaehler++;
	   }
   }

   public static void ausgabeZufallszahlen () // Methode zur Ausgabe aller Gleitkommazahlen
   {
	   long anzahl = zufallszahlen.length;
	   int zaehler = 0; // der Index von Arrays darf nicht vom Datentyp long sein
	   while (zaehler &lt; anzahl)
	   {
		   java.lang.System.out.println (zufallszahlen [zaehler]);
		   zaehler++;
	   }
   }

   public static void main (java.lang.String [] argumente) // Hauptprogramm &quot;main&quot; zum Aufruf der beiden Unterprogramme
   {
	   setzeZufallszahlen (1000); // Aufruf des Unterprogramms setzeZufallszahlen mit dem Parameter 1000 als Startwert
	   ausgabeZufallszahlen (); // Aufruf des Unterprogramms ausgabeMonatsname ohne Parameter
   }
}&lt;/syntaxhighlight&gt;

Mit dem Aufruf des Hauptprogramms ''main'' erfolgt die Ausgabe von acht Pseudozufallszahlen:

&lt;syntaxhighlight&gt;
0.7101849056320707
0.574836350385667
0.9464192094792073
0.039405954311386604
0.4864098780914311
0.4457367367074283
0.6008140654988429
0.550376169584217
&lt;/syntaxhighlight&gt;

Im nächsten Beispiel mit einem Array für die zwölf Monatsnamen ist der Datentyp eines Arrayelements jeweils eine Zeichenkette, die je nach ihrer Länge verschieden große Speicherbereiche belegen:

{| class=&quot;wikitable&quot;
|'''Länge des  Arrays'''
|'''Speicheradresse des Arrays'''
|'''Speicherbedarf für eine Speicheradresse'''
|'''Speicherbedarf für ein Zeichen'''
|
|
|-
|13
|10000000
|4
|2
|
|
|-
|Index
|'''Speicheradresse des Elements im Array'''
|'''Gespeicherter Inhalt des Elements (Speicheradresse)'''
|'''Länge der Zeichenkette'''
|'''Speicherbedarf der Zeichenkette'''
|'''Gespeicherter Inhalt des Elements (Zeichenkette)'''
|-
|0
|10000000
|20000000
|8
|16
|&quot;deutsch&quot;
|-
|1
|10000004
|20000016
|7
|14
|&quot;Januar&quot;
|-
|2
|10000008
|20000030
|8
|16
|&quot;Februar&quot;
|-
|3
|10000012
|20000046
|5
|10
|&quot;März&quot;
|-
|4
|10000016
|20000056
|6
|12
|&quot;April&quot;
|-
|5
|10000020
|20000068
|4
|8
|&quot;Mai&quot;
|-
|6
|10000024
|20000076
|5
|10
|&quot;Juni&quot;
|-
|7
|10000028
|20000086
|5
|10
|&quot;Juli&quot;
|-
|8
|10000032
|20000096
|7
|14
|&quot;August&quot;
|-
|9
|10000036
|20000110
|10
|20
|&quot;September&quot;
|-
|10
|10000040
|20000130
|8
|16
|&quot;Oktober&quot;
|-
|11
|10000044
|20000146
|9
|18
|&quot;November&quot;
|-
|12
|10000048
|20000164
|9
|18
|&quot;Dezember&quot;
|}

In den folgenden Beispielen in der Programmiersprache werden die zwölf Monatsnamen in Arrays mit Zeichenketten gespeichert. Hierzu wird die Sprache der Monatsnamen im ersten Arrayfeld mit dem Index 0 und die zwölf Monatsnamen in den folgenden Arrayfeldern mit den Indizes 1 bis 12 gespeichert:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Monatsnamen
{
   // Klassenvariable
   private static java.lang.String monatsnamen [] = {&quot;deutsch&quot;,
      &quot;Januar&quot;, &quot;Februar&quot;, &quot;März&quot;, &quot;April&quot;, &quot;Mai&quot;, &quot;Juni&quot;, &quot;Juli&quot;, &quot;August&quot;, &quot;September&quot;, &quot;Oktober&quot;, &quot;November&quot;, &quot;Dezember&quot;};

   public static void ausgabeMonatsname (int monat) // Methode zur Textausgabe von Monatsnamen
   {
      java.lang.System.out.println (monatsnamen [monat]);
   }

   public static void main (java.lang.String [] argumente) // Hauptprogramm &quot;main&quot; zum Aufruf der Methode ausgabeMonatsname
   {
      ausgabeMonatsname (1); // Aufruf des Unterprogramms ausgabeMonatsname mit dem Parameter 1
   }
}
&lt;/syntaxhighlight&gt;

Mit dem Aufruf des Hauptprogramms ''main'' erfolgt die Ausgabe mit dem ersten Monatsnamen:

&lt;syntaxhighlight&gt;
Januar
&lt;/syntaxhighlight&gt;

In einigen Programmiersprachen muss die Größe der Array vor der Initialisierung festgelegt werden, und die Zuordnung zwischen den Indizes und den Arrayfeldern ist dann auch bei der Initialisierung explizit erkennbar:

&lt;syntaxhighlight lang=&quot;oberon2&quot;&gt;
(* Programmiersprache Component Pascal *)

MODULE Monatsnamen;

   IMPORT Out; (* Import des Moduls &quot;Out&quot; für die Textausgabe *)

   TYPE Monatsnamen = POINTER TO ARRAY OF ARRAY OF CHAR;

   VAR monatsnamen: Monatsnamen;

   PROCEDURE InittialisiereMonatsnamen (); (* Prozedur zur Initialisierung von Monatsnamen *)
   BEGIN
      NEW (monatsnamen, 13, 10); (* Reservierung von 13 Zeichenketten mit je 10 Zeichen) *)
      monatsnamen [0] := &quot;deutsch&quot;;
      monatsnamen [1] := &quot;Januar&quot;;
      monatsnamen [2] := &quot;Februar&quot;;
      monatsnamen [3] := &quot;März&quot;;
      monatsnamen [4] := &quot;April&quot;;
      monatsnamen [5] := &quot;Mai&quot;;
      monatsnamen [6] := &quot;Juni&quot;;
      monatsnamen [7] := &quot;Juli&quot;;
      monatsnamen [8] := &quot;August&quot;;
      monatsnamen [9] := &quot;September&quot;;
      monatsnamen [10] := &quot;Oktober&quot;;
      monatsnamen [11] := &quot;November&quot;;
      monatsnamen [12] := &quot;Dezember&quot;;
   END InittialisiereMonatsnamen;

   PROCEDURE AusgabeMonatsname (monat: INTEGER); (* Prozedur zur Textausgabe von Monatsnamen *)
   BEGIN
      Out.String (monatsnamen [monat]);
   END AusgabeMonatsname;

   PROCEDURE Hauptprogramm*;
   BEGIN
      InittialisiereMonatsnamen (); (* Initialisierung beim Laden des Moduls &quot;Monatsnamen&quot; *)
      AusgabeMonatsname (1); (* Aufruf des Unterprogramms AusgabeMonatsname mit dem Parameter 1 *)
   END Hauptprogramm;

END Monatsnamen.
&lt;/syntaxhighlight&gt;

Durch den Aufruf von ''Monatsnamen.Hauptprogramm'' erfolgt die Ausgabe mit dem ersten Monatsnamen:

&lt;syntaxhighlight&gt;
Januar
&lt;/syntaxhighlight&gt;

Arrays können mehrdimensional gestaltet werden. Um zum Beispiel zwei Sprachen mit Monatsnamen zu speichern, kann eine weitere Dimension mit einem Index für die gewünschte Sprache implementiert werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */

public class Monatsnamen
{
   // Konstanten für Sprachaufzählung
   public final static int DEUTSCH = 0;
   public final static int ENGLISCH = 1;

   // Klassenvariablen
   private static java.lang.String monatsnamen [] [] =
   {
      {&quot;deutsch&quot;, &quot;Januar&quot;, &quot;Februar&quot;, &quot;März&quot;, &quot;April&quot;, &quot;Mai&quot;, &quot;Juni&quot;, &quot;Juli&quot;, &quot;August&quot;, &quot;September&quot;, &quot;Oktober&quot;, &quot;November&quot;, &quot;Dezember&quot;},
      {&quot;english&quot;, &quot;January&quot;, &quot;February&quot;, &quot;March&quot;, &quot;April&quot;, &quot;May&quot;, &quot;June&quot;, &quot;July&quot;, &quot;August&quot;, &quot;September&quot;, &quot;October&quot;, &quot;November&quot;, &quot;December&quot;}
   };

   public static void ausgabeMonatsname (int monat) // Methode zur Textausgabe von Monatsnamen
   {
      java.lang.System.out.println (&quot;Deutschsprachiger Monatsname = &quot; + monatsnamen [DEUTSCH] [monat]);
      java.lang.System.out.println (&quot;Englischsprachiger Monatsname = &quot; + monatsnamen [ENGLISCH] [monat]);
   }

   public static void main (java.lang.String [] argumente) // Hauptprogramm &quot;main&quot; zum Aufruf der Methode ausgabeMonatsname
   {
      ausgabeMonatsname (2);
   }
}
&lt;/syntaxhighlight&gt;

Mit dem Aufruf des Hauptprogramms ''main'' erfolgt die Ausgabe mit den beiden zweiten Monatsnamen:

&lt;syntaxhighlight&gt;
Deutschsprachiger Monatsname = Februar
Englischsprachiger Monatsname = February
&lt;/syntaxhighlight&gt;

Bei anderen Programmiersprachen ist durch die obligatorische Verwendung von symbolischen Konstanten (im Beispiel unten &quot;DEUTSCH&quot; und &quot;ENGLISCH&quot;) bei jeder erforderlichen, also auch bei allen initialen Zuweisungen zu Array-Elementen übersichtlich und klar erkennbar, welches Feld angesprochen wird:

&lt;syntaxhighlight lang=&quot;oberon2&quot;&gt;
(* Programmiersprache Component Pascal *)

MODULE Monatsnamen;

   IMPORT Out; (* Import des Moduls &quot;Out&quot; für die Textausgabe *)

   CONST
      DEUTSCH = 0;
      ENGLISCH = 1;

   TYPE Monatsnamen = POINTER TO ARRAY OF ARRAY OF ARRAY OF CHAR;

   VAR monatsnamen: Monatsnamen;

   PROCEDURE InittialisiereMonatsnamen ();  (* Prozedur zur Initialisierung von Monatsnamen *)
   BEGIN
      NEW (monatsnamen, 2, 13, 10); (* Reservierung von 2 mal 13 Zeichenketten mit je 10 Zeichen) *)
      monatsnamen [DEUTSCH, 0] := &quot;deutsch&quot;;
      monatsnamen [DEUTSCH, 1] := &quot;Januar&quot;;
      monatsnamen [DEUTSCH, 2] := &quot;Februar&quot;;
      monatsnamen [DEUTSCH, 3] := &quot;März&quot;;
      monatsnamen [DEUTSCH, 4] := &quot;April&quot;;
      monatsnamen [DEUTSCH, 5] := &quot;Mai&quot;;
      monatsnamen [DEUTSCH, 6] := &quot;Juni&quot;;
      monatsnamen [DEUTSCH, 7] := &quot;Juli&quot;;
      monatsnamen [DEUTSCH, 8] := &quot;August&quot;;
      monatsnamen [DEUTSCH, 9] := &quot;September&quot;;
      monatsnamen [DEUTSCH, 10] := &quot;Oktober&quot;;
      monatsnamen [DEUTSCH, 11] := &quot;November&quot;;
      monatsnamen [DEUTSCH, 12] := &quot;Dezember&quot;;

      monatsnamen [ENGLISCH, 0] := &quot;english&quot;;
      monatsnamen [ENGLISCH, 1] := &quot;January&quot;;
      monatsnamen [ENGLISCH, 2] := &quot;February&quot;;
      monatsnamen [ENGLISCH, 3] := &quot;March&quot;;
      monatsnamen [ENGLISCH, 4] := &quot;April&quot;;
      monatsnamen [ENGLISCH, 5] := &quot;May&quot;;
      monatsnamen [ENGLISCH, 6] := &quot;June&quot;;
      monatsnamen [ENGLISCH, 7] := &quot;July&quot;;
      monatsnamen [ENGLISCH, 8] := &quot;August&quot;;
      monatsnamen [ENGLISCH, 9] := &quot;September&quot;;
      monatsnamen [ENGLISCH, 10] := &quot;October&quot;;
      monatsnamen [ENGLISCH, 11] := &quot;November&quot;;
      monatsnamen [ENGLISCH, 12] := &quot;December&quot;;
   END InittialisiereMonatsnamen;

   PROCEDURE AusgabeMonatsname (monat: INTEGER); (* Prozedur zur Textausgabe von Monatsnamen *)
   BEGIN
      Out.String (&quot;Sprache = &quot; + monatsnamen [DEUTSCH, 0] + &quot;: &quot; + monatsnamen [DEUTSCH, monat]);
      Out.Ln;
      Out.String (&quot;Sprache = &quot; + monatsnamen [ENGLISCH, 0] + &quot;: &quot; + monatsnamen [ENGLISCH, monat]);
      Out.Ln;
   END AusgabeMonatsname;

   PROCEDURE Hauptprogramm*;
   BEGIN
      InittialisiereMonatsnamen (); (* Initialisierung beim Laden des Moduls &quot;Monatsnamen&quot; *)
      AusgabeMonatsname (2);
   END Hauptprogramm;

END Monatsnamen.
&lt;/syntaxhighlight&gt;

Durch den Aufruf von ''Monatsnamen.Hauptprogramm'' erfolgt die Ausgabe mit den beiden zweiten Monatsnamen:

&lt;syntaxhighlight&gt;
Sprache = deutsch: Februar
Sprache = english: February
&lt;/syntaxhighlight&gt;

Die Verwendung von Indizes außerhalb der deklarierten oder angeforderten Array-Größen verursachen in streng strukturierten Programmiersprachen zur Laufzeit einen Programmabbruch. Bei sorgfältiger Programmierung ist deswegen darauf zu achten, dass nur gültige Indizes zur Anwendung kommen können. In schlecht strukturierten Programmiersprachen wie C oder C++ werden die Indizes von Arrays in der Regel nicht automatisch geprüft, so dass unbemerkt auf ungültige Speicheradressen zugegriffen werden kann und bei entsprechenden Angriffen Daten verfälscht und schadhafter Binärcode in die Programme eingeschleust sowie zur Ausführung gebracht werden kann.

==Kontrollstrukturen==
Kontrollstrukturen dienen dazu, den Programmablauf in wohlstrukturierter Weise im Sinne eines Algorithmus zu beeinflussen. Hierfür können '''Unterprogramme''' aufgerufen, '''Fallunterscheidungen''' vorgenommen oder Programmteile mehrfach durchlaufen werden ('''Schleifen''').

===Sprunganweisungen===
Sprünge an andere Programmstellen ergeben sich inhärent beim Aufruf von Unterprogrammen. Geschieht ein solcher Sprung durch eine explizite Sprunganweisung im Programmcode, wie zum Beispiel mit Goto-, Break- oder Continue-Anweisungen, ist dies unstrukturiert und im Übrigen auch völlig überflüssig, denn Programme mit Sprunganweisungen können immer und ohne großen Aufwand durch Kontrollstrukturen, also mit Hilfe von '''Unterprogrammen''', '''Schleifen''' oder '''Fallunterscheidungen''', gestaltet werden.

Explizite Sprunganweisungen stellen eine &quot;Programmiertechnik mit dem Holzhammer&quot; und wegen der daraus resultierenden verschlungenen Pfade während des Programmablaufs einen sogenannten '''Spaghetti-Code''' dar. Im Quellcode ist der Programmablauf nicht mehr ohne weiteres nachvollziehbar, beispielsweise bei der Untersuchung, von welchen Stellen des Programms an welche anderen Stellen gesprungen werden soll oder worden sein kann.

Im Falle der Switch-Case-Anweisung handelt es sich bei der in manchen Programmiersprachen verwendeten Break-Anweisung eigentlich nicht um eine Sprunganweisung, sondern um einen obligatorischen Begrenzer (englisch: ''delimiter''), der zur Herstellung der Programmstruktur erforderlich ist. In einigen Programmiersprachen darf dieser Begrenzer (''break'') jedoch weggelassen werden, um den Code in bestimmten aber vereinzelten Fällen etwas kürzer gestalten zu können, was aber gleichzeitig und unabdingbar zu unstrukturierter Programmierung führt, die Programmabläufe unübersichtlich macht und dazu führen kann, dass die Programme gegebenenfalls nur noch schwierig nachzuvollziehen und zu warten sind.

====Unterprogramme====
[[Datei:Unterprogrammaufruf.png|mini|rechts|hochkant=1|Von der Hauptroutine &quot;Procedure main&quot; eines gestarteten Programms wird nach Ausführung der Anweisungen &quot;Instructions&amp;nbsp;1&quot; ein Unterprogramm &quot;Procedure sub&quot; aufgerufen (&quot;Call sub&quot;), und der Programmablauf wird mit den dortigen Anweisungen &quot;Instructions&quot; fortgeführt. Wenn die letzte Anweisung &quot;Return&quot; des Unterprogramms erreicht worden ist, wird in das Hauptprogramm zurückgesprungen und der Programmablauf an der Stelle direkt hinter dem Aufruf des Unterprogramms mit den Anweisungen &quot;Instructions&amp;nbsp;2&quot; fortgesetzt.]]

Eine besonders häufig angewendete Programmiertechnik ist der Aufruf von Unterprogrammen. Unterprogramme stellen im Sinne des Quelltextes eines Programmes üblicherweise Prozeduren, Methoden oder Funktionen dar. Mit der Programmanweisung des Aufrufs kann der Programmablauf zum entsprechenden Unterprogramm verzweigt werden. Hierbei können in der Regel auch Parameter übergeben werden, um zwischen dem aufrufenden Programmteil und dem Unterprogramm Daten austauschen zu können. Ist das Unterprogramm vollständig abgearbeitet worden, wird der Programmablauf hinter der Stelle des Unterprogrammaufrufs fortgesetzt.

Unterprogramme können mehrfach und von allen Stellen des Programcodes aufgerufen werden, in dem das Unterprogramm sichtbar ist. Die Unterscheidung zwischen Prozeduren und Methoden ist nicht einheitlich. Etliche Programmiersprachen verwenden kategorisch nur einen der beiden Begriffe. Hierbei kann zwischen traditionellen (statischen) Prozeduren und objektorientierten (typengebunden oder dynamischen) Prozeduren unterschieden werden. Letztere werden als Methoden einer Klasse oder aber auch als typengebundene Prozeduren eines Programmoduls bezeichnet.

====Rücksprunganweisungen====
Nach Ablauf des Unterprogramms kann ein Rückgabewert an das aufrufende Programm zurückgegeben werden, der im aufrufenden Programmteil dann zur Verfügung steht und als Ausdruck zum Beispiel an eine Variable zugewiesen werden kann. In diesem Fall wird ein Unterprogramm auch '''Funktion''' genannt, da als Ergebnis des Unterprogrammaufrufs ein Funktionswert berechnet wurde und dann zurückgegeben wird.

Jedes Unterprogramm hat daher exakt eine Rücksprunganweisung (oft mit dem Schlüsselwort '''return''' gekennzeichnet), die logischerweise die letzte Anweisung sein muss, damit alle Anweisungen vorher durchgeführt werden können. Der Rücksprung erfolgt immer zur Stelle des Unterprogrammaufrufs, wo die Programmausführung anschließend fortgeführt wird.

Hat das Unterprogramm keinen Rückgabewert, der an den aufrufenden Programmteil zurückgegeben werden muss, wird in vielen Programmiersprachen auf eine explizite Rücksprunganweisung verzichtet; in diesem Fall wird sie also implizit ausgeführt. Ist das Hauptprogramm vollständig durchlaufen, wird das Programm nach dessen Rücksprunganweisung beendet, und die Kontrolle an das Laufzeitsystem oder das Betriebssystem zurückgegeben, von wo aus das Hauptprogramm aufgerufen worden war.

Mehrfache und insbesondere vorzeitige Rücksprunganweisungen in einem Unterprogramm sind unstrukturiert und daher zu unterlassen, auch wenn die Programmiersprache dies nicht zwingend fordert. Vorzeitige Unterprogrammabbrüche ('''Break'''-Anweisungen) verhindern, dass nachfolgende Programmsequenzen ausgeführt werden können, obwohl sie bei einer Ausführung das Ergebnis für den Rückgabewert beeinflussen würden. Dies kann zur Verwirrung führen, weil das Unterprogramm bei einer Überprüfung oder einer Analyse immer vollständig auf potentielle vorzeitige Unterprogrammabbrüche durchsucht werden muss.

Der folgende unstrukturierte Java-Code, der den in der Variablen '''ergebnis''' gespeicherten Wert vor dessen Rückgabe als Text ausgeben soll, verdeutlicht dies:

&lt;syntaxhighlight lang=&quot;java&quot;&gt;
private static double unterprogramm (double parameter)
{
   double ergebnis = parameter;
   boolean ganzzahlig = (parameter % 1 == 0);
   if (ganzzahlig) return ergebnis;
   ergebnis = ergebnis + 1;
   java.lang.System.out.println (&quot;Ergebnis = &quot; + ergebnis);
   return ergebnis;
}
&lt;/syntaxhighlight&gt;

Die Erhöhung des Wertes der Variablen '''ergebnis''' sowie die Textausgabe mit dem Aufruf der Methode '''println''' unmittelbar vor der Rücksprunganweisung erfolgen wegen der beiden vorhandenen Rücksprunganweisungen nur, wenn der Wert des Parameters '''parameter''' nicht ganzzahlig ist. Demzufolge erzeugen die folgenden beiden Unterprogrammaufrufe

&lt;syntaxhighlight lang=&quot;java&quot;&gt;
   unterprogramm (0);
   unterprogramm (0.5);
&lt;/syntaxhighlight&gt;

die Textausgabe:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
Ergebnis = 1.5
&lt;/syntaxhighlight&gt;

Dieses formal korrekte, aber unerwünschte Verhalten wird nur nachvollziehbar, wenn der gesamte Code des Unterprogramms analysiert wird, was bei komplexeren Unterprogrammen und beim Vorhandensein mehrerer Rücksprunganweisungen sehr aufwendig werden kann..

Das folgende Unterprogramm implementiert den eigentlich gewünschten Algorithmus in strukturierter Form mit einer einzigen Rücksprunganweisung am Ende des Unterprogramms:

&lt;syntaxhighlight lang=&quot;java&quot;&gt;
private static double unterprogramm (double parameter)
{
   double ergebnis = parameter;
   boolean ganzzahlig = (parameter % 1 == 0);
   if (! ganzzahlig)
   {
      ergebnis = ergebnis + 1;
   }
   java.lang.System.out.println (&quot;Ergebnis = &quot; + ergebnis);
   return ergebnis;
}
&lt;/syntaxhighlight&gt;

Die Textausgabe bei den oben angegebenen  Aufrufen des Unterprogramms erfolgt nun wie gewünscht:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
Ergebnis = 0.0
Ergebnis = 1.5
&lt;/syntaxhighlight&gt;

Es empfiehlt sich grundsätzlich ebenfalls immer, innerhalb von Rücksprunganweisungen keine komplexen Ausdrücke, Kontrollstrukturen oder Unterprogrammaufrufe zu verwenden, um einfache und eindeutige Rückgabewerte zu erhalten sowie diese gegebenenfalls mit einer Textausgabe oder einem Debugger kontrollieren zu können. Im Idealfall wird in der Rücksprunganweisung nur der Wert einer zuvor berechneten lokalen Variable mit einem sprechenden Bezeichner zurückgegeben:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
   ergebnis ← f (a, b, c);
   return ergebnis;
&lt;/syntaxhighlight&gt;

In der Regel ergeben sich durch die zusätzliche explizite Zuweisung an die lokale Variable '''ergebnis''' keine Laufzeiteinbußen, da im übersetzten Maschinencode implizit für den Rückgabewert sowieso eine Zuweisung ausgeführt werden muss. Moderne Übersetzer berücksichtigen diesen Kontext automatisch, so dass in beiden Fällen derselbe Maschinencode erzeugt wird.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

===Fallunterscheidungen===
Die einfachste Fallunterscheidung ist die bedingte Anweisung. Verzweigungen enthalten mindestens zwei alternative Programmpfade.

====Bedingte Anweisung====
[[Datei:einfAusw.png|mini|rechts|hochkant=2|Struktogramm einer bedingten Anweisung.]]

Im folgenden Beispiel mit einer bedingten Anweisung (zum Beispiel if - then - end) wird die Dekrement-Anweisung a-- (der Wert der numerischen Variablen a soll um eins erniedrigt werden) nur dann ausgeführt, falls der boolesche Ausdruck a &gt; b wahr ist, die entsprechende Bedingung also erfüllt ist:

 falls a &gt; b dann a-- ende

Hier wird der Wert der Variablen a also nur dann dekrementiert, wenn der Wert der Variablen a größer ist als der Wert der Variable b. Ansonsten wird der Programmablauf sofort hinter der ende-Marke fortgeführt.

====Einfache Verzweigung====
[[Datei:zweifAusw.png|mini|rechts|hochkant=2|Struktogramm einer einfachen Verzweigung.]]

Die einfachste Verzweigung (zum Beispiel if - then - else - end) enthält genau zwei alternative Pfade, von denen in Abhängigkeit eines booleschen Ausdrucks nur einer ausgeführt wird, wie in diesem Beispiel:

 falls a &gt; b dann a-- ansonsten b-- ende

Je nachdem die entsprechende Bedingung erfüllt ist oder nicht, wird die eine oder die andere Anweisung ausgeführt. Im obigen Beispiel wird der Wert der Variablen a nur dann dekrementiert, falls der Wert der Variablen a größer ist als der Wert der Variable b, ansonsten wird hier im Vergleich zur bedingten Anweisung allerdings der Wert der Variablen b um eins erniedrigt. In beiden Fällen wird das Programm anschließend hinter der ende-Marke fortgeführt.

====Mehrfache Verzweigung====
[[Datei:Mehrseitige Auswahl.png|mini|rechts|hochkant=2|Struktogramm einer mehrfachen Verzweigung.]]

Eine mehrfache Verzweigung (zum Beispiel switch - case - else - end) enthält mehr als zwei alternative Programmpfade, die meist, wie auch im folgenden Beispiel, von ganzzahligen Ausdrücken gesteuert werden:

 verzweige mit dem Wert von a
    falls 1 : unterprogramm_A ()
    falls 2 : unterprogramm_B ()
    falls 3 : unterprogramm_C ()
    ansonsten unterprogramm_D ()
 ende

In Abhängigkeit des in der ganzzahligen Variablen a gespeicherten Zahlenwertes wird genau eines der vier angegebenen Unterprogramme aufgerufen; beim Wert 1 unterprogramm_A, beim Wert 2 unterprogramm_B, beim Wert 3 unterprogramm_C und ansonsten unterprogramm_D. Danach wird der Programmablauf hinter den ende-Marke fortgeführt.

In manchen weniger stakt strukturierten Programmiersprachen wie C sind Vorsicht und Aufmerksamkeit geboten, weil beispielsweise dort die verschiedenen Fälle der entsprechenden switch-Anweisung nur optional mit einer break-Anweisung und nicht immer und obligatorisch abgeschlossen werden. Dies nutzen einige Programmierer, um in bestimmten Situationen mehrere Fälle hintereinander abarbeiten zu lassen. Dieses Vorgehen ist jedoch hochgradig unstrukturiert und führt sehr schnell und unübersichtlichem Programmcode und somit sehr leicht zu Programmierfehlern. Dies kann vermieden werden, wenn in diesen Programmiersprachen hinter jedem unterschiedenem Fall kategorisch die break-Anweisung implementiert wird, auch wenn die Programmiersprache oder der Übersetzer dies nicht fordern.

[[Datei:MehrfAusw.png|mini|rechts|hochkant=2|Struktogramm mit verschachtelten einfachen Verzweigungen, um eine mehrfache Verzweigung zu implementieren.]]

Mehrfache Verzweigungen mit aufeinanderfolgenden numerischen oder aufzählbaren Werten, wie im obigen Beispiel 1, 2 und 3, können rechnerintern unter Umständen effizient genutzt werden, weil die Sprungadressen arithmetisch berechnet werden können. Dies ist bei modernen Laufzeitsystemen in der Regel aber nicht mehr so relevant, und diese mehrfachen Verzweigungen können auch immer durch mehrfache Fallunterscheidungen programmiert werden. Durch eine eigene Anweisung für die mehrfache Verzweigung kann die Übersichtlichkeit des Quelltextes allerdings oft gesteigert werden. Auf der anderen Seite können die Übersichtlichkeit und die Nachvollziehbarkeit in der Regel auch hier mit entsprechenden Unterprogrammaufrufen gesteigert werden.

===Schleifen===
Bei Schleifen wird eine Anweisungsfolge nur dann ausgeführt, wenn die entsprechende boolesche, im Sinne der Schleife lokale Laufvariable den Wert &quot;wahr&quot; hat. Alle Schleifen können auf eine grundlegende Form zurückgeführt werden, bei der ein wesentliches Merkmal ist, ob die Laufvariable '''zu Beginn''' der Schleifenanweisungen den initialen Wert &quot;wahr&quot; erhält (fußgesteuert) oder in der Anfangsbedingung durch einen variablen booleschen Ausdruck bestimmt ist (kopfgesteuert). Es ist sinnvoll, dass diese Laufvariable nur zum Zwischenspeichern der Abbruchbedingung dient und ausschließlich im Zusammenhang mit der Schleife verwendet wird.

Bei wohlstrukturierter Programmierung mit zählenden Schleifen können numerische Laufvariablen verwendet werden, die innerhalb der Schleife vorzugsweise erst in der letzten Anweisung der Schleife aktualisiert werden, damit es innerhalb des Schleifendurchlaufs nicht zu Inkonsistenzen, Verwechslungen oder Mehrdeutigkeiten kommen kann.

Ferner gibt es in der strukturierten Programmierung keine expliziten Sprunganweisungen, die irgendwo innerhalb einer Schleife zum Beispiel mit dem Kommando '''continue''' den Rest der Schleife überspringen und sofort die nächstfolgende Abbruchbedingung der Schleife prüfen lassen. Innerhalb von Schleifen ist es ohne Weiteres möglich, alle Zwischenschritte mit Verzweigungen zu steuern beziehungsweise alle Zwischenergebnisse in lokalen Variablen zu speichern, ohne dass es in modernen Computersystemen zu längeren Ausführungszeiten kommt.

Im Folgenden soll dies mit der Programmiersprache Java an sehr einfachen Schleifen, die alle Zahlen außer der Fünf von Eins bis Zehn ausgeben sollen, erläutert werden.

Unstrukturiertes Beispiel:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
long i = 1;
do
{
  if (i == 5)
  {
    i++; // Die Schleifenendanweisung zum Hochzaehlen der Laufvariable muss hier dupliziert werden, damit es nicht zu einer Fehlfunktion kommt.
    continue; // Die Schleife wird durch diese explizite Sprunganweisung unstrukturiert abgebrochen.
  }
  java.lang.System.out.println (i);
  i++;
} while (i &lt;= 10);
&lt;/syntaxhighlight&gt;

Strukturiertes Beispiel:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
long i = 1;
do
{
  if (i != 5)
  {
     java.lang.System.out.println (i);
  }
  i++;
} while (i &lt;= 10);
&lt;/syntaxhighlight&gt;

====Kopfgesteuerte Schleifen====
[[Datei:KopfgesteuerteSchleife.png|mini|rechts|hochkant=2|Struktogramm einer kopfgesteuerten Schleife.]]

Kopfgesteuerte Schleifen werden auch als '''While'''-Anweisungen bezeichnet.

{| class=&quot;wikitable&quot; style=&quot;text-align:center&quot;
| rowspan=&quot;4&quot; | Kopfgesteuerte Schleife
| colspan=&quot;2&quot; | Setze Laufvariable auf boolesche Anfangsbedingung
|-
| rowspan=&quot;3&quot; | Solange wie die Laufvariable den Wert &quot;wahr&quot; hat führe aus
|-
|Anweisungsfolge
|-
| Setze Laufvariable auf boolesche Endbedingung
|}

Wenn die boolesche Anfangsbedingung zu Beginn den Wert &quot;falsch&quot; hat, wird die Schleife '''nicht durchlaufen'''.

====Fußgesteuerte Schleifen====
[[Datei:FussgesteuerteSchleife.png|mini|rechts|hochkant=2|Struktogramm einer fußgesteuerten Schleife.]]

Die fußgesteuerte Schleife, die auch '''Repeat'''-Anweisung genannt wird, ist ein Sonderfall der kopfgesteuerten Schleife, bei der die boolesche Anfangsbedingung immer auf &quot;wahr&quot; gesetzt wird. Daher wird eine fußgesteuerte Schleife '''immer mindestens einmal durchlaufen'''.

{| class=&quot;wikitable&quot; style=&quot;text-align:center&quot;
| rowspan=&quot;4&quot; | Fußgesteuerte Schleife
| colspan=&quot;2&quot; | Setze Laufvariable auf &quot;wahr&quot;
|-
| rowspan=&quot;3&quot; | Solange wie die Laufvariable den Wert &quot;wahr&quot; hat führe aus
|-
|Anweisungsfolge
|-
| Setze Laufvariable auf boolesche Endbedingung
|}

Da der Ausdruck der booleschen Anfangs- und Endbedingung oft identisch formuliert ist, bietet es sich an, dafür einen Funktionsaufruf zu verwenden, um eine Codewiederholung zu vermeiden.

Aus Gründen der Laufzeiteffizienz wird das Setzen der Laufvariablen zu Beginn und die erstmalige Überprüfung der Laufvariablen oft weggelassen, was für die allermeisten Anwendungen heute jedoch unwesentlich ist. Da die Laufvariable in diesem Fall zu Beginn jedoch nicht definiert werden muss und daher gegebenenfalls auch gar nicht definiert wird, birgt dieses Vorgehen die Gefahr in sich, dass die Laufvariable ihren undefinierten Zustand behält. Insbesondere tritt dies ein, wenn das Setzen der Laufvariable auf eine boolesche Endbedingung nicht erfolgt, weil dies in der verwendeten Programmiersprache nicht obligatorisch ist beziehungsweise vom Programmierer vergessen wurde, oder weil dies wegen eines zwangsläufig unstrukturierten Abbruchs innerhalb der Schleife (zum Beispiel mit einer Break-Anweisung) gar nicht erfolgen kann.

====Endlosschleifen====
'''Endlosschleifen''' sind unstrukturiert, da das Programm nicht regelgerecht beendet werden kann. Daher sind diese sogenannten Loop-Anweisungen, wie zum Beispiel

 for (;;)
 {
    ...
 }

 while (true)
 {
    ...
 }

 repeat
 {
    ...
 }
 until (false)

beziehungsweise

 do
 {
    ...
 }
 while (true)

oder

 loop
 {
    ...
 }

zu unterlassen. Insbesondere das Verlassen von Endlosschleifen mit einer '''Sprunganweisung''' oder gar mehreren potentiellen Sprunganweisungen, wie zum Beispiel ''break'' oder ''exit'', ist hochgradig unstrukturierte Programmierung, da der Ausstiegszeitpunkt oder die Stelle des Ausstiegs aus der Schleife (wenn überhaupt) nur schwierig nachzuvollziehen oder zu bestimmen ist.

====For-Schleifen====
Die For-Schleifen-Anweisung

 int i
 for (i ← 0; i &lt; max; i++)
 {
  ...
 }

ist identisch mit der kopfgesteuerten while-Anweisung:

 int i
 i ← 0
 while (i &lt; max)
 {
  ...
  i = i + 1
 }

Es ist im Sinne eines einfachen Sprachumfangs und eines einheitlichen Sprachstils unter Umständen nützlich, für kopfgesteuerte Schleifen keine For-Schleifen, sondern ausschließlich While-Schleifen zu benutzen.

Wenn die Programmiersprache es erlaubt, Zählvariablen ausschließlich für eine Schleife zu definieren, dann hat dies den Vorteil, dass das Prinzip der Lokalität für diese Zählvariablen sehr gut erfüllt ist, da die Zählvariable dann außerhalb der Schleife nicht sichtbar ist und somit auch nicht verwendet werden kann:

 for (int i ← 0; i &lt; max; i++)
 {
  ...
 }

Die äquivalente Schreibweise mit einer while-Schleife sieht wie folgt aus, wobei die äußere Blockanweisung dafür sorgt, dass die Zählvariable &quot;i&quot; innerhalb der Blockanweisung deklariert ist und nur in Verbindung mit der Schleife sichtbar respektive verwendbar ist:

 {
    int i
    i ← 0
    while (i &lt; max)
    {
     ...
     i++
    }
 }

Bei Algorithmen, die aus mehreren Kontrollstrukturen bestehen, ist es im Sinne der besseren Strukturierung vorzuziehen, alle Schleifen in eigene Methoden auszulagern, die aufgerufen werden und deren Schnittstellen über ihre Parameter eindeutig festgelegt sind. Hierbei können die Schleifen verschachtelt sein (innere und äußere Schleife) oder hintereinander ausgeführt werden. In jedem Fall sind alle Parameter und Variablen (also auch die jeweiligen Zählvariablen) innerhalb der entsprechenden Methoden lokal verfügbar.

==Codewiederholungen==
Codewiederholungen gehören insbesondere bei Anfängern sehr häufig zu den kapitalen Fehlern beim Softwareentwurf. Es ist nur scheinbar bequem, bereits vorhandenen Quelltext zu kopieren und für eine ähnliche Aufgabe geringfügig anzupassen. Es ist Größenordnungen besser, den bereits vorhandenen Quelltext so anzupassen, dass er für alle ähnlichen oder zumindest mehrere ähnliche Aufgabenstellungen eingesetzt werden kann. Erfahrene Programmierer wittern schon von Anfang an, dass eine bestimmte Methode auch in einem ähnlichen Kontext eingesetzt werden könnte und entwerfen den Code von vornherein so allgemein wie möglich.

===Symbolische Konstanten===
Konstante Ausdrücke werden in der Regel als '''symbolische Konstanten''' definiert, wie zum Beispiel mit der symbolischen Konstante &quot;Pi&quot; für die Kreiszahl oder die symbolische Konstante &quot;Title&quot; für den Text &quot;Programmierung&quot;:

 const double Pi ← 3.141592654
 const String Title ← &quot;Programmierung&quot;

Statt konstante Ausdrücke zu wiederholen – und sei es nur eine ganze Zahl – ist es erheblich besser, stattdessen eine symbolische Konstante mit einem „sprechenden“ Bezeichner zu verwenden.

Also nicht mit der ganzen Zahl 3:

 int inputNumber ← 3
 ...
 if (inputNumber = 3) ...

Sondern besser mit der symbolischen Konstante &quot;Exit&quot; mit dem unveränderlichen, ganzzahligen Wert 3:

 const int Exit ← 3
 
 int inputNumber ← Exit
 ...
 if (inputNumber = Exit) ...

Oder nicht zweimal mit derselben ganzen Zahl 3:

 if (a &gt; 3) and (b &gt; 3) ...

Sondern besser mit zwei verschiedenen symbolischen Konstanten &quot;Limit_a&quot; und &quot;Limit_b&quot;:

 const int Limit_a ← 3
 const int Limit_b ← 3
 
 if (a &gt; Limit_a) and (b &gt; Limit_b) ...

Auf diese Weise kann auch leicht vermieden werden, dass gleichlautende Ausdrücke mit unterschiedlicher Bedeutung verwechselt werden können, insbesondere wenn sie später einmal geändert werden müssen:

 if (numberOfConstellation &gt; 12)
 {
    Ausgabe (&quot;Diese Sternbildnummer ist ungültig.&quot;)
 }
 
 if (numberOfHalftones &gt; 12)
 {
    Ausgabe (&quot;Das Intervall ist größer als eine Oktave.&quot;)
 }

Die beiden konstanten Zahlensymbole &quot;12&quot; haben nichts außer ihrem Zahlenwert gemeinsam, und daher ist der folgende Code erheblich besser nachvollziehbar:

 const int Number_Of_Constellations ← 12
 const int Number_Of_Halftones_Per_Octave ← 12
 
 ...
 
 if (numberOfConstellation &gt; Number_Of_Constellations)
 {
    Ausgabe (&quot;Diese Sternbildnummer ist ungültig.&quot;)
 }
 
 if (numberOfHalftones &gt; Number_Of_Halftones_Per_Octave)
 {
    Ausgabe (&quot;Das Intervall ist größer als eine Oktave.&quot;)
 }

===Aufruf von Unterprogrammen===
[[Datei:Aufruf.png|mini|rechts|hochkant=2|Struktogramm eines Unterprogrammaufrufs.]]

Unterprogramme, die in vielen Programmiersprachen auch Methoden, Prozeduren oder Funktionen genannt werden, beinhalten sequenzielle Rechenvorschriften (Algorithmen) zum Bearbeiten von Daten, die zu einer Einheit zusammengefasst sind.

So kann zum Beispiel die Rechenvorschrift für die Berechnung des Kreisumfangs aus dem Kreisradius als Folge von Programmanweisungen formuliert werden, aber auch in eine Methode ausgelagert werden. Dieses Unterprogramm kann dann irgendwo im Programmcode aufgerufen werden. Dies gewinnt besonders dann Bedeutung, wenn das Unterprogramm an verschiedenen Stellen aufgerufen werden soll, so dass dann diese Programmanweisungen nicht mehrfach programmiert oder kopiert werden müssen.

Insbesondere wenn die ursprünglichen, an mehreren Stellen auftauchenden Programmanweisungen einen Fehler enthalten, muss dieser nach dem Entdecken des Fehlers - also möglicherweise zu einem viel späteren Zeitpunkt - zur Fehlerbehebung zwangsweise an mehreren Stellen im Programmcode korrigiert werden. Das ist nicht nur mühsam, sondern einzelne relevante Stellen können leicht übersehen werden, so dass der entdeckte Fehler gar nicht vollständig ausgemerzt wird.

Die mehrfach eingegebenen Programmanweisungen zur Berechnung des Kreisumfangs werden beim Auftreten von '''Codewiederholung''' an drei Stellen des Quelltextes programmiert:

 const double Pi ← 3.141592654
 
 double perimeter1 ← radius1 * 2 * Pi
 double perimeter2 ← radius2 * 2 * Pi
 double perimeter3 ← radius3 * 2 * Pi

Mithilfe des im Unterprogramm &quot;perimeter&quot; nur einmal implementierten Algorithmus' zur Ermittlung des Kreisumfangs und dessen dreimaligem Aufruf kann die Wiederholung der Implementierung der Rechenvorschrift leicht vermieden werden:

 /* &quot;perimeter&quot; computes and returns the perimeter of a circle with radius &quot;radius&quot; */
 double perimeter (radius)
 {
    const double Pi ← 3.141592654
    double perimeter ← radius * 2 * Pi
    return perimeter
 }
 
 double perimeter1 ← perimeter (radius1)
 double perimeter2 ← perimeter (radius2)
 double perimeter3 ← perimeter (radius3)

==Zuweisungskompatibilität==
'''Zuweisungskompatibilität''' liegt vor, wenn Ausdrücke und Variablen aufgrund hinreichend kompatibler Datentypen einander zugewiesen, miteinander verglichen oder eindeutig miteinander verknüpft werden können.

Es kann bereits im Quelltext überprüft werden, ob eine hinreichende Zuweisungskompatibilität vorliegt. Liegt diese nicht vor, handelt es sich um eine Typverletzung, und es muss eine explizite Typumwandlung programmiert werden. In diesem Fall kann es sehr leicht zu Programmfehlern kommen.

Programmiersprachen, die für die maschinennahe Programmierung konzipiert wurden, wie zum Beispiel Assemblersprachen oder die Programmiersprache C, haben oft gar keine oder nur eine sehr schwache Typprüfung, was sehr leicht zu Programmfehlern führen kann.

In manchen Programmiersprachen, wie zum Beispiel C, ist es sogar erlaubt, beliebige Zeiger einer Zeigervariablen zuzuweisen, ohne dass geprüft wird oder überhaupt geprüft werden kann, ob die Datentypen der referenzierten Daten kompatibel sind.

===Zeichenketten===
Ein weiteres schwerwiegendes Problem kann sich bei der Verwendung von Zeichenketten (englisch: string) ergeben, die in der Regel zum Speichern von Texten Verwendung finden und die aus einer Sequenz von einzelnen Zeichen respektive Buchstaben (englisch: character) bestehen.

Eine strukturierte Programmiersprache, die Zeichenkettenverarbeitung und einen entsprechenden Datentyp zur Verfügung stellt, sollte fordern, dass jede Zeichenkette mit einem Zeichen abgeschlossen wird, das das Ende der Zeichenkette markiert (englisch: string terminator). Hierfür wird allgemein das Zeichen mit dem numerischen Wert null verwendet, das keinen Buchstaben repräsentiert und in Quelltexten häufig mit den Symbolen NUL, 0X oder \0 kodiert wird.

Manche unstrukturierte Programmiersprachen fordern nicht, dass eine solche Kennzeichnung des Endes der Zeichenkette verwendet werden muss. Bei der Implementation von Zeichenkettenfunktionen in Programmbibliotheken, insbesondere wenn die dazugehörige Programmiersprache gar keinen Datentyp für Zeichenketten zur Verfügung stellt, ist auch bei strukturierten Programmiersprachen nicht unbedingt gewährleistet, dass eine entsprechende Kennzeichnung des Zeichenkettenendes obligatorisch ist. Bei der Implementierung von Vergleichsfunktionen oder Zeichenkettenmanipulationen in unstrukturierten Programmiersprachen oder Programmbibliotheken muss die Tatsache, ob das Nullzeichen vorhanden ist oder nicht, regelmäßig untersucht und berücksichtigt werden. Einfacher und sicherer ist es, mit einer strukturierten Programmiersprache oder einer entsprechenden Programmbibliothek zu arbeiten, bei der immer gewährleistet ist und vorausgesetzt werden kann, dass alle Zeichenketten mit einem Endezeichen abgeschlossen sind.

===Strenge Zuweisungskompatibilität===
Zuweisungen sind uneingeschränkt zulässig, wenn eine strenge Zuweisungskompatibilität gegeben ist. Dazu müssen die Datentypen eines zuzuweisenden Ausdrucks und einer Variable exakt übereinstimmen, wie in folgendem Beispiel mit dem Datentyp &quot;Mann&quot; und den beiden Instanzen &quot;otto&quot; und &quot;emil&quot;:

 TYPE Mann = Verbund von alter und groesse
 
 VARIABLE otto, emil: Mann
 
 otto.alter   ← 50
 otto.groesse ← 1.80
 
 emil ← otto

Alle Attribute von „otto“, nämlich „alter“ und „groesse“, können „emil“ eindeutig zugewiesen werden.

Zwei Instanzen sind streng zuweisungskompatibel, wenn sie derselben Klasse angehören, wie in diesem Beispiel die beiden Objekte &quot;fenster1&quot; und &quot;fenster2&quot; aus der Klasse &quot;Rechteck&quot;:

 TYPE Rechteck = Klasse mit breite, hoehe und mit Methode flaechenberechnung&amp;nbsp;()
 
 VARIABLE fenster1, fenster2: Rechteck
 
 fenster1.breite ← 200
 fenster1.hoehe  ← 100
 fenster1.flaechenberechnung&amp;nbsp;() (Flächenberechnung für „fenster1“ ausführen)
 
 fenster2 ← fenster1
 fenster2.flaechenberechnung&amp;nbsp;() (Flächenberechnung für „fenster2“ ausführen)

Die Zuweisung in der vorletzten Programmzeile ist möglich, da beide Instanzvariablen &quot;fenster1&quot; und &quot;fenster2&quot; derselben Klasse &quot;Rechteck&quot; angehören, und daher liefert auch der Methodenaufruf in der letzten Programmzeile ein korrektes Ergebnis.

====Logische Kompatibilität====
Zwei übereinstimmende Definitionen von zwei Datentypen sind nicht zuweisungskompatibel. Die Daten können zwar eindeutig überführt werden (technische Kompatibilität), es liegen zwei formal zwar identische, aber dennoch verschiedene Definitionen vor, so dass diese keine logische Kompatibilität aufweisen. Folgendes Beispiel wäre demzufolge formal korrekt, aber nicht logisch:

 TYPE Mann = Verbund von alter und groesse
 TYPE Frau = Verbund von alter und groesse
 
 VARIABLE otto: Mann
 VARIABLE anna: Frau
 
 otto.alter   ← 50
 otto.groesse ← 1.80
 
 anna ← otto

Die Zuweisung in der letzten Programmzeile ist technisch zwar ohne Probleme möglich, aber logisch nicht korrekt, und sie birgt daher die Gefahr der Entstehung von Programmierfehlern. Um solche Fehler zu vermeiden, sind Zuweisungen mit impliziter Typumwandlung in einigen Programmiersprachen mit starker Typisierung nicht zulässig, und der Compiler verweigert die Übersetzung dieser Zuweisung.

In der objektorientierten Programmierung kann durch die Vererbung der gemeinsamen Eigenschaften von Datentypen leicht eine logische Kompatibilität hergestellt werden:

 TYPE Mensch = Verbund von alter und groesse
 
 TYPE Mann = Mensch
 TYPE Frau = Mensch
 
 VARIABLE otto: Mann
 VARIABLE anna: Frau
 
 otto.alter   ← 50
 otto.groesse ← 1.80
 
 anna ← otto

Die Objekteigenschaften &quot;alter&quot; und &quot;groesse&quot; sind hierbei Eigenschaften von Objekten des Datentyps &quot;Mensch&quot; und daher sowohl zuweisungskompatibel, als auch logisch korrekt; bei der Zuweisung können und werden nur die Attribute &quot;alter&quot; und &quot;groesse&quot; der gemeinsamen Basisklasse &quot;Mensch&quot; übertragen.

====Wahrheitswerte====
In einigen älteren Programmiersprachen, wie zum Beispiel C, gibt es keinen eigenen Datentyp für zweiwertige boolesche Variablen. Zur Behandlung und Verarbeitung entsprechender Information wird dann häufig der ganzzahlige Datentyp mit dem kleinsten Speicherbedarf verwendet, wobei der Zahlenwert null für den Wahrheitswert „Falsch“ und alle anderen Zahlenwerte für den Wahrheitswert „Wahr“ Verwendung finden. Auch hier ergeben sich logische Inkompatibilitäten und somit ein gefährliches Potential für Komplikationen, da mit binären Werten keine Arithmetik und mit Zahlen keine logischen Verknüpfungen oder logischen Operationen durchgeführt werden können. Im folgenden Beispiel wird dieser Missbrauch verdeutlicht:

 VARIABLE schlechteWahrheit1, schlechteWahrheit2, ergebnisWahrheit: INTEGER
 
 schlechteWahrheit1 ← 0
 schlechteWahrheit2 ← 1
 
 ergebnisWahrheit ← (schlechteWahrheit1 + schlechteWahrheit2)
 
 ergebnisWahrheit ← (schlechteWahrheit2 + schlechteWahrheit2)

Das Ergebnis der ersten arithmetischen Addition ist 1, was fälschlich als der Wahrheitswert „Wahr“ missinterpretiert werden könnte, der nicht dem Ergebnis der logischen Und-Verknüpfung entspricht. Noch offensichtlicher ist das Problem in der zweiten arithmetischen Addition, wo das Ergebnis 2 erzielt wird. Somit existieren ohne Not mehr als zwei Zustände für die binären (also zweiwertigen) Variablen, was schnell zu Missverständnissen und Programmierfehlern führen kann.

Eine eindeutige und korrekte Implementierung wird erreicht, wenn die Programmiersprache oder eine dazugehörige Programmbibliothek einen zweiwertigen Datentyp, wie zum Beispiel „BOOLEAN“ oder „bool“, zwei entsprechende Ausprägungen, wie zum Beispiel &quot;false&quot; und &quot;true&quot;, und die dazugehörigen eindeutigen booleschen Operatoren und Funktionen (beispielsweise &quot;and&quot;, &quot;or&quot; oder &quot;not&quot;) anbietet.

 VARIABLE richtigeWahrheit1, richtigeWahrheit2, ergebnisWahrheit: BOOLEAN
 
 richtigeWahrheit1 ← falsch
 richtigeWahrheit2 ← wahr
 
 ergebnisWahrheit ← (richtigeWahrheit1 und richtigeWahrheit2)
 
 ergebnisWahrheit ← (richtigeWahrheit2 und richtigeWahrheit2)

Sinngemäß gilt das Gleiche für die Verknüpfungen von Mengen. Wenn hier bei den Datentypen und zulässigen Operatoren nicht zwischen Bitmengen (englisch: (bit) sets) und Zahlen unterschieden wird, kommt es wie zum Beispiel bei der Bestimmung von Vereinigungs- oder Differenzmengen zu Interpretationsproblemen. Eine eindeutige und korrekte Implementierung verwendet Datentypen, die für Mengen und Mengenoperationen definiert sind. In einigen Programmiersprachen werden solche Datentypen im Sprachumfang implizit angeboten, in anderen gibt es dafür standardisierte Programmbibliotheken, auf die über Unterprogrammaufrufe zugegriffen werden kann.

===Zuweisungskompatibilität ohne Informationsverlust===
In einigen Fällen kann die Information, die mit einem Datentyp dargestellt werden kann, eindeutig und ohne Informationsverlust in einen anderen Datentyp überführt werden. Typische Beispiele sind ganze Zahlen mit unterschiedlicher Speichergröße. So kann ein Integer mit 16&amp;nbsp;Bit Speichergröße eindeutig in einer vorzeichenbehafteten Integer-Variablen mit 32&amp;nbsp;Bit Speichergröße abgelegt werden, ohne dass die ursprünglich nur mit 16&amp;nbsp;Bit gespeicherte Zahl verändert wird. Umgekehrt ist dies jedoch nicht allgemein möglich, insbesondere unter der Beachtung von Vorzeichen und großen Zahlen. Der folgende Programmierabschnitt zeigt ein Beispiel ohne Zuweisungskompatibilität, da der Datentyp „BYTE“ nur 8&amp;nbsp;Bit Speichertiefe hat und nur Werte zwischen -128 bis +127 und somit nicht die Zahl 555 repräsentieren kann, wohingegen der Datentyp „SHORTINT“ eine Speichertiefe von 16&amp;nbsp;Bit hat und ganze Zahlen von -32768 bis +32767 repräsentieren kann:

 zahl1: BYTE
 zahl2: SHORTINT
 
 zahl2 ← 555
 zahl1 ← zahl2

Die letzte Programmzeile stellt einen ungültigen Versuch der Zuweisung der ganzen Zahl&amp;nbsp;555 aus der Variablen „zahl2“ an die Variable „zahl1“ dar.

Bei einer solchen Programmanweisung kann bei typsicheren Programmiersprachen bereits der Compiler verhindern, dass ausführbarer Maschinencode erzeugt wird. Bei fehlender Überprüfung durch den Compiler kann unbemerkt Information verloren gehen, so dass bei nachfolgenden Berechnungen unter Umständen grobe Berechnungsfehler auftreten, die relativ schwierig zu analysieren sind.

===Zuweisungskompatibilität mit geringem Informationsverlust===
Ein Sonderfall ist die Zuweisung von ganzen Zahlen an Variablen, die Gleitkommazahlen repräsentieren. In der Regel kann ohne die Gefahr von Programmfehlern toleriert werden, große ganze Zahlen implizit in Gleitkommazahlen umzuwandeln, da der Rechenfehler (wenn überhaupt vorhanden) hierbei sehr klein ist. Auch dies kann an einem Beispiel verdeutlicht werden: ein „LONGINT“ mit 64&amp;nbsp;Bit Speichergröße kann die Zahl 9223372036854775807 mit 19 Dezimalstellen speichern. Der folgende Programmierabschnitt zeigt ein Beispiel mit Zuweisungskompatibilität mit einem in der Regel zu vernachlässigenden Informationsverlust, da der Datentyp „REAL“ nach IEEE 754 mit 64&amp;nbsp;Bit nur Zahlen mit einer Mantisse mit maximal 14 Nachkommastellen speichern kann:

 zahl1: LONGINT
 zahl2: REAL
 
 zahl1 ← 9223372036854775807
 zahl2 ← zahl1

Die letzte Anweisung stellt in fast allen Programmiersprachen einen gültigen Versuch der Zuweisung der ganzen Zahl&amp;nbsp;&lt;math&gt;{2}^{63} - 1&lt;/math&gt; aus der Variablen „zahl1“ an die Variable „zahl2“ dar, da diese gerundeten Zahlenwert &lt;math&gt;9{,}22337203685478 \cdot {10}^{18}&lt;/math&gt; enthält, und der Fehler durch das Abschneiden der letzten Nachkommastellen hier nur in einer Größenordnung von &lt;math&gt;{10}^{-14}&lt;/math&gt; liegt und daher für praktisch alle Anwendungen vernachlässigt werden kann.

Bei einer erneuten Datentypkonvertierung zurück zu einem geeigneten ganzzahligen Datentyp kommt es dann aber zu einer Abweichung zu der ursprünglichen ganzen Zahl. In solchen Fällen ist es daher besser, vorsichtshalber und mit Inkaufnahme etwas längerer Programmlaufzeiten ausschließlich mit Gleitkommazahlen zu operieren.

===Zuweisungskompatibilität mit definiertem Informationsverlust===
Zwei Instanzen sind mit definiertem Informationsverlust zuweisungskompatibel, wenn die zuzuweisende Klasse einer Klasse angehört, die von der zugewiesenen Klasse abgeleitet wurde. Alle Daten die in der zugewiesenen Klasse deklariert und somit erforderlich sind, können dann zugewiesen werden, jedoch werden die in der zuzuweisenden abgeleiteten Klasse möglicherweise hinzugefügten Attribute ignoriert, wie das folgende Beispiel verdeutlichen soll, in welchem der Datentyp „Mensch“ alle Eigenschaften vom Datentyp „Lebewesen“ erbt und zusätzlich das Attribut „intelligenzquotient“ bekommt:

 TYPE Lebewesen = Verbund von alter und gewicht
 
 TYPE Mensch = Lebewesen mit intelligenzquotient
 
 VARIABLE     otto: Mensch
 VARIABLE eukaryot: Lebewesen
 
 otto.alter               ← 50
 otto.gewicht             ← 75
 otto.intelligenzquotient ← 100
 
 eukaryot ← otto

Die Zuweisung in der letzten Zeile ist korrekt, das Attribut „intelligenzquotient“ der Variable „otto“ vom Datentyp „Mensch“ wird jedoch nicht an die Variable „eukaryot“ zugewiesen, da es beim Datentyp „Lebewesen“ der Basisklasse nicht deklariert ist.

==Komplexe Ausdrücke==
Zusammengesetzte Ausdrücke mit verschiedenartigen Operatoren können sehr unübersichtlich und somit fehleranfällig sein. Manche Programmiersprachen haben sehr viele Hierarchieebenen für Operatoren, die auch durch erfahrene Programmierer kaum durchschaut werden können, oder sogar dafür sorgen, dass bestimmte Teile des Quellcodes zur Laufzeit gar nicht erreicht werden können. Daher ist es dringend empfehlenswert, Anweisungen in kleine, überschaubare Einheiten zu untergliedern. In einigen Programmiersprachen ist es sogar möglich, die Zuweisung in andere Anweisungen zu integrieren, da sie selber als ein Ergebniswert interpretiert werden darf. Ferner ist nicht immer offensichtlich welchen Datentyp ein Ergebnis hat, was insbesondere in Ermangelung eines zweiwertigen Datentyps ''Boolean'' zu Missverständnissen führen kann.

Also zum Beispiel nicht:

 if (a ← b – c = 0) ...

In dieser bedingten Anweisung (if) ist nicht klar, in welcher Reihenfolge der Zuweisungsoperator (←), der Differenzoperator (-) und der Vergleichsoperator (=) ausgeführt werden (sollen). 

Es ist erheblich besser, die Anweisungen klar zu trennen:

 a ← (b – c)
 if (a = 0) ...

Die folgenden beiden Beispiele mit dem Zuweisungsoperator &quot;=&quot; und dem Vergleichsoperator &quot;==&quot; zeigen Programmsequenzen in der Programmiersprache C, die zu sehr leicht zu übersehenden Programmierfehlern führen können:

&lt;syntaxhighlight lang=&quot;C&quot;&gt;
 /* Programmiersprache C */
 int i = 0;
 if (i = 1)
 {
    /*
       Dieser Block wird immer ausgeführt,
       weil die Zuweisung i = 1 immer das numerische Ergebnis 1 hat,
       was als der boolesche Wert &quot;wahr&quot; interpretiert wird.
    */
 }
 
 int i = 0;
 if (i == 1)
 {
    /*
       Dieser Block wird nie ausgeführt,
       weil die Vergleichsoperation i == 1 immer das numerische Ergebnis 0 hat,
       was als der boolesche Wert &quot;falsch&quot; interpretiert wird.
    */
 }
&lt;/syntaxhighlight&gt;

Die folgende Rückgabe-Anweisung (&quot;return&quot;) in der Programmiersprache Java ist nicht nur verwirrend, sondern sinnfrei:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 2;
 long y = 1;
 return y + x--;
&lt;/syntaxhighlight&gt;

Der Dekrement-Operator &quot;- -&quot; wird in vielen Programmiersprachen gar nicht ausgeführt, weil er hierarchisch erst nach einer Zuweisung ausgeführt wird oder nach einer die Code-Sequenz beendende Return-Anweisung noch ausgeführt werden müsste, aber de facto gar nicht mehr ausgeführt wird. Deswegen ist die folgende Anweisungsfolge nicht nur weniger komplex, gut strukturiert und korrekt, sondern auch sinnvoll und leicht sowie eindeutig nachvollziehbar:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 2;
 long y = 1;
 x--;
 long summe = y + x;
 return summe;
&lt;/syntaxhighlight&gt;

Beeindruckend sinnlos, verwirrend und komplex sind Monster-Ausdrücke (nach Niklaus Wirth: ''notational monsters''), die in einigen Programmiersprachen wie zum Beispiel C erlaubt sind, wie zum Beispiel bei der Kombination einer Rücksprunganweisung (&quot;return&quot;) mit einer Zuweisung (&quot;=&quot;), zwei verschiedenen Inkrement-Operatoren (&quot;++&quot;) und einem Additionsoperator (&quot;+&quot;). Es ist sehr schwierig durchschaubar, in welcher Reihenfolge diese fünf Anweisungen ausgeführt werden und ob diese überhaupt ausgeführt werden. Selbst wenn die Zuweisung oder die nachrangige Inkrementierung ausgeführt würden, wären sie völlig sinnlos, da auf die lokale Variable i nach der Return-Anweisung gar nicht mehr zugegriffen werden kann:

&lt;syntaxhighlight lang=&quot;C&quot;&gt;
/* Programmiersprache C */
int i = 0;
return i = ++i+i++;
&lt;/syntaxhighlight&gt;

Auch im folgenden Java-Beispiel ist die Sachlage nicht wesentlich besser. Das Ergebnis dieser Anweisungsfolge für die Variable y ergibt den Wert 2 + 2 = 4 , weil der letzte Inkrementoperator die Variable x vor der Ausführung aller anderen Operatoren auf den Wert 2 erhöht, und der erste Inkrementoperator die Variable x erst nach der Addition und der Zuweisung auf den Wert 3 erhöht:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 1;
 long y = x++ + ++x;
&lt;/syntaxhighlight&gt;

Es ist ebenfalls nicht leicht zu durchschauen, dass das Ergebnis dieser Anweisungsfolge in Java für die Variable y den Wert 2 + 3 = 5 ergibt, weil die Variable x vor der Auswertung des arithmetischen Summe zweimal inkrementiert wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 1;
 long y = ++x + ++x;
&lt;/syntaxhighlight&gt;

Ferner ist das Ergebnis der nächsten Anweisungsfolge in Java für die Variable y der Wert 2 + 2 = 4, weil die Variable x vor der Auswertung der arithmetischen Summe nur beim ersten Inkrementoperator für die Summenbildung wirksam verändert wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 1;
 long y = ++x + x++;
&lt;/syntaxhighlight&gt;

Auf der anderen Seite ist das Ergebnis der nächsten Anweisungsfolge in Java für die Variable y der Wert 1 + 2 = 3, weil die Variable x während der Auswertung des arithmetischen Ausdrucks nur beim ersten Inkrementoperator für die Summenbildung wirksam verändert wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long x = 1;
 long y = x++ + x++;
&lt;/syntaxhighlight&gt;

Noch gefährlicher wird es, wenn die Reihenfolge der Auswertung von arithmetischen Ausdrücken mit gleichwertigen Operanden für den Compiler oder Interpreter nicht definiert ist:

&lt;syntaxhighlight lang=&quot;C&quot;&gt;
/* Programmiersprache C */
 int x = 1;
 long y = ++x * --x;
&lt;/syntaxhighlight&gt;

Wird die Multiplikation von links nach rechts ausgewertet, ergibt sich für die Variable y der Wert 2, wird die Multiplikation von rechts nach links ausgewertet, ergibt sich für die Variable y der Wert 0. Derselbe Quelltext kann auf zwei verschiedenen Systemen also völlig andere Rechenergebnisse hervorrufen.

In anderen Programmiersprachen werden die Inkremente und Dekremente von ganzzahligen Variablen daher mit Prozeduraufrufen bewerkstelligt (beispielsweise INC() und DEC()), die fester Bestandteil der Programmiersprache sind, wie zum Beispiel in Pascal, wo der Zuweisungsoperator aus zwei verschiedenen Zeichen besteht (&quot;:=&quot;), damit es keine Verwechslungen mit einem Identitätsoperator oder Vergleichsoperator geben kann:

&lt;syntaxhighlight lang=&quot;pascal&quot;&gt;
(* Programmiersprache Pascal *)
 VAR
    x, y, produkt: integer;
 BEGIN
    x := 1;
    INC (x);
    y := x;
    DEC (x);
    produkt := y * x;
 END;
&lt;/syntaxhighlight&gt;

Die Aufrufe der Inkrement- beziehungsweise Dekrementprozeduren dürfen und können –&amp;nbsp; genauso wie Zuweisungen&amp;nbsp;– in der Programmiersprache Pascal also gar nicht Bestandteil eines arithmetischen Ausdrucks sein, so dass der Zeitpunkt der Ausführung immer eindeutig aus der Reihenfolge der Anweisungen hervorgeht.

===Ternäre Operatoren===
Ein '''ternärer Operator''' hat als Ergebnis einen beliebigen Wert und verknüpft hierzu drei Ausdrücke:

* Der erste Ausdruck ein '''binärer Ausdruck''', der wahr oder falsch ist.
* Der zweite Ausdruck beschreibt den Ergebniswert, wenn der erste Ausdruck '''wahr''' ist.
* Der dritte Ausdruck beschreibt den Ergebniswert, wenn der erste Ausdruck '''falsch''' ist.

In vielen Programmiersprachen werden die drei Ausdrücke mit den Begrenzungszeichen ? und : voneinander getrennt, und der binäre Ausdruck wird eingebettet in runde Klammern vorangestellt:

 (binärer Ausdruck) ? zweiter Ausdruck : dritter Ausdruck

Jeder dieser drei Ausdrücke kann sich wiederum aus mehreren anderen Ausdrücken zusammensetzen, so dass der Überblick schnell verloren gehen kann.

Die Ergebniswerte von Ausdrücken mit ternären Operatoren sollten besser nicht in andere Ausdrücke eingesetzt werden, sondern in einer lokalen Variable zwischengespeichert und erst danach weiterverwendet werden:

 variable ergebnis;
 ergebnis ← (binärer Ausdruck) ? zweiter Ausdruck : dritter Ausdruck

Grundsätzlich ist es wegen der größeren Übersichtlichkeit, Transparenz und einfacheren Modifikation vorzuziehen, für das Ergebnis gar '''keine ternären Operatoren''' zu verwenden, sondern eine '''bedingte Anweisung mit Blockanweisungen''' zu verwenden:

 variable ergebnis;
 falls (binärer Ausdruck)
 dann
    Block für ergebnis ← zweiter Ausdruck
 ansonsten
    Block für ergebnis ← dritter Ausdruck
 ende

===Blockanweisungen===
'''Blockanweisungen''' sind ein elegantes Mittel, um Programmcode zu strukturieren sowie die Sichtbarkeit von lokalen Variablen zu begrenzen. In vielen Programmiersprachen werden eindeutige Symbole für die Kennzeichnung von Programmblöcken verwendet, wie zum Beispiel geschweifte Klammern:

 {
    ...
 }

Die drei Punkte stehen hierbei für beliebige Anweisungsfolgen.

In anderen Programmiersprachen werden Schlüsselwörter für die Begrenzung von Blockanweisungen verwendet, wie zum Beispiel &quot;BEGIN&quot; und &quot;END&quot;:

 BEGIN
    ...
 END

Der Blockinhalt mit Anweisungen -&amp;nbsp;in beiden obenstehenden Beispielen durch die drei aufeinanderfolgenden Punkte symbolisiert&amp;nbsp;-, wird in der Regel eingerückt, um die Lesbarkeit des Quelltextes für die Programmierer zu erleichtern.

Blockanweisungen können geschachtelt, dürfen -&amp;nbsp;sofern in der Syntax einer Programmiersprache überhaupt möglich&amp;nbsp;- jedoch nicht verschränkt werden. Dies bedeutet, dass bei geschachtelten Blöcken ein begonnener Block immer erst vollständig abgearbeitet werden muss, bevor der nächstäußere weitergeführt und abgeschlossen werden kann:

 {
    ... /* Äußerer Block */
    {
       ... /* Mittlerer Block */
       {
          ... /* Innerer Block */
       }
       ... /* Mittlerer Block */
    }
    ... /* Äußerer Block */
 }

Verschränkte Blockanweisungen sind unsinnig, unstrukturiert sowie überflüssig und daher in den meisten Programmiersprachen nicht zulässig:

 BEGIN1
    ...
    BEGIN2
       ...
    ...
 END1
 ...   ...
    END2

Die Implementationen von allen Modulen, Klassen und Unterprogrammen sowie auch von allen Kontrollstrukturen (also Fallunterscheidungen und Schleifen) sollten '''kategorisch mit Blockanweisungen''' strukturiert werden.

=== Blockanweisungen bei Kontrollstrukturen ===
[[Datei:lineareAnw.png|mini|rechts|hochkant=2|Struktogramm einer Anweisungsfolge.]]

Auch wenn die Programmiersprache die Verwendung von Blockanweisungen für Anweisungsfolgen in einer Kontrollstruktur nicht vorschreibt, ist es sehr ratsam, die Blockanweisung kategorisch einzusetzen, um Programmierfehler zu vermeiden. Wenn zum Beispiel eine if-Anweisung so wie in den Programmiersprachen C und Java so strukturiert ist, dass genau eine Folgeanweisung ausgeführt wird, wenn die Bedingung wahr ist, kann es ohne Blockanweisungen bei der Programmentwicklung oder -wartung leicht zu übersehenden Programmierfehlern kommen. Im folgenden korrekt formulierten Java-Programmbeispiel wird die Variable v1 auf den Wert null zurückgesetzt, falls sie den gleichen Zahlenwert wie max hat:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
    v1 = 0;
&lt;/syntaxhighlight&gt;

Soll zudem auch noch eine Textausgabe erfolgen, kann diese zusätzlich programmiert werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
    v1 = 0;
    java.lang.System.out.println (&quot;Der Maximalwert wurde erreicht.&quot;);
&lt;/syntaxhighlight&gt;

Die unterste Programmierzeile ist zwar eingerückt, was suggeriert, dass sie nur ausgeführt wird, wenn die darüberstehende Bedingung erfüllt ist. Ein Java-Interpreter führt jedoch nur eine einzige unmittelbar nach der Bedingung aufgeführte Anweisung aus, wenn die Bedingung wahr ist. Mit anderen Worten: die Textausgabe erfolgt im obigen Programmbeispiel immer, also insbesondere auch wenn die Variablen v1 und max nicht den gleichen Zahlenwert haben. Im Quelltext sollte das daher besser folgendermaßen formuliert werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
    v1 = 0;
 java.lang.System.out.println (&quot;Der Maximalwert wurde erreicht.&quot;);
&lt;/syntaxhighlight&gt;

Ähnlich tückisch ist die Tatsache, dass in manchen weniger streng strukturierten Programmiersprachen, auf die Bedingung der if-Anweisung eine beliebige Anweisung folgen darf, die nicht notwendigerweise eine Blockanweisung sein muss, sondern auch eine einzelne Anweisung sein darf, die zum Beispiel mit einem Semikolon abgeschlossen wird und auch eine '''leere Anweisung''' sein kann. Dies führt zu leicht zu übersehenden Programmierfehlern, wie im folgenden Beispiel:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max);
 {
    v1 = 0;
    java.lang.System.out.println (&quot;Der Maximalwert wurde erreicht.&quot;);
 }
&lt;/syntaxhighlight&gt;

Die Blockanweisung wird immer ausgeführt, obwohl ihre Darstellung mit korrekter Einrückung suggeriert, dass sie nur dann ausgeführt wird, wenn die boolesche Bedingung (v1 == max) erfüllt ist. Dies ist allerdings nicht der Fall, da direkt hinter den runden Klammern der if-Anweisung ein Semikolon steht, welches eine '''leere Anweisung''' implementiert, die bei der Erfüllung der Bedingung ausgeführt wird.

All diese Missverständnisse können leicht vermieden werden, indem bei der Programmierung von Kontrollstrukturen '''kategorisch Blockanweisungen''' verwendet werden, selbst wenn die Programmiersprache dies nicht fordert:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
 {
    v1 = 0;
 }
&lt;/syntaxhighlight&gt;

Beziehungsweise:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 if (v1 == max)
 {
    v1 = 0;
    java.lang.System.out.println (&quot;Der Maximalwert wurde erreicht.&quot;);
 }
 else
 {
    java.lang.System.out.println (&quot;Der Maximalwert wurde nicht erreicht.&quot;);
 }
&lt;/syntaxhighlight&gt;

==== Verschachtelung ====
In noch stärkerem Maße leidet die Verständlichkeit von Quellcode, wenn mehrere Kontrollstrukturen ohne die Verwendung von Blockstrukturen verschachtelt werden:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long v1, v2, v3;
 v1 = 3;
 v2 = 3;
 v3 = 7;
 if ((v1 &gt; 0) &amp;&amp; (v2 &gt; 0))
    if (v1 &gt; v2)
       v3 = v1 - v2;
 else
    v3 = v2 - v1;
 java.lang.System.out.println (&quot;v3 = &quot; + v3);
&lt;/syntaxhighlight&gt;

Beim Lesen des Quellcodes mit einer solchen &quot;baumelnden&quot; ''else''-Anweisung (englisch: ''dangling else'') kann schnell der Eindruck entstehen, dass sie zur ersten ''if''-Anweisung gehört und das Ergebnis für die Variable ''v3'' 7 bleibt, da ''v1'' und ''v2'' positive Zahlen sind. Tatsächlich wird der Quellcode jedoch so ausgeführt, so dass die Variable ''v3'' den Wert 0 erhält.

Um solche Missverständnisse zu vermeiden, ist es -&amp;nbsp;wie oben bereits erwähnt&amp;nbsp;- dringend geboten, Blockanweisungen kategorisch einzusetzen, auch wenn sie durch die Definition der Programmiersprache nicht sowieso vorgeschrieben sind:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long v1, v2, v3;
 v1 = 3;
 v2 = 3;
 v3 = 7;
 if ((v1 &gt; 0) &amp;&amp; (v2 &gt; 0))
 {
    if (v1 &gt; v2)
    {
       v3 = v1 - v2;
    }
    else
    {
       v3 = v2 - v1;
    }
 }
 java.lang.System.out.println (&quot;v3 = &quot; + v3);
&lt;/syntaxhighlight&gt;

==Wertebereiche==
===Division durch null===
Im Zusammenhang mit dem '''Divisionsoperator''' gibt es in allen Programmiersprachen das Problem, dass der Divisor nicht null werden darf.

Die Division durch null kann und sollte kategorisch durch eine geeignete Kontrollstruktur mit dem Vergleichsoperator &quot;&lt;&gt;&quot; verhindert werden, der nur bei Ungleichheit der beiden Operanden den Ergebniswert &quot;wahr&quot; erzeugt:

 if (divisor &lt;&gt; 0)
 {
    quotient ← dividend / divisor
 }
 else
 {
    /* Ausnahmebehandlung / Fehlermeldung */
 }

===Wertebereichsprüfung===
Bei Parametern mit eingeschränktem zulässigen Wertebereich kann eine allgemeine und an allen entsprechenden Stellen verwendbare Funktion programmiert werden, die den gültigen Wertebereich überprüft und einen entsprechenden (häufig zweiwertigen respektive booleschen) Funktionswert zurückgibt, wie zum Beispiel die folgende Funktion &quot;waterIsLiquid &quot;, die überprüft, ob die Wassertemperatur zwischen 0° und 100° Celsius liegt, bevor das spezifische Gewicht des Wassers berechnet werden darf:

 boolean waterIsLiquid (double temperature) /* temperature in degrees Celsius */
 {
    final long freezingPoint ← 0;
    final long boilingPoint  ← 100;
    boolean waterIsLiquid ← (temperature &gt; freezingPoint) and (temperature &lt; boilingPoint);
    return waterIsLiquid;
 }
 
 ...
 
 double temperature, density;
 
 ...
 
 if waterIsLiquid (temperature)
 {
    /* function computes an approximation of the density of air-free liquid water in kilograms per cubic metre */
    density ←
       (    999.83952
          + (16.945176 * temperature)
          - (0.0079870401 * temperature * temperature)
          - (0.000046170461 * temperature * temperature * temperature)
          + (0.00000010556302 * temperature * temperature * temperature * temperature)
          - (0.00000000028054253 * temperature * temperature * temperature * temperature * temperature)
       ) / ((0.01689785 * temperature) + 1);
 }
 else
 {
    /* exception handling, because water is not liquid */
 }

===Parameterkombinationen===
Es ist wichtig, dass immer alle auftretenden Parameterkombinationen berücksichtigt und vom Programmcode verarbeitet werden, wenn aus diesen Parametern valide berechnete Werte abgeleitet werden sollen.

Um zum Beispiel das Argument (also den Phasenwinkel zwischen -180° und +180°) einer komplexwertigen Zahl mit den reellwertigen Komponenten x und y über den Arcustangens (&quot;arctan&quot;) zu berechnen, muss geprüft werden, ob der Parameter x gleich null ist, und welche Vorzeichen die Parameter x und y haben:

 double x
 double y
 
 ...
 
 double argument
 
 if (x = 0)
 {
    if (y &gt; 0)
    {
       argument ← 90
    }
    elseif (y &lt; 0)
    {
       argument ← -90
    }
    else /* y is equal to 0, too */
    {
       stop /* argument is not defined */
    }
 }
 else /* x is not equal to 0 */
 {
    argument ← arctan (y / x)
    if (x &lt; 0)
    {
       if (y &gt;= 0)
       {
          argument ← argument + 180
       }
       else /* both, x and y are less than 0 */
       {
          argument ← argument - 180
       }
    }
 }

==Schnittstellen==
Schnittstellen definieren die Sichtbarkeits- und Zugriffsregeln zwischen verschiedenen Bestandteilen eines Programms und ermöglichen so die Interaktion zwischen diesen. Dabei ist es keineswegs sinnvoll, alle Bezeichner überall sichtbar zu machen, da dadurch die Übersichtlichkeit und Nachvollziehbarkeit insgesamt drastisch eingeschränkt wird. Dies führt letztlich zu Programmfehlern, da der Programmierer wegen der großen zu berücksichtigenden Datenmenge nicht mehr in der Lage ist, alle Implikationen seiner Arbeit zu überschauen.

Alle Eigenschaften (Attribute) und Methoden (Werkzeuge), die zusammengehören (aber auch nur diese), sollen in jeweils einer Einheit zusammengefasst werden, wie zum Beispiel einer Klasse oder einem Modul. Oft wird eine solche Einheit in einer Quelltextdatei zusammengefasst, was sinnvoll ist und die Nachvollziehbarkeit erleichtert.

Nur diejenigen Eigenschaften und Methoden, die außerhalb dieser Einheiten benutzt werden sollen oder müssen, dürfen mit einem Modifikator versehen werden, der dies ermöglicht (zum Beispiel &quot;public&quot;). Alle anderen Eigenschaften und Methoden sollten explizit als intern (zum Beispiel &quot;private&quot;) deklariert sein. ''packages'' sind wegen der unübersichtlichen Sichtbarkeitsregeln (zum Beispiel durch den Modifikator &quot;protected&quot;) als Zwischenebene entbehrlich und eher zu vermeiden. Alternativ können ohne weiteres längere, zusammengesetzte Klassennamen verwendet werden, um die Zugehörigkeit zu einem bestimmten Themenbereich zu kennzeichnen, wie zum Beispiel mit einfachen Bezeichnern:

 StatisticsMyEvaluation
 StatisticsMyAssessment

Diese Bezeichner sind in der Regel unmittelbar mit den Programmdateien im Dateisystem korreliert. Hierbei sind also keine '''qualifizierten Bezeichner''' auf verschiedene Konstrukte erforderlich, die hier im Beispiel aus mehreren Bezeichnern mit zwischengestellten Punkten zusammengesetzt sind. Links vom Punkt steht der Bezeichner der Programmbibliothek (Modulsammlung, Paket), und rechts vom Punkt steht der Bezeichner für ein Programmbaustein (Modul, Klasse):

 package statistics
 
 statistics.MyEvaluation
 statistics.MyAssessment

===Importe===
====Import-Anweisungen====
'''Import-Anweisungen''' werden häufig nicht dazu benutzt anzumelden und anzuzeigen, welche externen Module (respektive Klassen) in einer Quelldatei verwendet werden, sondern werden als Möglichkeit missbraucht, den Quelltext möglichst kurz zu fassen.

Nicht:

 import MyModule
 ...
 drawLine ()
 ...

Sondern eindeutig mit qualifiziertem Bezeichner:

 ...
 MyModule.drawLine ()
 ...

Mit diesen qualifizierten Bezeichnern ist es dann auch einfach und eindeutig möglich, gleichnamige Bezeichner, wie zum Beispiel für die Methode ''drawLine'', aus verschiedenen Klassen zu benutzen:

 ...
 MyModule.drawLine ()
 YourModule.drawLine ()
 ...

Die Erkennbarkeit der Herkunft eines importierten Bezeichners an jeder Stelle des Auftretens in einem Quelltext ist in der Regel von großer Nützlichkeit, insbesondere wenn andere Programmierer den Quelltext nachvollziehen können sollen oder wenn der Quellcode nach längerer Zeit gewartet werden soll.

Insbesondere Import-Anweisungen mit Wildcards sind schlecht nachvollziehbar (auch wenn viele Entwicklungssysteme Funktionen für eine gewisse Transparenz bieten), so wie zum Beispiel:

 import myPackage.*
 import yourPackage.*
 
 drawLine () /* To which package does the method &quot;drawLine&quot; belong? */
 
 Class var ← new Class () /* To which package does the class &quot;Class&quot; belong? */

====Zyklische Importe====
[[Datei:Zyklischer.Import.png|mini|rechts|hochkant=2|Zyklische Importe durch Aufruf (&quot;call&quot;) des Unterprogramms (&quot;procedure&quot;) '''sum''' aus der Klasse '''B''' in das Unterprogramm '''add''' der Klasse A sowie Aufruf des Unterprogramms '''add''' aus der Klasse '''A''' in das Unterprogramm '''sum''' der Klasse '''B'''.]] 

'''Zyklische Importe''' beziehungsweise Zirkelbezüge sind nicht nur unübersichtlich, sondern auch unstrukturiert und können zu Speicherüberläufen führen, da sich Programmteile immer wieder gegenseitig aufrufen, ohne beendet zu werden. Ferner kann die Funktion des übersetzten Programms bei einer Optimierung des Codes von der Reihenfolge der Übersetzung der Quelltexte abhängen. Die Schnittstellen der Klassen und Module können im Allgemeinen weder unabhängig voneinander noch eindeutig überprüft werden.

'''Beispiel''': Die beiden Funktionen Funktionen ''add'' aus der Klasse ''A'' und ''sum'' aus der Klasse ''B'' rufen sich endlos gegenseitig auf, um die Summe zweier Zahlenwerte zu berechnen, bis der Speicher überlaufen würde und das Laufzeitsystem die Ausführung deswegen abbricht oder der Speicher überläuft, das Programm unkontrolliert und ohne (nachvollziehbare) Fehlermeldung abstürzt.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

 public class A
 {
    public int procedure add (int a, int b)
    {
       int result ← B.sum (a, b);
       return result;
    }
 }

 public class B
 {
    public int procedure sum (int x, int y)
    {
       int result ← A.add (x, y);
       return result;
    }
 }

[[Datei:Circular Reference.svg|mini|rechts|hochkant=1|Variante von Abhängigkeiten zwischen Modulen oder Klassen, in denen die zyklischen Bezüge weniger offensichtlich sind, wenn nur der nächste Nachbar betrachtet wird. Der dunkelrote Pfeil oben rechts zeigt nach unten auf ein bereits vorher definiertes Element, das sich rechts in der Mitte befindet. Die Definition dieses Elements darf bei einem strukturierten Aufbau der Programmteile allerdings nicht von dem Element ober rechts abhängig sein.]]

Solche zyklischen Abhängigkeiten können durch Verzweigungen und indirekte Aufrufe wesentlich weniger offensichtlich sein, und sind dann nur sehr schwierig zu erkennen und zu beheben. Sichere Programmiersprachen überprüfen solche zyklischen Zusammenhänge daher und lassen sie nicht zu.

In der Regel ist es bei der Anwendung von rekursiven Programmiertechniken mit wohldefinierten Abbruchbedingungen möglich, ohne zyklische Modulabhängigkeiten auszukommen. Ein Übersetzer kann in den Metadaten von Programm-Modulen Zeitstempel verwenden, um bei der Interpretation eines Programmteils herausfinden zu können, ob alle anderen importierten Programmteile bereits vorher gültig übersetzt wurden.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Nebeneffekte==
'''Nebeneffekte''' treten auf, wenn der Programmierer von naheliegenden, jedoch falschen Annahmen ausgeht, die die Programmiersprache betreffen. Solche Nebeneffekte sind unerwünscht und können durch ein strukturiertes Vorgehen oft leicht vermieden werden.

===Durch arithmetischen Überlauf===
Als Indiz für solche Nebeneffekte möge folgendes Beispiel in Java dienen, bei dem die Dezimalzahl 127 (die hexadezimale Repräsentation dieses Zahlenwerts ist durch die acht Ziffern 7F gegeben) um eins erhöht wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 byte zahl = 127;
 java.lang.System.out.println (&quot;zahl = &quot; + zahl);
 zahl++;
 java.lang.System.out.println (&quot;zahl = &quot; + zahl);
&lt;/syntaxhighlight&gt;

Diese Anweisungsfolge erzeugt die Ausgabe:

:zahl = 127
:zahl = -128

Wenn die größte mit dem Datentyp &quot;byte&quot; darstellbare Zahl 127 mit dem Inkrement-Operator ++ um eins erhöht wird, ergibt sich durch arithmetischen Überlauf als Ergebnis die kleinste darstellbare ganze Zahl 128.

Dass solche Nebeneffekte auch in Standard-Bibliotheken versteckt sein können, möge das folgende Beispiel in Java zeigen, bei dem die Dezimalzahl -1 (die hexadezimale Repräsentation dieses Zahlenwerts ist durch die acht Ziffern FFFFFFFF gegeben) mit zwei verschiedenen Unterprogrammen ausgegeben werden soll (Stand 2026):

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 long zahl = 0xFFFFFFFF;
 java.lang.System.out.println (&quot;dezimal: &quot; + zahl);
 java.lang.System.out.print (&quot;hexadezimal: &quot;);
 java.lang.System.out.printf (&quot;%h\n&quot;, zahl);
&lt;/syntaxhighlight&gt;

Diese Anweisungsfolge erzeugt die Ausgabe:

:dezimal: -1
:hexadezimal: 0

Die Methode &quot;printf&quot; für die Ausgabe im hexadezimalen Format (Steuersequenz h%), ruft die statische Methode &quot;formatUnsignedLong0&quot; aus der Klasse &quot;Long&quot; aus dem package &quot;java.lang&quot; im Modul &quot;java.base&quot; der Java-Standardbibliothek auf und gibt den Wert 0 aus, obwohl der korrekte hexadezimale Wert FFFFFFFF lautet. Der Fehler entsteht bei der internen Berechnung, bei der es einen arithmetischen Überlauf gibt, der nicht explizit abgefangen wird.

===Durch Rundung===
Manchmal ist es schwierig zu erkennen, dass das Ergebnis einer Operation nicht dem exakten Ergebnis entspricht, das mathematisch zu erwarten wäre, weil es Rundungsfehler gibt. Gleitkommazahlen können nicht mit beliebig hoher Präzision gespeichert werden, und daher können sich dadurch solche Rundungsfehler auch mit einer völlig unerwarteten Wirkung ergeben. Hier ein Beispiel in der Programmiersprache Java für ein System mit einer Speichertiefe von 64 Bit:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 double a = 4.4;
 double b = 3.3;
 java.lang.System.out.println (a - b);
&lt;/syntaxhighlight&gt;

Die Ausgabe lautet nicht &quot;1.1&quot; wie zu erwarten wäre, sondern:

:1.1000000000000005

Noch schwieriger ist es, wenn das Kommutativ-, das Distributiv- oder das Assoziativgesetz nicht zu gelten scheinen, wie in diesem Beispiel, bei dem die Variable &quot;b&quot; einmal zur Variable &quot;a&quot; und einmal zur Variable &quot;c&quot; assoziiert ist:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 double a = 4.4;
 double b = 3.3;
 double c = 1.1;
 java.lang.System.out.println ((a - b) - c);
 java.lang.System.out.println (a - (b + c));
&lt;/syntaxhighlight&gt;

Mathematisch kommt in beiden Fällen exakt der Wert null heraus, die Ausgabe lautet jedoch:

:4.440892098500626E-16
:0.0

Die Wirkung von derartigen Nebeneffekten sind nur sehr schwierig zu beherrschen, und daher sollte beim Vergleichen von Gleitkommawerten die Präzision respektive die Maschinengenauigkeit der gespeicherten Werte berücksichtigt werden. Manche Programmiersprachen stellen hierfür einen Wert für die kleineste relative Genauigkeit von Gleitkommazahlen &lt;math&gt;\epsilon&lt;/math&gt; (epsilon) zur Verfügung. Das folgende Beispiel für den Datentyp double mit 64 Bit Speichertiefe nach dem Standard IEEE 754 in der Programmiersprache Java mit einem Wert für &lt;math&gt;\epsilon = 10^{-15}&lt;/math&gt; nach der Formel:

:&lt;math&gt;\Bigg| {\frac {differenzBerechnet - differenzErwartet} {differenzErwartet}} \Bigg| &lt; \epsilon&lt;/math&gt;

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
 double a = 4.4;
 double b = 3.3;
 double differenzBerechnet = a - b;
 double differenzErwartet = 1.1;

 boolean gleichheit1 = (differenzBerechnet == differenzErwartet);
 java.lang.System.out.println (gleichheit1);

 double epsilon = 1.0E-15;
 boolean gleichheit2 = java.lang.Math.abs ((differenzBerechnet - differenzErwartet) / differenzErwartet) &lt; epsilon;
 java.lang.System.out.println (gleichheit2);
&lt;/syntaxhighlight&gt;

Die Ausgabe lautet hier:

:false
:true

===Durch Reihenfolge===
In einigen Programmiersprachen ist die Reihenfolge der Abarbeitung von kombinierten Ausdrücken nicht explizit definiert und führt daher zu einem solchen Nebeneffekt.

Die Anweisungen

 h ← f (x) + g (x)

oder

 h ← g (x) + f (x)

können je nach Compiler zu unterschiedlichen Ergebnissen für die Summe h führen. Die Methodenaufrufe f oder g können nämlich unter Umständen die als Parameter verwendete (lokale) Variable x verändern und somit gegebenenfalls verschiedene Werte für h erzeugen, je nachdem, ob zuerst f&amp;nbsp;(x) oder g&amp;nbsp;(x) ausgewertet wird. In solchen Programmiersprachen sind sogenannte Durchgangsparameter in kombinierten Ausdrücken zu vermeiden.

Ferner ist es denkbar, dass durch den ersten Funktionsaufruf globale Variablen oder Instanzen verändert und beim zweiten Funktionsaufruf verwendet werden.

Die erwünschte Reihenfolge von Funktionsaufrufen kann leicht durch entsprechende Code-Sequenzen mit sequentiellen Anweisungen erzwungen werden:

 result_f ← f (x)
 result_g ← g (x)
 h ← result_f + result_g

Dieses Vorgehen erzeugt darüberhinaus den günstigen Umstand, dass die Zwischenergebnisse in lokalen Variablen gespeichert und somit abgefragt werden können. Diese sind nach einem Programmabbruch dann auch mit einem Post-Mortem-Debugger analysierbar.

===Durch Kombination von Operatoren===
Manche Programmiersprachen -&amp;nbsp;insbesondere in der C-Sprachfamilie&amp;nbsp;- erlauben die Kombination von Zuweisungsoperatoren und arithmetischen Operatoren.

 Zuweisungsoperator: =
 Arithmetische Operatoren: + - * /
 Kombinierte Operatoren: += -= *= /=

Die kombinierten Operatoren sollen für die scheinbar äquivalenten Formulierungen mit getrenntem Zuweisungsoperator und arithmetischem Operator stehen:

 a += 1; steht für a = a + 1;
 a -= 1; steht für a = a - 1;
 a *= 1; steht für a = a * 1;
 a /= 1; steht für a = a / 1;

Diese Schreibweisen sollen wohl vor allem ein wenig Schreibarbeit bei der Programmierung ersparen, können aber zu schwer zu identifizierenden Programmierfehlern führen, wie das folgende Java-Beispiel verdeutlichen soll:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
	long a = 1;
	double b = 1.5;
	a *= b;
	java.lang.System.out.println (a);
	a += b;
	java.lang.System.out.println (a);
	a -= b;
	java.lang.System.out.println (a);
&lt;/syntaxhighlight&gt;

Dieser Code erzeugt die Ausgabe:

 1
 2
 0

Die nur scheinbar äquivalenten Formulierungen für die kombinierten Operatoren

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
	a = a * b;
	a = a + b;
	a = a - b;
&lt;/syntaxhighlight&gt;

werden in Java wegen der mangelnden Zuweisungskompatibilität der arithmetischen Ausdrücke hinter dem Zuweisungsoperator vom Datentyp &quot;double&quot; zum Datentyp &quot;long&quot; der Variable &quot;a&quot; gar nicht übersetzt.

Die tatsächlichen äquivalenten Formulierungen für die kombinierten Operatoren lauten nämlich wie folgt:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
	a = (long) (a * b);
	a = (long) (a + b);
	a = (long) (a - b);
&lt;/syntaxhighlight&gt;

Durch die impliziten Datentypumwandlungen erklären sich auch die falschen numerischen und gegebenenfalls nicht erwarteten ganzzahligen Ergebnisse. Wenn bei der Programmierung diese Tatsachen nicht bewusst sind oder übersehen werden, ergeben sich numerische Fehler in den arithmetischen Berechnungen. Dies kann einfach vermieden werden, indem kombinierte Operatoren zugunsten der expliziten sowie transparenten Formulierungen mit separaten Operatoren nicht verwendet werden.

=== Durch Sprachdefinition ===
Als Beispiel dient hier die scheinbar falsche Ausgabe eines Java-Programms, weil die Definition der Programmiersprache der Intuition widerspricht:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long i = 01234567;
 java.lang.System.out.println (i);
&lt;/syntaxhighlight&gt;

Dieser Code erzeugt die Ausgabe:

 342391

Das Literal &quot;01234567&quot; wird trotz der ausschließlichen Verwendung von gültigen dezimalen Ziffern nicht als die Dezimalzahl 1234567&lt;sub&gt;10&lt;/sub&gt; interpretiert und ausgegeben, sondern entsprechend der Definition der Programmiersprache Java wegen der einleitenden Null als Oktalzahl zur Basis Acht, also als 1234567&lt;sub&gt;8&lt;/sub&gt; = 342391&lt;sub&gt;10&lt;/sub&gt;.

=== Durch Überladen ===
Eine Überladung liegt vor, wenn eine Operator oder ein Bezeichner mehrfach in verschiedenen Bedeutungen auftritt, die leicht zu Verwechslungen führen können. Streng strukturierte Programmiersprachen erlauben das polymorphe Überladen nicht, wenn es dadurch zu Programmierfehlern kommen kann.

Das '''Überladen''' muss in der objektorientierten Programmierung vom '''Überschreiben''' unterschieden werden, wobei auch überschriebene Methoden in weniger strukturierten Programmiersprachen überladen werden dürfen, was ebenfalls zu unübersichtlichem Programmcode und schnell zu übersehenden Programmierfehlern führen kann. Siehe hierzu unten unter [[Strukturierte Programmierung#Überladung|Überladung]].

==== Überladung von Divisionsoperatoren ====
Die Divisionsoperatoren sind in vielen Programmiersprachen leider überladen, wenn nämlich formal keine Unterscheidung zwischen Division mit ganzen Zahlen (Datentyp zum Beispiel &quot;long&quot; oder &quot;int&quot;) und Gleitkommazahlen (Datentyp zum Beispiel &quot;real&quot; oder &quot;double&quot;) gemacht wird. In diesen Fällen muss der Divisionsoperator sehr aufmerksam verwendet werden:

 int i ← 2;
 int j ← 1;
 real k ← j / i; /* Ueberladener Divisionsoperator mit zwei ganzzahligen Operanden */

Verwendet die Programmiersprache im arithmetischen Ausdruck die ganzzahlige Division, hat dies zur Folge, dass die Variable k den Wert '''0''' erhält. Verwendet die Programmiersprache stattdessen die reelwertige Division, bekommt die Variable k den Wert 0,5 zugewiesen.

Einige Programmiersprachen unterscheiden daher sinnvollerweise explizit zwischen einem Operator für die ganzzahlige Division (&quot;div&quot; oder &quot;DIV&quot;) und einem Operator für die Gleitkommadivision (&quot;/&quot;).

&lt;syntaxhighlight lang=&quot;pascal&quot;&gt;
(* Programmiersprache Pascal *)
 i, j : integer;
 k : real;
 i := 2;
 j := 1;
 k := j / i; (* Gleitkommazahliger Divisionsoperator mit zwei ganzzahligen Operanden *)
&lt;/syntaxhighlight&gt;

In der letzten Anweisung wird der Variablen &quot;k&quot; der Zahlenwert der reellwertigen Division '''0,5''' zugewiesen.

&lt;syntaxhighlight lang=&quot;pascal&quot;&gt;
(* Programmiersprache Pascal *)
 i, j, k : integer;
 i := 2;
 j := 1;
 k := j div i; (* Ganzzahliger Divisionsoperator mit zwei ganzzahligen Operanden *)
&lt;/syntaxhighlight&gt;

In der letzten Anweisung wird der Variablen &quot;k&quot; der Zahlenwert der ganzzahligen Division '''0''' zugewiesen.

Bei Programmiersprachen, die die Unterscheidung der Divisionsoperatoren nicht unterstützen, ist die Verwendung der expliziten und zuweisungskompatiblen Datentypumwandlung (englisch: ''type cast'') nicht nur sinnvoll, sondern sogar zwingend erforderlich:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 long i = 2;
 long j = 1;
 double k = ((double) j) / ((double) i) /* Ueberladener Divisionsoperator mit zwei gleitkommazahligen Operanden */
&lt;/syntaxhighlight&gt;

In der Regel ist es für eine Gleitkommadivision hierbei ausreichend, wenn nur einer der beiden Operanden, also nur der Nenner (Dividend) oder der nur Zähler (Divisor) der Division, eine Gleitkommazahl darstellt.

Entsprechende Überlegungen gelten auch für alle '''Modulo-Operatoren''' (wie zum Beispiel &quot;%&quot;, &quot;mod&quot; oder &quot;MOD&quot;).

==== Überladung von Variablen ====
Oft ist es in einer Programmiersprache erlaubt, dieselben Bezeichner für Variablen mit verschiedenen Sichtbarkeitsbereichen zu verwenden. Dies kann sehr einfach zur Verwechslung dieser Variablen führen, wie im folgenden Java-Beispiel verdeutlicht wird, wo es sowohl eine globale Klassenvariable (Sichtbarkeit in der Klasse &quot;OverloadedVariables&quot;) als auch eine lokale Variable (Sichtbarkeit in der Methode &quot;main&quot;) mit dem Namen &quot;bezeichner&quot; gibt:&lt;syntaxhighlight lang=&quot;java&quot;&gt;
public class OverloadedVariables
{
	// globale Klassenvariable &quot;bezeichner&quot;
	private static long bezeichner = 1;

	// Hauptprogramm (Methode &quot;main&quot;)
	public static void main (java.lang.String [] argumente) 
	{
		// lokale Variable &quot;bezeichner&quot;
		long bezeichner = 2; 
		// Ausgabe der globalen Klassenvariable &quot;bezeichner&quot;
		java.lang.System.out.println (&quot;Wert der globalen Variable = &quot; + OverloadedVariables.bezeichner);
		// Ausgabe der lokalen Variable aus der Methode &quot;main&quot;
		java.lang.System.out.println (&quot;Wert der  lokalen Variable = &quot; + bezeichner);
	}
}
&lt;/syntaxhighlight&gt;Falls die Klassenvariable referenziert werden soll, muss sie in Java qualifiziert bezeichnet werden, indem der Name der Klasse vorangestellt wird.

==== Überladung von Methoden ====
Viele Programmiersprachen erlauben die Deklaration von mehreren Methoden mit gleichem Bezeichner, die sich in der Anzahl oder den Datentypen ihrer Parameter unterscheiden. Das folgende Java-Beispiel mit zwei Methoden demselben Namens, von denen die mit der passenden Datentyp des Parameters &quot;zahl&quot; aufgerufen wird, verdeutlicht dies:&lt;syntaxhighlight lang=&quot;java&quot;&gt;
	private static long kehrwert (long zahl)
	{
		long kehrwert = 1 / zahl;
		return kehrwert;
	}

	private static double kehrwert (double zahl)
	{
		double kehrwert = 1 / zahl;
		return kehrwert;
	}

	public static void main (java.lang.String [] argumente)
	{
		double kehrwert1 = kehrwert (2);
		double kehrwert2 = kehrwert (2.0);
		java.lang.System.out.println (&quot;Kehrwert 1 = &quot; + kehrwert1);
		java.lang.System.out.println (&quot;Kehrwert 2 = &quot; + kehrwert2);
	}
&lt;/syntaxhighlight&gt;Die Ausgabe ergibt zwei verschiedene Ergebnisse für den Kehrwert der Zahl Zwei:&lt;syntaxhighlight&gt;
Kehrwert 1 = 0.0
Kehrwert 2 = 0.5
&lt;/syntaxhighlight&gt;Durch die kategorische Verwendung verschiedener Bezeichner für verschiedene Methoden kann die Verwechslungsgefahr leicht und ohne Probleme verhindert werden, und die Erzeugung der beiden verschiedenen Ergebnisse wird transparent:&lt;syntaxhighlight lang=&quot;java&quot;&gt;private static long kehrwertLong (long zahl)
	{
		long kehrwert = 1 / zahl;
		return kehrwert;
	}

	private static double kehrwertDouble (double zahl)
	{
		double kehrwert = 1 / zahl;
		return kehrwert;
	}

	public static void main (java.lang.String [] argumente)
	{
		double kehrwert1 = kehrwertLong (2);
		double kehrwert2 = kehrwertDouble (2.0);
		java.lang.System.out.println (&quot;Kehrwert 1 = &quot; + kehrwert1);
		java.lang.System.out.println (&quot;Kehrwert 2 = &quot; + kehrwert2);
	}&lt;/syntaxhighlight&gt;

===Durch falsche Spezifikation===
In Programmiersprachen, die dynamische Variablen ausschließlich als Zeiger behandeln (wie zum Beispiel C oder C++), kann trotz exakter Übereinstimmung der referenzierten Datentypen bei einer Zuweisung des Ergebnisses einer Funktion ein Zeiger auf den lokalen Stapelspeicher der Funktion zurückgegeben werden, der nur während der Ausführung der Funktion, aber nicht mehr nach dem Rücksprung aus der Funktion gültig ist. Während der weiteren Programmausführung kann der Speicherbereich jederzeit überschrieben werden, ohne dass der Programmierer dies wünscht oder absehen kann.

Im folgenden Beispiel in der Programmiersprache C wird innerhalb der Funktion ''function'' der Wert 5 dem Datenfeld ''a'' der Variablen ''data'' zwar korrekt zugewiesen, kann aber nach dem Rücksprung aus der Funktion im Stapelspeicher jederzeit unbeabsichtigt verändert werden, wie zum Beispiel beim erneuten Aufruf einer Funktion oder anderen Operationen, die den Stapelspeicher verwenden:

&lt;syntaxhighlight lang=&quot;C&quot;&gt;
/* Programmiersprache C */

struct DataType { int a }; // Definition des Datentyps ''DataType'' mit einem ganzzahligen Datenfeld ''a''

// Deklaration der Funktion ''function'' mit einem Zeiger auf eine Variable vom Datentyp ''DataType'' als Speicheradresse für den Rückgabewert
DataType* function ()
{
  DataType data;           // Deklaration der lokalen Variable ''data'' vom Datentyp ''DataType''
  data.a = 5;              // Zuweisung des Wertes ''5'' zum Datenfeld ''a'' der Variablen ''data''
  return &amp;data;            // Rückgabe der lokalen, temporären Speicheradresse von ''data'', die nach der Beendigung des Funktionsaufrufs gar nicht mehr gültig ist.
}
&lt;/syntaxhighlight&gt;

Der Programmierer muss zur Abwendung dieses Übels darauf achten, dass Rückgabewerte durch Allokation einer entsprechenden Variablen in einem dauerhaft verfügbaren dynamischen Speicherbereich (also zum Beispiel im Heap-Speicher) auch nach dem Aufruf der Funktion noch gültig und korrekt aufrufbar sind.

Bei der Verwendung von vollständig typsicheren Programmiersprachen ist die Rückgabe von lokal definierten Adressen nicht zulässig, und die Übersetzung des entsprechenden Codes wird vom Complier von vornherein verweigert, so dass es gar nicht zu einem solchen Nebeneffekt kommen kann.

Alternativ kann der Datentyp ''DataType'' nicht direkt als Verbund, sondern als Zeiger auf einen entsprechenden Verbund deklariert werden. In diesem Fall muss in der Funktion zunächst eine Instanz erzeugt werden (beispielsweise mit dem Kommando ''new'' oder ''allocate''). Diese Instanz ist dann nicht mehr im lokalen Stapelspeicher (Stack) der Funktion gespeichert, sondern es kann im dynamischen Speicherbereich (Heap) global - also auch außerhalb der Funktion und nach Beendigung des Funktionsaufrufs - darauf zugegriffen werden.

===Durch Verwechslung von Speicherinhalt und Speicheradresse===
Die Werte von Variablen werden unter einer bestimmten Speicheradresse eines Computers gespeichert, wo vom Laufzeitsystem die für den entsprechenden Datentyp erforderliche Datenmenge der entsprechende Speicherplatz reserviert und bereitgehalten wird. Diese Speicheradresse wird in modernen Systemen in der Regel automatisch verwaltet, so dass sie im Allgemeinen gar nicht bekannt ist und auch gar nicht bekannt sein muss.

Daraus ergeben sich unter Umständen jedoch wichtige Implikationen. In manchen Programmiersprachen, wie zum Beispiel Java, ist nämlich nicht unmittelbar erkennbar, ob bei bestimmten Operationen der Speicherinhalt oder die Speicheradresse einer Variablen verwendet wird. So werden bei bei logischen Vergleichen mit Operanden, die aus Variablen mit einfachen Datentypen bestehen (etwa boolean, long oder double), die unter der Speicheradresse gespeicherten '''Werte''' verglichen, also die Inhalte. Bei Variablen mit komplexen Datentypen (beispielsweise eine abzählbare Liste von Daten eines Datentyps (array), ein Verbund (record / struct), der sich aus verschiedenen Datentypen zusammensetzen kann, oder allgemein in der objektorientierten Programmierung die Instanz eines Objekts) werden jedoch gar nicht unbedingt die gespeicherten Inhalte, sondern lediglich die Speicheradressen der beiden Operanden verglichen. Hier wird also beim Gleichheitsoperator nur geprüft, ob es sich um dasselbe Speicherobjekt (dieselbe Instanz) handelt, und nicht, ob zwei verschiedene Speicherobjekte den gleichen Inhalt haben. Bei strenger Strukturierung wird (hoffentlich schon vor der Ausführung bereits im Quelltext) zusätzlich geprüft, ob die zu vergleichenden komplexen Datentypen überhaupt zuweisungskompatibel und somit sinnvoll vergleichbar sind.

Unter welchen Umständen welche Speicheradressen für gleiche Speicherinhalte verwendet werden, ist insbesondere für unerfahrene Programmierer keineswegs immer naheliegend oder leicht nachzuvollziehen. Dies wird im Folgenden anhand des logischen Vergleichs auf Gleichheit von Zeichenketten (Java-Klasse java.lang.String) in der Programmiersprache Java verdeutlicht. Die Wirkungsweise des Gleichheitsoperators  == wird der Wirkungsweise des Funktionsaufrufs der Methode '''java.lang.String.equals''' gegenübergestellt, die einen booleschen Rückgabewert hat.

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
	boolean vergleich;

	// Die symbolische Konstante für die Zeichenkette &quot;abc&quot; wird in einer Variablen mit dem Bezeichner text verwaltet
	// Die Zeichenkette &quot;abc&quot; wird von Java unter der Speicheradresse #MEM1 abgelegt
	// Die Variable text und die symbolische konstante Zeichenkette &quot;abc&quot; haben dieselbe Speicheradresse #MEM1
	java.lang.String text = &quot;abc&quot;;

	// Vergleich der Speicheradresse #MEM1 mit der Speicheradresse #MEM1
	vergleich = (&quot;abc&quot; == &quot;abc&quot;);
	java.lang.System.out.println (&quot;1. Vergleich \&quot;abc\&quot; == \&quot;abc\&quot;: &quot; + vergleich);

	// Vergleich der Speicheradresse #MEM1 mit der Speicheradresse #MEM1 !!!
	vergleich = (text == &quot;abc&quot;);
	java.lang.System.out.println (&quot;2. Vergleich text == \&quot;abc\&quot;: &quot; + vergleich);

	// Vergleich des Inhalts bei der Speicheradresse #MEM1 mit dem Inhalt bei der Speicheradresse #MEM1
	vergleich = text.equals (&quot;abc&quot;);
	java.lang.System.out.println (&quot;3. Vergleich text.equals (\&quot;abc\&quot;): &quot; + vergleich);

	// Neue Instanz fuer die bereits oben deklarierte Zeichenkette text 
	// Die neue Instanz wird mit dem new-Operator unter der Speicheradresse #MEM2 erzeugt
	// Der Speicherinhalt wird mit dem Konstruktor java.lang.String und dem Wert &quot;abc&quot; initialisiert
	// Die Variable text bekommt durch die Zuweisung die Speicheradresse #MEM2
	text = new java.lang.String (&quot;abc&quot;);

	// Vergleich der Speicheradresse #MEM2 mit der Speicheradresse #MEM1 !!!
	vergleich = (text == &quot;abc&quot;);
	java.lang.System.out.println (&quot;4. Vergleich text == \&quot;abc\&quot;: &quot; + vergleich);

	// Vergleich des Inhalts bei der Speicheradresse #MEM2 mit dem Inhalt bei der Speicheradresse #MEM1
	vergleich = text.equals (&quot;abc&quot;);
	java.lang.System.out.println (&quot;5. Vergleich text.equals (\&quot;abc\&quot;): &quot; + vergleich);
&lt;/syntaxhighlight&gt;

Die Textausgabe dieses Programms sieht wie folgt aus:

&lt;syntaxhighlight lang=&quot;text&quot;&gt;
1. Vergleich &quot;abc&quot; == &quot;abc&quot;: true
2. Vergleich text == &quot;abc&quot;: true
3. Vergleich text.equals (&quot;abc&quot;): true
4. Vergleich text == &quot;abc&quot;: false
5. Vergleich text.equals (&quot;abc&quot;): true
&lt;/syntaxhighlight&gt;

Symbolisch konstante Zeichenketten, wie zum Beispiel der Ausdruck &quot;abc&quot;, werden unter einer verdeckten Speicheradresse abgelegt und von Java für gleichlautende Ausdrücke automatisch wiederverwendet. Wird jedoch mit dem new-Operator eine Instanz eines Objekts erzeugt, so bekommt diese unabhängig davon, welcher Inhalt dort gespeichert wird, stets eine andere neue Speicheradresse zugeordnet. Für den Vergleich des Inhalts von Zeichenketten auf Gleichheit ist in Java also immer die generische typengebundene Methode &quot;equals'' zu verwenden. Diese typengebundene Methode &quot;equals&quot; gibt es auch in vielen anderen Java-Klassen, um den Inhalt der entsprechenden Objektinstanzen auf Gleichheit vergleichen zu können.

==Strukturierte objektorientierte Programmierung==
===Vermeidung von Codewiederholung durch Vererbung===
Die Vermeidung von Codewiederholung durch Vererbung kann beispielsweise an den beiden graphischen Objekten '''Kreis''' und '''Dreieck''' deutlich gemacht werden. Diese beiden Objekte können unabhängig voneinander als Datentyp modelliert werden, wobei ihre gemeinsamen Eigenschaften '''Farbe''' und '''Strichstärke''', sowie die jeweilige Methode zum '''Zeichnen''' beide Male unabhängig behandelt werden (dies kann eindeutig durch '''Hat'''-Beziehungen ausgedrückt werden: ein Kreis oder ein Dreieck '''hat''' eine Farbe, eine Strickstärke sowie eine Methode zum Zeichnen), was eine Codewiederholung darstellt. Der '''Kreis''' hat zusätzlich das Attribut '''Radius''', und das '''Dreieck''' hat zusätzlich die drei Attribute '''SeiteA''', '''SeiteB''' und '''SeiteC''':

 Kreis   hat: Farbe, Strichstärke, Methode zum Zeichnen, Radius
 Dreieck hat: Farbe, Strichstärke, Methode zum Zeichnen, SeiteA, SeiteB, SeiteC

Mithilfe von Vererbung kann die Codewiederholung vermieden werden, indem die Attribute '''Farbe''' und '''Strichstärke''', sowie die Methode zum '''Zeichnen''' nur einmal mithilfe des abstrakten Objekts '''GraphischesObjekt''' deklariert werden. Die konkreten Objekte '''Kreis''' und '''Dreieck''' erben alle gemeinsamen Eigenschaften und Methoden (respektive typengebundenen Prozeduren) von '''GraphischesObjekt''' (dies kann eindeutig durch '''Ist'''-Beziehungen ausgedrückt werden: ein Kreis '''ist''' ein GraphischesObjekt, und ein Dreieck '''ist''' ein GraphischesObjekt) und werden nur durch die jeweils fehlenden Attribute ergänzt:

 GraphischesObjekt hat: Farbe, Strichstärke, Methode zum Zeichnen

 Kreis   ist GraphischesObjekt, hat zusätzlich: Radius
 Dreieck ist GraphischesObjekt, hat zusätzlich: SeiteA, SeiteB, SeiteC

===Überladung===
Das '''Überladen''' von Methoden, Konstruktoren oder Variablen ist auch bei objektorientierter Programmierung überflüssig, erschwert die Nachvollziehbarkeit vom Quellcode und birgt die Gefahr von Programmierfehlern, die unter Umständen erst lange nach der Entwicklung der Software bei deren Wartung entstehen. Das folgende Beispiel verdeutlicht einen leicht zu übersehenden Programmierfehler durch die Veränderung bei den überladenen Funktionen während der Programmentwicklung oder Programmwartung:

 double quotient (double a, double b)
 {
  return a / b; /* Gleitkommazahlige Division */
 }
 
 long i ← 1;
 long j ← 2;
 double q ← quotient (i, j); /* q ist 0,5 da die gleitkommazahlige Definition der Funktion 'quotient' verwendet wird */

Wird die Funktion 'quotient' später mit einer ganzzahligen Variante überladen, ergibt sich beim bestehenden Aufruf der Funktion unbeabsichtigt ein anderes Ergebnis für die Variable 'q':

 double quotient (long a, long b)
 {
  return a DIV b; /* Ganzzahlige Division */
 }
 
 double quotient (double a, double b)
 {
  return a / b; /* Gleitkommazahlige Division */
 }
 
 long i ← 1;
 long j ← 2;
 double q ← quotient (i, j); /* q ist 0 da die ganzzahlige Definition der Funktion 'quotient' verwendet wird */

Noch unübersichtlicher wird die Lage, wenn zusätzlich auch noch Überladungen mit gemischten Datentypen für die Funktionsparameter definiert werden:

 double quotient (long a, long b)
 
 double quotient (double a, long b)
 
 double quotient (long a, double b)
 
 double quotient (double a, double b)

Deswegen werden Methoden oder Attribute besser nicht überladen, auch nicht, wenn die Programmiersprache dies zulässt. Auch jede Klasse bekommt daher maximal einen einzigen '''Konstruktor''', der alle erforderlichen Parameter zur Initialisierung der Instanzvariablen enthält. Als günstige Nebeneffekte stellen sich kürzere Übersetzungszeiten ein.

Wenn die ursprünglichen Deklarationen in der Basisklasse oder einer der von ihr erbenden Klassen überladen werden, indem zum Beispiel weitere gleichnamige Methoden mit abweichenden Parametern definiert werden, dann kann es zu verändertem Verhalten von Software kommen. Ohne dass die Anwendung selbst geändert wurde, kann es allein durch die Aktualisierung einer verwendeten Klasse zu völlig anderen Rechenergebnissen kommen, weil automatisch eine andere, neu überladene Methode aufgerufen wird, ohne dass dies im Quelltext des Anwendungsprogramms sichtbar wird. Die Folge können schwerwiegende Programmierfehler sein, die schwierig zu analysieren sind.

Als ein Beispiel diene hier die Methode java.lang.Math.ulp zur Bestimmung der &quot;'''u'''nits in the '''l'''ast '''p'''lace&quot; (&quot;Einheiten in der letzten Stelle&quot;), die in der Klasse java.lang.Math aus historischen Gründen mit zwei Parametern deklariert und somit überladen ist:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 public class Math;
 {
    public static double ulp​ (double d)
    public static float  ulp​ (float f)
 }
&lt;/syntaxhighlight&gt;

Der folgende Java-Code

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 double zahl;
 zahl = java.lang.Math.ulp (1L); // Datentyp long
 java.lang.System.out.println (zahl);
 zahl = java.lang.Math.ulp (1F); // Datentyp float
 java.lang.System.out.println (zahl);
 zahl = java.lang.Math.ulp (1D); // Datentyp double
 java.lang.System.out.println (zahl);
&lt;/syntaxhighlight&gt;

erzeugt folgende Ausgabe, da die ganze Zahl Eins mit dem Datentyp long (64 Bit) in der Programmiersprache Java implizit offensichtlich nicht in den Datentyp double (64 Bit), sondern in den Datentyp float (32 Bit) umgewandelt wird, und somit die mit dem Parameter des Datentyps float deklarierte Methode aufgerufen wird:

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 1.1920928955078125E-7
 1.1920928955078125E-7
 2.220446049250313E-16
&lt;/syntaxhighlight&gt;

Falls bei einer neueren Version der Klasse java.lang.Math die Methode ulp mit einem Parameter des Datentyps long überladen würde, wäre das Ergebnis mit dem ganzzahligen Parameter des Werts &quot;1L&quot; (long) nicht mehr vorhersagbar, obwohl der oben angegebene Methodenaufruf sich formal gar nicht geändert hätte.

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 public class Math;
 {
    public static double ulp ​(double d)
    public static float  ulp​ (float f)
    public static double ulp ​(long l)
 }
&lt;/syntaxhighlight&gt;

Das Ergebnis des Aufrufs 

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/* Programmiersprache Java */
 double zahl = java.lang.Math.ulp (1L);
 java.lang.System.out.println (zahl);
&lt;/syntaxhighlight&gt;

würde dann allein von der tatsächlichen Implementierung der neuen überladenen Methode mit dem Parameter des Datentyps long abhängen, die mit den alten beiden ulp-Methoden nichts mehr zu tun hat, außer, dass sie den gleichen Namen hat.

===Überschreibung===
Das '''Überschreiben''' von geerbten Methoden oder Konstruktoren ist etwas völlig anderes als das Überladen und kann sehr sinnvoll sein.

Beim Überschreiben muss die Signatur der Methode (oder des Konstruktors) unter strikter Beachtung der Zuweisungskompatibilität, der Anzahl und der Reihenfolge aller Parameter sowie der Rückgabewerte berücksichtigt werden. Wenn die Programmiersprache dies nicht automatisch unterstützt, sind wenigstens entsprechend aufwendige Maßnahmen im Quelltext sicherzustellen, wie zum Beispiel explizite Typenprüfungen oder hinreichend ausführliche Hinweise in Kommentaren.

Wenn Methoden oder Konstruktoren einer Basisklasse von der überschreibenden Klasse aufgerufen werden (englisch ''super call'') kann es zum ''Fragile Base Class Problem'' (zu Deutsch ''Problem der anfälligen Basisklasse'') kommen, da bei der Implementierung der Basisklasse die möglichen Auswirkungen in den später implementierten, überschreibenden Klassen nicht berücksichtigt werden konnten. Zur Abwendung dieser Gefahr sind ein besonders sorgfältiger und strukturierter Programmierstil sowie eine lückenlose Dokumentation des Quelltextes sehr hilfreich.

Das fehlerfreie und robuste Überschreiben von Klassen beziehungsweise die Vererbung von implementierten Klassen erfordern eine hohe Fähigkeit zum abstrakten Denken und eine umfangreiche Programmiererfahrung.

===Mehrfachvererbung===
Durch [[w:Mehrfachvererbung|Mehrfachvererbung]], also das Erben von Methoden und Instanzvariablen aus mehreren Basisklassen, führt zu komplexen, und schwierig zu durchschauenden Abhängigkeiten, die im Rahmen des [[w:Diamond-Problem|Diamond-Problems]] sogar zu unerwünschten Mehrdeutigkeiten führen kann. Die Vererbung aus zwei Basisklassen kann bei Bedarf ohne weiteres durch die Verwendung von [[w:Zwillingsklasse|Zwillingsklassen]] vermieden werden, was den Programmieraufwand ein wenig erhöht, aber dafür solche Mehrdeutigkeiten verhindert und außerdem die Übersetzungszeiten der Quelltexte reduziert.

In der Programmiersprache Java ist es zum Beispiel möglich, mehrere Basisklassen zu erben. Dabei ist zwar nur eine konkrete Vererbung aus einer Basisklasse (in Java: class) zulässig, aber zusätzlich dürfen noch beliebig viele weitere Basisklassen (in Java: interface) abstrakt geerbt werden. Dabei werden alle Attribute und Methoden aller Basisklassen auf die erbende Klasse übertragen. Auch die konkret vererbte Basisklasse kann wiederum selber mehrere abstrakte Basisklassen implementieren. Falls es in mehreren Basisklassen gleichlautende öffentliche Bezeichner gibt, kommt es unweigerlich zu Konflikten. 

Es ist in der Implementierung insbesondere bei fehlenden entsprechenden Kommentaren nicht ohne Weiteres erkennbar, zu welchen Basisklassen die zu überschreibenden Instanzvariablen oder Methoden gehören.

&lt;syntaxhighlight lang=&quot;Java&quot;&gt;
/**
 * Die Klasse Mehrfachvererbung erbt Attribute und Methoden aus drei Basisklassen:
 *    Sie ist eine Instanz der Klasse (class = konkrete Klasse) javax.swing.JFrame.
 *    Sie implementiert die Schnittstelle (interface = abstrakte Klasse) java.awt.event.KeyListener.
 *    Sie implementiert die Schnittstelle (interface = abstrakte Klasse) java.awt.event.ActionListener.
 */

public class Mehrfachvererbung
extends javax.swing.JFrame
implements java.awt.event.KeyListener, java.awt.event.ActionListener
{
	/**
	 *  Konstante serialVersionUID aus der Basisklasse java.io.Serialization fuer die Serialisation,
	 *  die in der Klasse javax.swing.JFrame implementiert ist
	 */
	private final static long serialVersionUID = 1L;

	/**
	 *  Instanzvariable fuer den zuletzt von einer Instanz der Klasse javax.swing.JFrame gesendeten Tastaturcode
	 */
	private int keyCode;

	/**
	 *  Zu ueberschreibende Methode aus der geerbten Klasse java.awt.event.KeyListener
	 *  Speichert den Tastaturcode der zuletzt betaetigten Taste fuer eine Instanz
	 *  @param event: aufgetretenes Tastaturereignis aus der Klasse java.awt.event.KeyEvent
	 */
	@Override
	public void keyPressed (java.awt.event.KeyEvent event)
	{
		this.keyCode = event.getKeyCode ();
	}

	/**
	 *  Zu ueberschreibende Methode aus der geerbten Klasse java.awt.event.KeyListener
	 *  Ungenutzt
	 *  @param event: aufgetretenes Tastaturereignis aus der Klasse java.awt.event.KeyEvent
	 */
	@Override
	public void keyReleased(java.awt.event.KeyEvent event)
	{
	}

	/**
	 *  Zu ueberschreibende Methode aus der geerbten Klasse java.awt.event.KeyListener
	 *  Ungenutzt
	 *  @param event: aufgetretenes Tastaturereignis aus der Klasse java.awt.event.KeyEvent
	 */
	@Override
	public void keyTyped (java.awt.event.KeyEvent event)
	{
	}

	/**
	 *  Zu ueberschreibende Methode aus der vererbten Klasse java.awt.event.ActionListener
	 *  Der Inhalt einer Instanz der Klasse javax.swing.JFrame wird erneut dargestellt,
	 *  wenn die Eingabetaste (Enter) betaetigt wurde.
	 *  @param event: aufgetretenes Aktionsereignis aus der Klasse java.awt.event.ActionEvent
	 */
	@Override
	public void actionPerformed (java.awt.event.ActionEvent event)
	{
		if (this.keyCode == java.awt.event.KeyEvent.VK_ENTER)
		{
			this.repaint ();
		}
	}
}
&lt;/syntaxhighlight&gt;

==Nachwort==
Ein sehr häufig auftretender „Programmierfehler“ - wiederum insbesondere bei Anfängern - ist das Unterlassen der Herstellung von Sicherungskopien der Quelltexte. Noch besser ist eventuell sogar eine Versionierung der Quelldateien, damit gegebenenfalls auf beliebige ältere Versionen zurückgegriffen werden kann. Die Auswirkungen dieses Fehlers sind hinreichend naheliegend, so dass hier nicht weiter darauf eingegangen werden muss.

Sollte der Leser nach der Lektüre dieser Beiträge zu dem verständlichen und naheliegenden Schluss gekommen sein, dass die Programmiersprachen C oder C++ ziemlich schlecht strukturiert sind, möge er sich auch einmal andere Programmiersprachen näher ansehen, wie zum Beispiel C#, Component Pascal oder auch Java.

Mit der Beherzigung der Vorschläge aus diesem Buch möge es dem Leser in seinem Programmier-Team in jeder Programmiersprache gelingen, in kürzerer Entwicklungszeit besser strukturierte und funktionierende Programme zu schreiben.

===Vergleich===
In der folgenden Tabelle werde einige imperative, objektorientierte Programmiersprachen hinsichtlich ihrer Strukturiertheit verglichen:

{| class=&quot;wikitable&quot;
|- class=&quot;hintergrundfarbe6&quot;
!Veröffentlichungsdatum!!1985!!1994!!1995!!2001
|-
!Programmiersprache!!C++!!Component&lt;br/&gt;Pascal!!Java!!C#
|-
| style=&quot;text-align:left&quot;| Vollständig strukturierte Syntax || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | nein
|-
| style=&quot;text-align:left&quot;| Datentypsicherheit bei Basistypen || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | ja
|-
| style=&quot;text-align:left&quot;| Datentypsicherheit bei komplexen Datentypen || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja
|-
| style=&quot;text-align:left&quot;| Modulsicherheit || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja
|-
| style=&quot;text-align:left&quot;| Keine zyklischen Importe || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | nein
|-
| style=&quot;text-align:left&quot;| Keine mehrfache Schnittstellenvererbung || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | nein
|-
| style=&quot;text-align:left&quot;| Keine mehrfache Implementationsvererbung || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja || style=&quot;text-align:center&quot; | nein || style=&quot;text-align:center&quot; | ja
|}

==Literatur==
* Niklaus Wirth:
** ''Programming in Modula 2'', Springer, 3. Auflage, 1985, ISBN 3-540-15078-1
** Mit Martin Reiser: ''Programming in Oberon – Steps beyond Pascal and Modula'', Addison-Wesley,1992, ISBN 0-201-56543-9
** ''Algorithmen und Datenstrukturen mit Modula - 2'', Teubner Leitfäden der Informatik, 5. Auflage, Teubner, Stuttgart, 1996, ISBN 9783519122609
* Herbert Schildt: ''Professionelles Modula-2'', McGraw-Hill, Hamburg, 1988, ISBN 3-89028-113-3
* Lászlo Böszörmény, Jürg Gutknecht, Gustav Pomberger: ''The School of Niklaus Wirth – The Art of Simplicity'', dpunkt, Heidelberg, 2000, ISBN 3-932588-85-1
* Hanspeter Mössenböck:
** ''Objektorientierte Programmierung in Oberon-2'', Springer, 1998, ISBN 9783540646495
** ''Sprechen Sie Java?: Eine Einführung in das systematische Programmieren'', dpunkt, Heidelberg, 2005, ISBN 9783898643627
** ''Kompaktkurs C# 4.0'', dpunkt, Heidelberg, 2009, ISBN 9783898646451

==Weblinks==
*{{w|Niklaus Wirth}}:
**Interessantes Interview: [http://www.simple-talk.com/opinion/geek-of-the-week/niklaus-wirth-geek-of-the-week/ Geek of the Week] vom 2. Juli 2009
**Ein noch interessanteres Interview (2009): [http://www.youtube.com/watch?v=wrGytM2YTQY An Interview with Niklaus Emil Wirth, Part 3]
*{{w|Frederick P. Brooks}}: [[w:en:The_Mythical_Man-Month|The Mythical Man-Month]]
*{{w|Benutzer:Bautsch|Markus Bautsch}}: [[:en:User:Bautsch/Capsula|Draft of the graphical programming language '''Capsula''']] (Wikibooks)

== Einzelnachweise ==
&lt;references&gt;&lt;/references&gt;

==Zusammenfassung des Projekts==
{{Vorlage:StatusBuch|10}}
* '''Zielgruppe:''' Programmierer, Software-Entwickler, Informatik-Lehrende
* '''Lernziele:''' Vermeidung von Fehlern, die leicht und unbemerkt zur unstrukturierten Programmierung führen können. Schnelle und sichere Erstellung leicht zu wartender Software.
* '''Buchpatenschaft/Ansprechperson:''' [[Benutzer:Bautsch]]
* '''Sind Co-Autoren gegenwärtig erwünscht?''' Ja, sehr gerne. Korrekturen von offensichtlichen Fehlern direkt im Text; Inhaltliches bitte per Diskussion.
* '''Richtlinien für Co-Autoren:''' Wikimedia-like.

[[Kategorie:Buch]]
[[Kategorie:Studium]]</text>
      <sha1>2oatpkiogvv8b37ty5wbz3tomcfc35q</sha1>
    </revision>
  </page>
  <page>
    <title>Diskussion:Strukturierte Programmierung</title>
    <ns>1</ns>
    <id>84137</id>
    <revision>
      <id>1088580</id>
      <parentid>1088578</parentid>
      <timestamp>2026-07-03T12:13:19Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <comment>/* Leerräume */ Antwort</comment>
      <origin>1088580</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="14604" sha1="1t966guqdnyk7dekqyfbffbiohfmo0u" xml:space="preserve">== Erweiterung ==
Diese Zusammenstellung von Hinweisen gefällt mir. In vielen Lehrbüchern werden immer wieder dieselben Ratschläge benötigt -- hier sind sie als Sammlung zu finden. ''Ich glaube, ich werde auch etwas beitragen.'' -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
:Die Unterstützung würde mich sehr freuen! --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)

Auch die folgenden Themen könnten besprochen werden.
;Untergliederung: Das Buch bekommt inzwischen so viele Einzelthemen, dass eine Gliederung in Bereiche (und damit in eigenständige Kapitel) sinnvoll wäre. ''Ich habe mir darüber noch keine genaueren Gedanken gemacht.'' -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Diese Idee ist mir auch schon gekommen, aber ich habe mir auch noch keine weiteren Gedanken gemacht. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
::: Diese Anleitung nimmt immer mehr Inhalt an (und sobald andere Programmierer es sehen, dürfte noch mehr dazu kommen). Ich empfehle deshalb die Aufteilung in einzelne Kapitel (Seiten); als Hauptthemen geht mir so etwas durch den Kopf (noch nicht als Formulierungen der Kapitel):
:::* Gestaltung von Quelltexten
:::* Konstante, Variable, Bezeichner, Deklaration
:::* Zusammenarbeit zwischen Quelldateien/Modulen/DLLs usw.
:::* Steuerung des Arbeitsablaufs
:::* alles, was zur OOP relevant ist
::: Ich bin mir noch unsicher, ob alle bisherigen Stichpunkte auf diese Weise sinnvoll untergebracht werden. Aber vielleicht kommen wir auf diese Weise zu einer Struktur &amp;ndash; denn um Struktur geht es hier schließlich. {{Smiley|lol}} -- [[Benutzer:Juetho|Jürgen]] 13:32, 6. Jan. 2012 (CET)

;Einrückungen und Zeilenumbruch: Du hast den Code automatisch eingerückt. Das sollte in einem eigenen Punkt erläutert werden. Ein Zeichen ist dafür entschieden zuwenig; man sollte mindestens zwei Zeichen verwenden. Bitte setze aber keine absoluten Regeln fest. Beispielsweise kann man bei diesen [[C++-Programmierung/ Einführung zum Buch/ Konventionen|Konventionen]] unterschiedlicher Meinung sind. Wichtig sind klare Festlegungen innerhalb eines Programms, damit die Struktur auch für neue Leser erkennbar bleibt. (Das hilft auch dem Autor eines Codes, wenn er nach zwei Wochen, Monaten oder Jahren etwas überarbeiten muss.) -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Ich bevorzuge den Tabulator - mehrfache Leerzeichen stammen aus der Zeit der ersten Texteditoren-, aber ich vermute und befürchte, dass dies in der Wiki-Software zur Zeit noch nicht unterstützt wird. Für die Compiler spielt dies keine Rolle, aber dafür umso mehr für die Menschen, die davor sitzen ;-) --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
::: Ich bevorzuge eigentlich ebenfalls Tabs, zumal in der IDE die Tab-Größe in der Regel eingestellt werden kann. Aber beim Kopieren z.B. über Foren geht der eigene Standard verloren; dann sind Leerzeichen besser, weil kompatibler. Mir ist vor allem aufgefallen, dass deine Code-Beispiele nur um ein Zeichen eingerückt sind. Es mag sein, dass das bei dir ein Tab war, und beim Herüberkopieren wurde das zu einem einsamen Leerzeichen. qed -- [[Benutzer:Juetho|Jürgen]] 13:32, 6. Jan. 2012 (CET)

;Deutsch oder Englisch: Ich empfehle, für Bezeichner generell englische Begriffe zu wählen, auch wenn ich die Verwendung der deutschen Sprache im deutschen Sprachraum entschieden bevorzuge. Zur Erläuterung meines Standpunkts (mit Beispielen) siehe [[Arbeiten mit .NET: Allgemeines/ Anhang/ Namenskonventionen#Deutsch oder Englisch?|.NET-Namenskonventionen]]. -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Damit habe ich keine Probleme, zumal ich sowieso vor hatte, das Wikibook ins Englische zu übertragen. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
:::Ich finde deutsche Bezeichner für deutschsprachige Leser verständlicher. Auch die Kommentare sollten meiner Meinung nach deutschsprachig bleiben. – [[Benutzer:Gebu|Gebu]] 17:48, 2. Jul. 2026 (CEST)

Es ist erstaunlich, was einem bei Verbessern noch so alles einfällt. Ich habe einiges vom Diskutierten bereits umgesetzt und bin mir aber bewusst, dass dies alles noch nicht fertig und noch nicht der Weisheit letzter Schluss ist. Die sinnvolle Strukturierung von Artikeln ist mindestens so herausfordernd, wie diejenige von Programmen ;-)  --[[Benutzer:Bautsch|Bautsch]] 12:49, 7. Jan. 2012 (CET)

== Kein Missbrauch bei Imports ==
Ich möchte widersprechen: Es ist kein Missbrauch, wenn &lt;tt&gt;using&lt;/tt&gt; bzw. &lt;tt&gt;imports&lt;/tt&gt; zur Verkürzung des Quellcodes genutzt wird. Gerade bei .NET mit den langen, mehrstufigen Namespace-Bezeichnern macht die ständige Wiederholung des vollständigen Bezeichners den Code sehr unübersichtlich. Der folgende Quelltext (aus der .NET-Doku kopiert) ist doch überhaupt nicht mehr lesbar, und es gibt Namespaces mit noch viel längeren Namen:
{{Syntax|lang=csharp|border=2|code=
public void InsertRow(string connectionString)
{
    string queryString = &quot;INSERT INTO Dept (DeptNo, Dname, Loc) values (50, 'TECHNOLOGY', 'DENVER')&quot;;
    using (System.Data.OracleClient.OracleConnection connection
        = new System.Data.OracleClient.OracleConnection(connectionString))
    {
        System.Data.OracleClient.OracleCommand command = new System.Data.OracleClient.OracleCommand(queryString);
        // do anything
    }
} }}
Man muss also in der Praxis abwägen. Bei &quot;einfachen&quot; Bezeichnern wie MyModule passt der Ratschlag, aber es gibt eben auch andere Situationen. -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
:Ich finde diesen Code gerade noch lesbar, verstehe das Argument aber sehr gut; insbesondere wenn auf engem Raum sehr viele Bezeichner aus einer fernen Bibliothek benutzt werden, kann das schnell albern und unübersichtlich aussehen. Bei einmaligem Auftreten finde ich das Ausschreiben im Allgemeinen schon recht hilfreich.

:Im engeren Sinne meinte ich aber besonders die Imports mit Wildcards, so wie zum Beispiel:

 import myPackage.*;
 import yourPackage.*;
 
 drawLine ();
 
 Class var = new Class (); /* To which package does Class belong ? */

und ähnliche Fälle. Ich werde das demnächst einmal genauer und etwas umfangreicher formulieren. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)

== For-Schleifen ==

Mit dem was unter &quot;For-Schleifen&quot; steht, bin ich nicht ganz einverstanden bzw. erkenne nicht so ganz die Relevanz. Praktisch jede Programmiersprache, die die dortige Syntax kennt (z.B. C ab C99, C++, Java, C#, D), erlaubt auch ...
  for(int i = 0; i &lt; max; i++)
  {
   ...
  }
... mit dem entscheidenen Vorteil, dass i &quot;so lokal wie möglich ist&quot; (siehe weiter oben unter &quot;Prinzip der Lokalität&quot;), nämlich nur innerhalb des Schleifen-Blocks. Wenn wirklich nur stumpf gezählt wird und die Zähl-Variable danach nicht mehr benötigt wird, sollte immer die For-Schleife den Vorzug bekommen. Zudem würd ich die for-Schleifen noch zum &quot;einfachen Sprachumfang&quot; zählen, da immer sehr einfach und praktisch immer (in der obigen Form) identisch implementiert. Wenn man sich dagegen mal die Regeln für switch/case-Anweisungen vermeintlich ähnlicher Sprachen anguckt ... --[[Spezial:Beiträge/92.196.53.40|92.196.53.40]] 21:51, 26. Mär. 2012 (CEST)

: Zustimmung zu deinen Bedenken. Es sind wohl die Randbedingungen zu beachten: Sofern dasselbe ''i'' vorher oder nachher benutzt wird, kann &lt;tt&gt;for&lt;/tt&gt; durch eine der anderen Schleifen ersetzt werden. Du darfst Text und Gliederung gerne überarbeiten. -- [[Benutzer:Juetho|Jürgen]] 09:04, 27. Mär. 2012 (CEST)
:: Ich würd es eigentlich nur löschen wollen (was ich aber nicht tun werde). Die genannten Argumente überzeugen mich nicht und &quot;... unter Umständen &lt;small&gt;[welchen?]&lt;/small&gt; ... auschließlich ...&quot; spricht auch nicht für eine eindeutigen Standpunkt des Autors. Wenn eine Sprache einen Zählschleifenkonstrukt mitbringt, sollte man es auch nutzen dürfen, denn es macht dem Quellcode-Leser deutlich, dass da nur gezählt wird (möglichst fixe Anzahl und Schrittweite) und nicht auf die Nichterfüllung einer while-Bedingung gewartet wird. --[[Spezial:Beiträge/92.196.30.97|92.196.30.97]] 21:20, 27. Mär. 2012 (CEST)

:::Ich bedanke mich für den wichtigen und richtigen Hinweis zur Lokalität und die Nichtlöschung des Abschnittes. Die Information habe ich mit einer weiteren Ergänzung in das Wikibook eingebaut. --[[Benutzer:Bautsch|Bautsch]] 08:39, 30. Mär. 2012 (CEST)
== Standard-Vorsilben und Bezeichner ==
Bei der Schreibweise von Bezeichnern und Methoden könnte man noch anfügen, dass bestimmte Standard-Vorsilben allgemein üblich sind. '''set'''Foo '''get'''Foo und andere wie '''is'''Foo '''my'''Foo '''del'''Foo '''copy'''Foo recht gebräuchlich. Der Bezug zum Objekt bleibt dadurch gewahrt. Ebenso kann man die Joker (Metasyntaktische Variablen) Foo, Bar, Bas, für den Quellcode erläutern. (z.B. am Beispiel von Parameterlisten). Weiterhin sollten gängige Zählvariablen erläutert werden. Das i und j meist für Iterationen gebraucht werden.  --[[Benutzer:Mjchael|mjchael]] 13:57, 30. Mär. 2012 (CEST)
: my, del und  copy ist mir noch nie untergekommen. Das dürfte auch zu sprachspezifisch werden (ist es teileweise schon jetzt, finde ich). Ab irgendeinem Punkt kann man nur noch auf die Styleguides der einzelnen Sprachen verweisen. --[[Spezial:Beiträge/92.196.71.109|92.196.71.109]] 17:07, 31. Mär. 2012 (CEST)

: Eine kleine Anekdote, die von meinem Vater berichtet wurde, der über 40 Jahre in der Softwareentwicklung tätig war: Als Schleifenzähler wurde &quot;ii&quot; benutzt (doppeltes &quot;i&quot;). Dadurch kann man diese Variable mit der Suchfunktion besser finden als ein einzelnes &quot;i&quot;, das z. B. auch in anderen Variablennamen oder Kommentaren vorkommen kann. – [[Benutzer:Gebu|Gebu]] 17:57, 2. Jul. 2026 (CEST)
::Solche Konstrukte sind bei der Verwendung von Editoren mit &quot;Refactor&quot;-Funktion inzwischen ja nicht mehr notwendig, sofern die Variablen und deren Sichtbarkeitsbereiche strukturiert deklariert worden sind... --[[Benutzer:Bautsch|Bautsch]] 13:57, 3. Jul. 2026 (CEST)

== Leerräume ==

&quot;Leerräume, also zum Beispiel Leerzeichen, Zeilen- und Seitenumbrüche oder Tabulatoren, werden - genauso wie Kommentare - vom Compiler überlesen und dienen daher ausschließlich zur Verbesserung der Lesbarkeit für die Programmierer.&quot; Stimmt das wirklich immer? Zumindest für bestimmte Scriptsprachen trifft es nicht zu. In Python z.B. ist korrekte Einrückung absolut notwendig (siehe [[w:Python (Programmiersprache)#Strukturierung durch Einrücken]]). Ich würde hier zumindest einen entsprechenden Hinweis anbringen, dass es durchaus Ausnahmen geben kann. --[[Benutzer:Versat|Versat]] 09:36, 4. Dez. 2015 (CET)

: Zustimmung zu deinem Hinweis; bei Basic (vermutlich bei allen Dialekten) ist das Zeilenende (also ein einfacher Zeilenumbruch) die Markierung für den Abschluss einer Anweisung. Also ändere es passend. -- [[Benutzer:Juetho|Jürgen]] 10:03, 4. Dez. 2015 (CET)

: Danke für die Hinweise&amp;nbsp;! Ich stimme auch zu, denn auch bei FORTRAN mussten am Zeilenanfang bestimmte Einrückungen eingehalten werden, damit die Lochkarten korrekt gestanzt werden konnten. Ich hatte das verdrängt, und habe den Text jetzt entsprechend geändert. --[[Benutzer:Bautsch|Bautsch]] 16:19, 5. Dez. 2015 (CET)

: Wie ich lese, sind Tabulatoren nicht mehr erwünscht. Statt dessen haben sich vier Leerzeichen durchgesetzt. Das könnte nach einer Prüfung an passender Stelle ins Buch aufgenommen werden. Quelle: Eine Google-Suche nach „Vier Leerzeichen oder Tabulator?“ – [[Benutzer:Gebu|Gebu]] 18:13, 2. Jul. 2026 (CEST)
::Danke für den Hinweis, habe es gerade aktualisiert. Ich kenne übrigens mehrere aktuelle Programmeditoren, die noch TAB-Zeichen unterstützen und verwenden. --[[Benutzer:Bautsch|Bautsch]] 14:13, 3. Jul. 2026 (CEST)

== Beispiele Überladung des Divisionsoperators ==

Huhu, eine Frage wegen den Beispielen in diesem Abschnitt, laut Kommentar sind dort zwei Beispiele für Pascal, ist das nicht eher C, weil die Zuordnung der Werte in Pascal mit := erfolgen, oder? -- [[Benutzer:Zase Wieder|Zase Wieder]] 10:23, 28. Nov. 2023 (CET)

:Ich schätze es handelt sich hier lediglich um einen Flüchtigkeitsfehler. Kommentare und Syntaxhighlight sprechen für das Ziel Pascal. Könnte ja auch sein, dass es Zuweisungen aus dem Programmbeginn sein sollen. Nach der Projektbeschreibung (offensichtlicher Fehler) hab ich mal Doppelpunkte ergänzt. Für den Fall der Fälle: Ping@[[Benutzer:Bautsch|Bautsch]]. Viele Grüße, [[Benutzer:HirnSpuk|HirnSpuk]]&lt;sup&gt;[[Benutzer Diskussion:HirnSpuk|Disk]]&lt;/sup&gt; –  15:39, 28. Nov. 2023 (CET)

::Ich danke Euch beiden, und habe mir auch noch erlaubt, &quot;div&quot; mit kleinen Buchstaben zu schreiben... :-) --[[Benutzer:Bautsch|Bautsch]] 16:50, 28. Nov. 2023 (CET)
:::ich danke auch, nur noch eine Kleinigkeit: die Zuweisungart des Typs ist mir nicht so bekannt, ist es nicht umgekehrt  ''xxx: integer;'' statt ''int xxx;''und erfolgt diese Typenanweisung  nicht „außerhalb“ in der Präambel. Auch scheinen leider unter der Literatur Ihre/Deine Beiträge nicht mehr bei ENISA aufrufbar zu sein, gibt es Alternativen (crises verbessert google zu crisis, ist letzteres gemeint?). Danke im Voraus und danke für die ganzen Kapitel hier auf de.wikibooks.org :). --grüße [[Benutzer:Zase Wieder|Zase Wieder]] 20:45, 12. Dez. 2023 (CET)

== Veraltetes im Kommentar zu Beginn ==

Derzeit im Buch: „Dazu gehören der Dateiname, der Modulname (respektive Klassenname) …“

Beides ist meines Wissens veraltet. Außerdem widerspricht beides dem DRY-Grundsatz („Wiederhole dich nicht.“). In Java müsste beispielsweise bei Änderung des Klassennamens sowohl der Dateiname als auch der Klassenname im Kommentar zu Beginn geändert werden. – [[Benutzer:Gebu|Gebu]] 10:23, 2. Jul. 2026 (CEST)

== Ist der Begriff „Prozeduren“ veraltet? ==

Derzeit im Buch: „… für Methoden (respektive für Prozeduren oder für Funktionen) …“.

Prozeduren gab es mal in der historischen Programmiersprache Pascal. Wird in aktuellen Programmiersprachen noch zwischen Prozedur und Funktion bzw. Methode unterschieden? – [[Benutzer:Gebu|Gebu]] 10:34, 2. Jul. 2026 (CEST)

== Minuszeichen im Beispiel in Component Pascal ==

Derzeit im Buch: „zahl-: LONGINT;“.

Ist hier das Minuszeichen falsch? – [[Benutzer:Gebu|Gebu]] 10:44, 2. Jul. 2026 (CEST)

== Zuweisungskompatibilität / Zeichenketten ==

Derzeit zu sehr auf die Programmiersprache C bezogen. Spätestens seit Java (seit 30 Jahren) überholt. – [[Benutzer:Gebu|Gebu]] 11:10, 2. Jul. 2026 (CEST)</text>
      <sha1>1t966guqdnyk7dekqyfbffbiohfmo0u</sha1>
    </revision>
    <revision>
      <id>1088581</id>
      <parentid>1088580</parentid>
      <timestamp>2026-07-03T12:28:14Z</timestamp>
      <contributor>
        <username>Gebu</username>
        <id>27433</id>
      </contributor>
      <comment>/* Leerräume */ Antwort</comment>
      <origin>1088581</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="14668" sha1="irirc28jk2j0ax98b9lh8tatiibhukx" xml:space="preserve">== Erweiterung ==
Diese Zusammenstellung von Hinweisen gefällt mir. In vielen Lehrbüchern werden immer wieder dieselben Ratschläge benötigt -- hier sind sie als Sammlung zu finden. ''Ich glaube, ich werde auch etwas beitragen.'' -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
:Die Unterstützung würde mich sehr freuen! --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)

Auch die folgenden Themen könnten besprochen werden.
;Untergliederung: Das Buch bekommt inzwischen so viele Einzelthemen, dass eine Gliederung in Bereiche (und damit in eigenständige Kapitel) sinnvoll wäre. ''Ich habe mir darüber noch keine genaueren Gedanken gemacht.'' -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Diese Idee ist mir auch schon gekommen, aber ich habe mir auch noch keine weiteren Gedanken gemacht. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
::: Diese Anleitung nimmt immer mehr Inhalt an (und sobald andere Programmierer es sehen, dürfte noch mehr dazu kommen). Ich empfehle deshalb die Aufteilung in einzelne Kapitel (Seiten); als Hauptthemen geht mir so etwas durch den Kopf (noch nicht als Formulierungen der Kapitel):
:::* Gestaltung von Quelltexten
:::* Konstante, Variable, Bezeichner, Deklaration
:::* Zusammenarbeit zwischen Quelldateien/Modulen/DLLs usw.
:::* Steuerung des Arbeitsablaufs
:::* alles, was zur OOP relevant ist
::: Ich bin mir noch unsicher, ob alle bisherigen Stichpunkte auf diese Weise sinnvoll untergebracht werden. Aber vielleicht kommen wir auf diese Weise zu einer Struktur &amp;ndash; denn um Struktur geht es hier schließlich. {{Smiley|lol}} -- [[Benutzer:Juetho|Jürgen]] 13:32, 6. Jan. 2012 (CET)

;Einrückungen und Zeilenumbruch: Du hast den Code automatisch eingerückt. Das sollte in einem eigenen Punkt erläutert werden. Ein Zeichen ist dafür entschieden zuwenig; man sollte mindestens zwei Zeichen verwenden. Bitte setze aber keine absoluten Regeln fest. Beispielsweise kann man bei diesen [[C++-Programmierung/ Einführung zum Buch/ Konventionen|Konventionen]] unterschiedlicher Meinung sind. Wichtig sind klare Festlegungen innerhalb eines Programms, damit die Struktur auch für neue Leser erkennbar bleibt. (Das hilft auch dem Autor eines Codes, wenn er nach zwei Wochen, Monaten oder Jahren etwas überarbeiten muss.) -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Ich bevorzuge den Tabulator - mehrfache Leerzeichen stammen aus der Zeit der ersten Texteditoren-, aber ich vermute und befürchte, dass dies in der Wiki-Software zur Zeit noch nicht unterstützt wird. Für die Compiler spielt dies keine Rolle, aber dafür umso mehr für die Menschen, die davor sitzen ;-) --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
::: Ich bevorzuge eigentlich ebenfalls Tabs, zumal in der IDE die Tab-Größe in der Regel eingestellt werden kann. Aber beim Kopieren z.B. über Foren geht der eigene Standard verloren; dann sind Leerzeichen besser, weil kompatibler. Mir ist vor allem aufgefallen, dass deine Code-Beispiele nur um ein Zeichen eingerückt sind. Es mag sein, dass das bei dir ein Tab war, und beim Herüberkopieren wurde das zu einem einsamen Leerzeichen. qed -- [[Benutzer:Juetho|Jürgen]] 13:32, 6. Jan. 2012 (CET)

;Deutsch oder Englisch: Ich empfehle, für Bezeichner generell englische Begriffe zu wählen, auch wenn ich die Verwendung der deutschen Sprache im deutschen Sprachraum entschieden bevorzuge. Zur Erläuterung meines Standpunkts (mit Beispielen) siehe [[Arbeiten mit .NET: Allgemeines/ Anhang/ Namenskonventionen#Deutsch oder Englisch?|.NET-Namenskonventionen]]. -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Damit habe ich keine Probleme, zumal ich sowieso vor hatte, das Wikibook ins Englische zu übertragen. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
:::Ich finde deutsche Bezeichner für deutschsprachige Leser verständlicher. Auch die Kommentare sollten meiner Meinung nach deutschsprachig bleiben. – [[Benutzer:Gebu|Gebu]] 17:48, 2. Jul. 2026 (CEST)

Es ist erstaunlich, was einem bei Verbessern noch so alles einfällt. Ich habe einiges vom Diskutierten bereits umgesetzt und bin mir aber bewusst, dass dies alles noch nicht fertig und noch nicht der Weisheit letzter Schluss ist. Die sinnvolle Strukturierung von Artikeln ist mindestens so herausfordernd, wie diejenige von Programmen ;-)  --[[Benutzer:Bautsch|Bautsch]] 12:49, 7. Jan. 2012 (CET)

== Kein Missbrauch bei Imports ==
Ich möchte widersprechen: Es ist kein Missbrauch, wenn &lt;tt&gt;using&lt;/tt&gt; bzw. &lt;tt&gt;imports&lt;/tt&gt; zur Verkürzung des Quellcodes genutzt wird. Gerade bei .NET mit den langen, mehrstufigen Namespace-Bezeichnern macht die ständige Wiederholung des vollständigen Bezeichners den Code sehr unübersichtlich. Der folgende Quelltext (aus der .NET-Doku kopiert) ist doch überhaupt nicht mehr lesbar, und es gibt Namespaces mit noch viel längeren Namen:
{{Syntax|lang=csharp|border=2|code=
public void InsertRow(string connectionString)
{
    string queryString = &quot;INSERT INTO Dept (DeptNo, Dname, Loc) values (50, 'TECHNOLOGY', 'DENVER')&quot;;
    using (System.Data.OracleClient.OracleConnection connection
        = new System.Data.OracleClient.OracleConnection(connectionString))
    {
        System.Data.OracleClient.OracleCommand command = new System.Data.OracleClient.OracleCommand(queryString);
        // do anything
    }
} }}
Man muss also in der Praxis abwägen. Bei &quot;einfachen&quot; Bezeichnern wie MyModule passt der Ratschlag, aber es gibt eben auch andere Situationen. -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
:Ich finde diesen Code gerade noch lesbar, verstehe das Argument aber sehr gut; insbesondere wenn auf engem Raum sehr viele Bezeichner aus einer fernen Bibliothek benutzt werden, kann das schnell albern und unübersichtlich aussehen. Bei einmaligem Auftreten finde ich das Ausschreiben im Allgemeinen schon recht hilfreich.

:Im engeren Sinne meinte ich aber besonders die Imports mit Wildcards, so wie zum Beispiel:

 import myPackage.*;
 import yourPackage.*;
 
 drawLine ();
 
 Class var = new Class (); /* To which package does Class belong ? */

und ähnliche Fälle. Ich werde das demnächst einmal genauer und etwas umfangreicher formulieren. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)

== For-Schleifen ==

Mit dem was unter &quot;For-Schleifen&quot; steht, bin ich nicht ganz einverstanden bzw. erkenne nicht so ganz die Relevanz. Praktisch jede Programmiersprache, die die dortige Syntax kennt (z.B. C ab C99, C++, Java, C#, D), erlaubt auch ...
  for(int i = 0; i &lt; max; i++)
  {
   ...
  }
... mit dem entscheidenen Vorteil, dass i &quot;so lokal wie möglich ist&quot; (siehe weiter oben unter &quot;Prinzip der Lokalität&quot;), nämlich nur innerhalb des Schleifen-Blocks. Wenn wirklich nur stumpf gezählt wird und die Zähl-Variable danach nicht mehr benötigt wird, sollte immer die For-Schleife den Vorzug bekommen. Zudem würd ich die for-Schleifen noch zum &quot;einfachen Sprachumfang&quot; zählen, da immer sehr einfach und praktisch immer (in der obigen Form) identisch implementiert. Wenn man sich dagegen mal die Regeln für switch/case-Anweisungen vermeintlich ähnlicher Sprachen anguckt ... --[[Spezial:Beiträge/92.196.53.40|92.196.53.40]] 21:51, 26. Mär. 2012 (CEST)

: Zustimmung zu deinen Bedenken. Es sind wohl die Randbedingungen zu beachten: Sofern dasselbe ''i'' vorher oder nachher benutzt wird, kann &lt;tt&gt;for&lt;/tt&gt; durch eine der anderen Schleifen ersetzt werden. Du darfst Text und Gliederung gerne überarbeiten. -- [[Benutzer:Juetho|Jürgen]] 09:04, 27. Mär. 2012 (CEST)
:: Ich würd es eigentlich nur löschen wollen (was ich aber nicht tun werde). Die genannten Argumente überzeugen mich nicht und &quot;... unter Umständen &lt;small&gt;[welchen?]&lt;/small&gt; ... auschließlich ...&quot; spricht auch nicht für eine eindeutigen Standpunkt des Autors. Wenn eine Sprache einen Zählschleifenkonstrukt mitbringt, sollte man es auch nutzen dürfen, denn es macht dem Quellcode-Leser deutlich, dass da nur gezählt wird (möglichst fixe Anzahl und Schrittweite) und nicht auf die Nichterfüllung einer while-Bedingung gewartet wird. --[[Spezial:Beiträge/92.196.30.97|92.196.30.97]] 21:20, 27. Mär. 2012 (CEST)

:::Ich bedanke mich für den wichtigen und richtigen Hinweis zur Lokalität und die Nichtlöschung des Abschnittes. Die Information habe ich mit einer weiteren Ergänzung in das Wikibook eingebaut. --[[Benutzer:Bautsch|Bautsch]] 08:39, 30. Mär. 2012 (CEST)
== Standard-Vorsilben und Bezeichner ==
Bei der Schreibweise von Bezeichnern und Methoden könnte man noch anfügen, dass bestimmte Standard-Vorsilben allgemein üblich sind. '''set'''Foo '''get'''Foo und andere wie '''is'''Foo '''my'''Foo '''del'''Foo '''copy'''Foo recht gebräuchlich. Der Bezug zum Objekt bleibt dadurch gewahrt. Ebenso kann man die Joker (Metasyntaktische Variablen) Foo, Bar, Bas, für den Quellcode erläutern. (z.B. am Beispiel von Parameterlisten). Weiterhin sollten gängige Zählvariablen erläutert werden. Das i und j meist für Iterationen gebraucht werden.  --[[Benutzer:Mjchael|mjchael]] 13:57, 30. Mär. 2012 (CEST)
: my, del und  copy ist mir noch nie untergekommen. Das dürfte auch zu sprachspezifisch werden (ist es teileweise schon jetzt, finde ich). Ab irgendeinem Punkt kann man nur noch auf die Styleguides der einzelnen Sprachen verweisen. --[[Spezial:Beiträge/92.196.71.109|92.196.71.109]] 17:07, 31. Mär. 2012 (CEST)

: Eine kleine Anekdote, die von meinem Vater berichtet wurde, der über 40 Jahre in der Softwareentwicklung tätig war: Als Schleifenzähler wurde &quot;ii&quot; benutzt (doppeltes &quot;i&quot;). Dadurch kann man diese Variable mit der Suchfunktion besser finden als ein einzelnes &quot;i&quot;, das z. B. auch in anderen Variablennamen oder Kommentaren vorkommen kann. – [[Benutzer:Gebu|Gebu]] 17:57, 2. Jul. 2026 (CEST)
::Solche Konstrukte sind bei der Verwendung von Editoren mit &quot;Refactor&quot;-Funktion inzwischen ja nicht mehr notwendig, sofern die Variablen und deren Sichtbarkeitsbereiche strukturiert deklariert worden sind... --[[Benutzer:Bautsch|Bautsch]] 13:57, 3. Jul. 2026 (CEST)

== Leerräume ==

&quot;Leerräume, also zum Beispiel Leerzeichen, Zeilen- und Seitenumbrüche oder Tabulatoren, werden - genauso wie Kommentare - vom Compiler überlesen und dienen daher ausschließlich zur Verbesserung der Lesbarkeit für die Programmierer.&quot; Stimmt das wirklich immer? Zumindest für bestimmte Scriptsprachen trifft es nicht zu. In Python z.B. ist korrekte Einrückung absolut notwendig (siehe [[w:Python (Programmiersprache)#Strukturierung durch Einrücken]]). Ich würde hier zumindest einen entsprechenden Hinweis anbringen, dass es durchaus Ausnahmen geben kann. --[[Benutzer:Versat|Versat]] 09:36, 4. Dez. 2015 (CET)

: Zustimmung zu deinem Hinweis; bei Basic (vermutlich bei allen Dialekten) ist das Zeilenende (also ein einfacher Zeilenumbruch) die Markierung für den Abschluss einer Anweisung. Also ändere es passend. -- [[Benutzer:Juetho|Jürgen]] 10:03, 4. Dez. 2015 (CET)

: Danke für die Hinweise&amp;nbsp;! Ich stimme auch zu, denn auch bei FORTRAN mussten am Zeilenanfang bestimmte Einrückungen eingehalten werden, damit die Lochkarten korrekt gestanzt werden konnten. Ich hatte das verdrängt, und habe den Text jetzt entsprechend geändert. --[[Benutzer:Bautsch|Bautsch]] 16:19, 5. Dez. 2015 (CET)

: Wie ich lese, sind Tabulatoren nicht mehr erwünscht. Statt dessen haben sich vier Leerzeichen durchgesetzt. Das könnte nach einer Prüfung an passender Stelle ins Buch aufgenommen werden. Quelle: Eine Google-Suche nach „Vier Leerzeichen oder Tabulator?“ – [[Benutzer:Gebu|Gebu]] 18:13, 2. Jul. 2026 (CEST)
::Danke für den Hinweis, habe es gerade aktualisiert. Ich kenne übrigens mehrere aktuelle Programmeditoren, die noch TAB-Zeichen unterstützen und verwenden. --[[Benutzer:Bautsch|Bautsch]] 14:13, 3. Jul. 2026 (CEST)
:::Danke! – [[Benutzer:Gebu|Gebu]] 14:28, 3. Jul. 2026 (CEST)

== Beispiele Überladung des Divisionsoperators ==

Huhu, eine Frage wegen den Beispielen in diesem Abschnitt, laut Kommentar sind dort zwei Beispiele für Pascal, ist das nicht eher C, weil die Zuordnung der Werte in Pascal mit := erfolgen, oder? -- [[Benutzer:Zase Wieder|Zase Wieder]] 10:23, 28. Nov. 2023 (CET)

:Ich schätze es handelt sich hier lediglich um einen Flüchtigkeitsfehler. Kommentare und Syntaxhighlight sprechen für das Ziel Pascal. Könnte ja auch sein, dass es Zuweisungen aus dem Programmbeginn sein sollen. Nach der Projektbeschreibung (offensichtlicher Fehler) hab ich mal Doppelpunkte ergänzt. Für den Fall der Fälle: Ping@[[Benutzer:Bautsch|Bautsch]]. Viele Grüße, [[Benutzer:HirnSpuk|HirnSpuk]]&lt;sup&gt;[[Benutzer Diskussion:HirnSpuk|Disk]]&lt;/sup&gt; –  15:39, 28. Nov. 2023 (CET)

::Ich danke Euch beiden, und habe mir auch noch erlaubt, &quot;div&quot; mit kleinen Buchstaben zu schreiben... :-) --[[Benutzer:Bautsch|Bautsch]] 16:50, 28. Nov. 2023 (CET)
:::ich danke auch, nur noch eine Kleinigkeit: die Zuweisungart des Typs ist mir nicht so bekannt, ist es nicht umgekehrt  ''xxx: integer;'' statt ''int xxx;''und erfolgt diese Typenanweisung  nicht „außerhalb“ in der Präambel. Auch scheinen leider unter der Literatur Ihre/Deine Beiträge nicht mehr bei ENISA aufrufbar zu sein, gibt es Alternativen (crises verbessert google zu crisis, ist letzteres gemeint?). Danke im Voraus und danke für die ganzen Kapitel hier auf de.wikibooks.org :). --grüße [[Benutzer:Zase Wieder|Zase Wieder]] 20:45, 12. Dez. 2023 (CET)

== Veraltetes im Kommentar zu Beginn ==

Derzeit im Buch: „Dazu gehören der Dateiname, der Modulname (respektive Klassenname) …“

Beides ist meines Wissens veraltet. Außerdem widerspricht beides dem DRY-Grundsatz („Wiederhole dich nicht.“). In Java müsste beispielsweise bei Änderung des Klassennamens sowohl der Dateiname als auch der Klassenname im Kommentar zu Beginn geändert werden. – [[Benutzer:Gebu|Gebu]] 10:23, 2. Jul. 2026 (CEST)

== Ist der Begriff „Prozeduren“ veraltet? ==

Derzeit im Buch: „… für Methoden (respektive für Prozeduren oder für Funktionen) …“.

Prozeduren gab es mal in der historischen Programmiersprache Pascal. Wird in aktuellen Programmiersprachen noch zwischen Prozedur und Funktion bzw. Methode unterschieden? – [[Benutzer:Gebu|Gebu]] 10:34, 2. Jul. 2026 (CEST)

== Minuszeichen im Beispiel in Component Pascal ==

Derzeit im Buch: „zahl-: LONGINT;“.

Ist hier das Minuszeichen falsch? – [[Benutzer:Gebu|Gebu]] 10:44, 2. Jul. 2026 (CEST)

== Zuweisungskompatibilität / Zeichenketten ==

Derzeit zu sehr auf die Programmiersprache C bezogen. Spätestens seit Java (seit 30 Jahren) überholt. – [[Benutzer:Gebu|Gebu]] 11:10, 2. Jul. 2026 (CEST)</text>
      <sha1>irirc28jk2j0ax98b9lh8tatiibhukx</sha1>
    </revision>
    <revision>
      <id>1088583</id>
      <parentid>1088581</parentid>
      <timestamp>2026-07-03T12:33:37Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <comment>/* Veraltetes im Kommentar zu Beginn */ Antwort</comment>
      <origin>1088583</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="14789" sha1="2s69vtcfeuc503ewl0wnzvbgk51mtya" xml:space="preserve">== Erweiterung ==
Diese Zusammenstellung von Hinweisen gefällt mir. In vielen Lehrbüchern werden immer wieder dieselben Ratschläge benötigt -- hier sind sie als Sammlung zu finden. ''Ich glaube, ich werde auch etwas beitragen.'' -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
:Die Unterstützung würde mich sehr freuen! --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)

Auch die folgenden Themen könnten besprochen werden.
;Untergliederung: Das Buch bekommt inzwischen so viele Einzelthemen, dass eine Gliederung in Bereiche (und damit in eigenständige Kapitel) sinnvoll wäre. ''Ich habe mir darüber noch keine genaueren Gedanken gemacht.'' -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Diese Idee ist mir auch schon gekommen, aber ich habe mir auch noch keine weiteren Gedanken gemacht. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
::: Diese Anleitung nimmt immer mehr Inhalt an (und sobald andere Programmierer es sehen, dürfte noch mehr dazu kommen). Ich empfehle deshalb die Aufteilung in einzelne Kapitel (Seiten); als Hauptthemen geht mir so etwas durch den Kopf (noch nicht als Formulierungen der Kapitel):
:::* Gestaltung von Quelltexten
:::* Konstante, Variable, Bezeichner, Deklaration
:::* Zusammenarbeit zwischen Quelldateien/Modulen/DLLs usw.
:::* Steuerung des Arbeitsablaufs
:::* alles, was zur OOP relevant ist
::: Ich bin mir noch unsicher, ob alle bisherigen Stichpunkte auf diese Weise sinnvoll untergebracht werden. Aber vielleicht kommen wir auf diese Weise zu einer Struktur &amp;ndash; denn um Struktur geht es hier schließlich. {{Smiley|lol}} -- [[Benutzer:Juetho|Jürgen]] 13:32, 6. Jan. 2012 (CET)

;Einrückungen und Zeilenumbruch: Du hast den Code automatisch eingerückt. Das sollte in einem eigenen Punkt erläutert werden. Ein Zeichen ist dafür entschieden zuwenig; man sollte mindestens zwei Zeichen verwenden. Bitte setze aber keine absoluten Regeln fest. Beispielsweise kann man bei diesen [[C++-Programmierung/ Einführung zum Buch/ Konventionen|Konventionen]] unterschiedlicher Meinung sind. Wichtig sind klare Festlegungen innerhalb eines Programms, damit die Struktur auch für neue Leser erkennbar bleibt. (Das hilft auch dem Autor eines Codes, wenn er nach zwei Wochen, Monaten oder Jahren etwas überarbeiten muss.) -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Ich bevorzuge den Tabulator - mehrfache Leerzeichen stammen aus der Zeit der ersten Texteditoren-, aber ich vermute und befürchte, dass dies in der Wiki-Software zur Zeit noch nicht unterstützt wird. Für die Compiler spielt dies keine Rolle, aber dafür umso mehr für die Menschen, die davor sitzen ;-) --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
::: Ich bevorzuge eigentlich ebenfalls Tabs, zumal in der IDE die Tab-Größe in der Regel eingestellt werden kann. Aber beim Kopieren z.B. über Foren geht der eigene Standard verloren; dann sind Leerzeichen besser, weil kompatibler. Mir ist vor allem aufgefallen, dass deine Code-Beispiele nur um ein Zeichen eingerückt sind. Es mag sein, dass das bei dir ein Tab war, und beim Herüberkopieren wurde das zu einem einsamen Leerzeichen. qed -- [[Benutzer:Juetho|Jürgen]] 13:32, 6. Jan. 2012 (CET)

;Deutsch oder Englisch: Ich empfehle, für Bezeichner generell englische Begriffe zu wählen, auch wenn ich die Verwendung der deutschen Sprache im deutschen Sprachraum entschieden bevorzuge. Zur Erläuterung meines Standpunkts (mit Beispielen) siehe [[Arbeiten mit .NET: Allgemeines/ Anhang/ Namenskonventionen#Deutsch oder Englisch?|.NET-Namenskonventionen]]. -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Damit habe ich keine Probleme, zumal ich sowieso vor hatte, das Wikibook ins Englische zu übertragen. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
:::Ich finde deutsche Bezeichner für deutschsprachige Leser verständlicher. Auch die Kommentare sollten meiner Meinung nach deutschsprachig bleiben. – [[Benutzer:Gebu|Gebu]] 17:48, 2. Jul. 2026 (CEST)

Es ist erstaunlich, was einem bei Verbessern noch so alles einfällt. Ich habe einiges vom Diskutierten bereits umgesetzt und bin mir aber bewusst, dass dies alles noch nicht fertig und noch nicht der Weisheit letzter Schluss ist. Die sinnvolle Strukturierung von Artikeln ist mindestens so herausfordernd, wie diejenige von Programmen ;-)  --[[Benutzer:Bautsch|Bautsch]] 12:49, 7. Jan. 2012 (CET)

== Kein Missbrauch bei Imports ==
Ich möchte widersprechen: Es ist kein Missbrauch, wenn &lt;tt&gt;using&lt;/tt&gt; bzw. &lt;tt&gt;imports&lt;/tt&gt; zur Verkürzung des Quellcodes genutzt wird. Gerade bei .NET mit den langen, mehrstufigen Namespace-Bezeichnern macht die ständige Wiederholung des vollständigen Bezeichners den Code sehr unübersichtlich. Der folgende Quelltext (aus der .NET-Doku kopiert) ist doch überhaupt nicht mehr lesbar, und es gibt Namespaces mit noch viel längeren Namen:
{{Syntax|lang=csharp|border=2|code=
public void InsertRow(string connectionString)
{
    string queryString = &quot;INSERT INTO Dept (DeptNo, Dname, Loc) values (50, 'TECHNOLOGY', 'DENVER')&quot;;
    using (System.Data.OracleClient.OracleConnection connection
        = new System.Data.OracleClient.OracleConnection(connectionString))
    {
        System.Data.OracleClient.OracleCommand command = new System.Data.OracleClient.OracleCommand(queryString);
        // do anything
    }
} }}
Man muss also in der Praxis abwägen. Bei &quot;einfachen&quot; Bezeichnern wie MyModule passt der Ratschlag, aber es gibt eben auch andere Situationen. -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
:Ich finde diesen Code gerade noch lesbar, verstehe das Argument aber sehr gut; insbesondere wenn auf engem Raum sehr viele Bezeichner aus einer fernen Bibliothek benutzt werden, kann das schnell albern und unübersichtlich aussehen. Bei einmaligem Auftreten finde ich das Ausschreiben im Allgemeinen schon recht hilfreich.

:Im engeren Sinne meinte ich aber besonders die Imports mit Wildcards, so wie zum Beispiel:

 import myPackage.*;
 import yourPackage.*;
 
 drawLine ();
 
 Class var = new Class (); /* To which package does Class belong ? */

und ähnliche Fälle. Ich werde das demnächst einmal genauer und etwas umfangreicher formulieren. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)

== For-Schleifen ==

Mit dem was unter &quot;For-Schleifen&quot; steht, bin ich nicht ganz einverstanden bzw. erkenne nicht so ganz die Relevanz. Praktisch jede Programmiersprache, die die dortige Syntax kennt (z.B. C ab C99, C++, Java, C#, D), erlaubt auch ...
  for(int i = 0; i &lt; max; i++)
  {
   ...
  }
... mit dem entscheidenen Vorteil, dass i &quot;so lokal wie möglich ist&quot; (siehe weiter oben unter &quot;Prinzip der Lokalität&quot;), nämlich nur innerhalb des Schleifen-Blocks. Wenn wirklich nur stumpf gezählt wird und die Zähl-Variable danach nicht mehr benötigt wird, sollte immer die For-Schleife den Vorzug bekommen. Zudem würd ich die for-Schleifen noch zum &quot;einfachen Sprachumfang&quot; zählen, da immer sehr einfach und praktisch immer (in der obigen Form) identisch implementiert. Wenn man sich dagegen mal die Regeln für switch/case-Anweisungen vermeintlich ähnlicher Sprachen anguckt ... --[[Spezial:Beiträge/92.196.53.40|92.196.53.40]] 21:51, 26. Mär. 2012 (CEST)

: Zustimmung zu deinen Bedenken. Es sind wohl die Randbedingungen zu beachten: Sofern dasselbe ''i'' vorher oder nachher benutzt wird, kann &lt;tt&gt;for&lt;/tt&gt; durch eine der anderen Schleifen ersetzt werden. Du darfst Text und Gliederung gerne überarbeiten. -- [[Benutzer:Juetho|Jürgen]] 09:04, 27. Mär. 2012 (CEST)
:: Ich würd es eigentlich nur löschen wollen (was ich aber nicht tun werde). Die genannten Argumente überzeugen mich nicht und &quot;... unter Umständen &lt;small&gt;[welchen?]&lt;/small&gt; ... auschließlich ...&quot; spricht auch nicht für eine eindeutigen Standpunkt des Autors. Wenn eine Sprache einen Zählschleifenkonstrukt mitbringt, sollte man es auch nutzen dürfen, denn es macht dem Quellcode-Leser deutlich, dass da nur gezählt wird (möglichst fixe Anzahl und Schrittweite) und nicht auf die Nichterfüllung einer while-Bedingung gewartet wird. --[[Spezial:Beiträge/92.196.30.97|92.196.30.97]] 21:20, 27. Mär. 2012 (CEST)

:::Ich bedanke mich für den wichtigen und richtigen Hinweis zur Lokalität und die Nichtlöschung des Abschnittes. Die Information habe ich mit einer weiteren Ergänzung in das Wikibook eingebaut. --[[Benutzer:Bautsch|Bautsch]] 08:39, 30. Mär. 2012 (CEST)
== Standard-Vorsilben und Bezeichner ==
Bei der Schreibweise von Bezeichnern und Methoden könnte man noch anfügen, dass bestimmte Standard-Vorsilben allgemein üblich sind. '''set'''Foo '''get'''Foo und andere wie '''is'''Foo '''my'''Foo '''del'''Foo '''copy'''Foo recht gebräuchlich. Der Bezug zum Objekt bleibt dadurch gewahrt. Ebenso kann man die Joker (Metasyntaktische Variablen) Foo, Bar, Bas, für den Quellcode erläutern. (z.B. am Beispiel von Parameterlisten). Weiterhin sollten gängige Zählvariablen erläutert werden. Das i und j meist für Iterationen gebraucht werden.  --[[Benutzer:Mjchael|mjchael]] 13:57, 30. Mär. 2012 (CEST)
: my, del und  copy ist mir noch nie untergekommen. Das dürfte auch zu sprachspezifisch werden (ist es teileweise schon jetzt, finde ich). Ab irgendeinem Punkt kann man nur noch auf die Styleguides der einzelnen Sprachen verweisen. --[[Spezial:Beiträge/92.196.71.109|92.196.71.109]] 17:07, 31. Mär. 2012 (CEST)

: Eine kleine Anekdote, die von meinem Vater berichtet wurde, der über 40 Jahre in der Softwareentwicklung tätig war: Als Schleifenzähler wurde &quot;ii&quot; benutzt (doppeltes &quot;i&quot;). Dadurch kann man diese Variable mit der Suchfunktion besser finden als ein einzelnes &quot;i&quot;, das z. B. auch in anderen Variablennamen oder Kommentaren vorkommen kann. – [[Benutzer:Gebu|Gebu]] 17:57, 2. Jul. 2026 (CEST)
::Solche Konstrukte sind bei der Verwendung von Editoren mit &quot;Refactor&quot;-Funktion inzwischen ja nicht mehr notwendig, sofern die Variablen und deren Sichtbarkeitsbereiche strukturiert deklariert worden sind... --[[Benutzer:Bautsch|Bautsch]] 13:57, 3. Jul. 2026 (CEST)

== Leerräume ==

&quot;Leerräume, also zum Beispiel Leerzeichen, Zeilen- und Seitenumbrüche oder Tabulatoren, werden - genauso wie Kommentare - vom Compiler überlesen und dienen daher ausschließlich zur Verbesserung der Lesbarkeit für die Programmierer.&quot; Stimmt das wirklich immer? Zumindest für bestimmte Scriptsprachen trifft es nicht zu. In Python z.B. ist korrekte Einrückung absolut notwendig (siehe [[w:Python (Programmiersprache)#Strukturierung durch Einrücken]]). Ich würde hier zumindest einen entsprechenden Hinweis anbringen, dass es durchaus Ausnahmen geben kann. --[[Benutzer:Versat|Versat]] 09:36, 4. Dez. 2015 (CET)

: Zustimmung zu deinem Hinweis; bei Basic (vermutlich bei allen Dialekten) ist das Zeilenende (also ein einfacher Zeilenumbruch) die Markierung für den Abschluss einer Anweisung. Also ändere es passend. -- [[Benutzer:Juetho|Jürgen]] 10:03, 4. Dez. 2015 (CET)

: Danke für die Hinweise&amp;nbsp;! Ich stimme auch zu, denn auch bei FORTRAN mussten am Zeilenanfang bestimmte Einrückungen eingehalten werden, damit die Lochkarten korrekt gestanzt werden konnten. Ich hatte das verdrängt, und habe den Text jetzt entsprechend geändert. --[[Benutzer:Bautsch|Bautsch]] 16:19, 5. Dez. 2015 (CET)

: Wie ich lese, sind Tabulatoren nicht mehr erwünscht. Statt dessen haben sich vier Leerzeichen durchgesetzt. Das könnte nach einer Prüfung an passender Stelle ins Buch aufgenommen werden. Quelle: Eine Google-Suche nach „Vier Leerzeichen oder Tabulator?“ – [[Benutzer:Gebu|Gebu]] 18:13, 2. Jul. 2026 (CEST)
::Danke für den Hinweis, habe es gerade aktualisiert. Ich kenne übrigens mehrere aktuelle Programmeditoren, die noch TAB-Zeichen unterstützen und verwenden. --[[Benutzer:Bautsch|Bautsch]] 14:13, 3. Jul. 2026 (CEST)
:::Danke! – [[Benutzer:Gebu|Gebu]] 14:28, 3. Jul. 2026 (CEST)

== Beispiele Überladung des Divisionsoperators ==

Huhu, eine Frage wegen den Beispielen in diesem Abschnitt, laut Kommentar sind dort zwei Beispiele für Pascal, ist das nicht eher C, weil die Zuordnung der Werte in Pascal mit := erfolgen, oder? -- [[Benutzer:Zase Wieder|Zase Wieder]] 10:23, 28. Nov. 2023 (CET)

:Ich schätze es handelt sich hier lediglich um einen Flüchtigkeitsfehler. Kommentare und Syntaxhighlight sprechen für das Ziel Pascal. Könnte ja auch sein, dass es Zuweisungen aus dem Programmbeginn sein sollen. Nach der Projektbeschreibung (offensichtlicher Fehler) hab ich mal Doppelpunkte ergänzt. Für den Fall der Fälle: Ping@[[Benutzer:Bautsch|Bautsch]]. Viele Grüße, [[Benutzer:HirnSpuk|HirnSpuk]]&lt;sup&gt;[[Benutzer Diskussion:HirnSpuk|Disk]]&lt;/sup&gt; –  15:39, 28. Nov. 2023 (CET)

::Ich danke Euch beiden, und habe mir auch noch erlaubt, &quot;div&quot; mit kleinen Buchstaben zu schreiben... :-) --[[Benutzer:Bautsch|Bautsch]] 16:50, 28. Nov. 2023 (CET)
:::ich danke auch, nur noch eine Kleinigkeit: die Zuweisungart des Typs ist mir nicht so bekannt, ist es nicht umgekehrt  ''xxx: integer;'' statt ''int xxx;''und erfolgt diese Typenanweisung  nicht „außerhalb“ in der Präambel. Auch scheinen leider unter der Literatur Ihre/Deine Beiträge nicht mehr bei ENISA aufrufbar zu sein, gibt es Alternativen (crises verbessert google zu crisis, ist letzteres gemeint?). Danke im Voraus und danke für die ganzen Kapitel hier auf de.wikibooks.org :). --grüße [[Benutzer:Zase Wieder|Zase Wieder]] 20:45, 12. Dez. 2023 (CET)

== Veraltetes im Kommentar zu Beginn ==

Derzeit im Buch: „Dazu gehören der Dateiname, der Modulname (respektive Klassenname) …“

Beides ist meines Wissens veraltet. Außerdem widerspricht beides dem DRY-Grundsatz („Wiederhole dich nicht.“). In Java müsste beispielsweise bei Änderung des Klassennamens sowohl der Dateiname als auch der Klassenname im Kommentar zu Beginn geändert werden. – [[Benutzer:Gebu|Gebu]] 10:23, 2. Jul. 2026 (CEST)

:Da stimme ich uneingeschränkt zu ! Ist ebenfalls geändert. --[[Benutzer:Bautsch|Bautsch]] 14:33, 3. Jul. 2026 (CEST)

== Ist der Begriff „Prozeduren“ veraltet? ==

Derzeit im Buch: „… für Methoden (respektive für Prozeduren oder für Funktionen) …“.

Prozeduren gab es mal in der historischen Programmiersprache Pascal. Wird in aktuellen Programmiersprachen noch zwischen Prozedur und Funktion bzw. Methode unterschieden? – [[Benutzer:Gebu|Gebu]] 10:34, 2. Jul. 2026 (CEST)

== Minuszeichen im Beispiel in Component Pascal ==

Derzeit im Buch: „zahl-: LONGINT;“.

Ist hier das Minuszeichen falsch? – [[Benutzer:Gebu|Gebu]] 10:44, 2. Jul. 2026 (CEST)

== Zuweisungskompatibilität / Zeichenketten ==

Derzeit zu sehr auf die Programmiersprache C bezogen. Spätestens seit Java (seit 30 Jahren) überholt. – [[Benutzer:Gebu|Gebu]] 11:10, 2. Jul. 2026 (CEST)</text>
      <sha1>2s69vtcfeuc503ewl0wnzvbgk51mtya</sha1>
    </revision>
    <revision>
      <id>1088586</id>
      <parentid>1088583</parentid>
      <timestamp>2026-07-03T13:21:06Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <comment>/* Ist der Begriff „Prozeduren“ veraltet? */ Antwort</comment>
      <origin>1088586</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="16385" sha1="hlk2y9ww9dfofcl6ic7pbtei7xcrng6" xml:space="preserve">== Erweiterung ==
Diese Zusammenstellung von Hinweisen gefällt mir. In vielen Lehrbüchern werden immer wieder dieselben Ratschläge benötigt -- hier sind sie als Sammlung zu finden. ''Ich glaube, ich werde auch etwas beitragen.'' -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
:Die Unterstützung würde mich sehr freuen! --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)

Auch die folgenden Themen könnten besprochen werden.
;Untergliederung: Das Buch bekommt inzwischen so viele Einzelthemen, dass eine Gliederung in Bereiche (und damit in eigenständige Kapitel) sinnvoll wäre. ''Ich habe mir darüber noch keine genaueren Gedanken gemacht.'' -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Diese Idee ist mir auch schon gekommen, aber ich habe mir auch noch keine weiteren Gedanken gemacht. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
::: Diese Anleitung nimmt immer mehr Inhalt an (und sobald andere Programmierer es sehen, dürfte noch mehr dazu kommen). Ich empfehle deshalb die Aufteilung in einzelne Kapitel (Seiten); als Hauptthemen geht mir so etwas durch den Kopf (noch nicht als Formulierungen der Kapitel):
:::* Gestaltung von Quelltexten
:::* Konstante, Variable, Bezeichner, Deklaration
:::* Zusammenarbeit zwischen Quelldateien/Modulen/DLLs usw.
:::* Steuerung des Arbeitsablaufs
:::* alles, was zur OOP relevant ist
::: Ich bin mir noch unsicher, ob alle bisherigen Stichpunkte auf diese Weise sinnvoll untergebracht werden. Aber vielleicht kommen wir auf diese Weise zu einer Struktur &amp;ndash; denn um Struktur geht es hier schließlich. {{Smiley|lol}} -- [[Benutzer:Juetho|Jürgen]] 13:32, 6. Jan. 2012 (CET)

;Einrückungen und Zeilenumbruch: Du hast den Code automatisch eingerückt. Das sollte in einem eigenen Punkt erläutert werden. Ein Zeichen ist dafür entschieden zuwenig; man sollte mindestens zwei Zeichen verwenden. Bitte setze aber keine absoluten Regeln fest. Beispielsweise kann man bei diesen [[C++-Programmierung/ Einführung zum Buch/ Konventionen|Konventionen]] unterschiedlicher Meinung sind. Wichtig sind klare Festlegungen innerhalb eines Programms, damit die Struktur auch für neue Leser erkennbar bleibt. (Das hilft auch dem Autor eines Codes, wenn er nach zwei Wochen, Monaten oder Jahren etwas überarbeiten muss.) -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Ich bevorzuge den Tabulator - mehrfache Leerzeichen stammen aus der Zeit der ersten Texteditoren-, aber ich vermute und befürchte, dass dies in der Wiki-Software zur Zeit noch nicht unterstützt wird. Für die Compiler spielt dies keine Rolle, aber dafür umso mehr für die Menschen, die davor sitzen ;-) --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
::: Ich bevorzuge eigentlich ebenfalls Tabs, zumal in der IDE die Tab-Größe in der Regel eingestellt werden kann. Aber beim Kopieren z.B. über Foren geht der eigene Standard verloren; dann sind Leerzeichen besser, weil kompatibler. Mir ist vor allem aufgefallen, dass deine Code-Beispiele nur um ein Zeichen eingerückt sind. Es mag sein, dass das bei dir ein Tab war, und beim Herüberkopieren wurde das zu einem einsamen Leerzeichen. qed -- [[Benutzer:Juetho|Jürgen]] 13:32, 6. Jan. 2012 (CET)

;Deutsch oder Englisch: Ich empfehle, für Bezeichner generell englische Begriffe zu wählen, auch wenn ich die Verwendung der deutschen Sprache im deutschen Sprachraum entschieden bevorzuge. Zur Erläuterung meines Standpunkts (mit Beispielen) siehe [[Arbeiten mit .NET: Allgemeines/ Anhang/ Namenskonventionen#Deutsch oder Englisch?|.NET-Namenskonventionen]]. -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Damit habe ich keine Probleme, zumal ich sowieso vor hatte, das Wikibook ins Englische zu übertragen. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
:::Ich finde deutsche Bezeichner für deutschsprachige Leser verständlicher. Auch die Kommentare sollten meiner Meinung nach deutschsprachig bleiben. – [[Benutzer:Gebu|Gebu]] 17:48, 2. Jul. 2026 (CEST)

Es ist erstaunlich, was einem bei Verbessern noch so alles einfällt. Ich habe einiges vom Diskutierten bereits umgesetzt und bin mir aber bewusst, dass dies alles noch nicht fertig und noch nicht der Weisheit letzter Schluss ist. Die sinnvolle Strukturierung von Artikeln ist mindestens so herausfordernd, wie diejenige von Programmen ;-)  --[[Benutzer:Bautsch|Bautsch]] 12:49, 7. Jan. 2012 (CET)

== Kein Missbrauch bei Imports ==
Ich möchte widersprechen: Es ist kein Missbrauch, wenn &lt;tt&gt;using&lt;/tt&gt; bzw. &lt;tt&gt;imports&lt;/tt&gt; zur Verkürzung des Quellcodes genutzt wird. Gerade bei .NET mit den langen, mehrstufigen Namespace-Bezeichnern macht die ständige Wiederholung des vollständigen Bezeichners den Code sehr unübersichtlich. Der folgende Quelltext (aus der .NET-Doku kopiert) ist doch überhaupt nicht mehr lesbar, und es gibt Namespaces mit noch viel längeren Namen:
{{Syntax|lang=csharp|border=2|code=
public void InsertRow(string connectionString)
{
    string queryString = &quot;INSERT INTO Dept (DeptNo, Dname, Loc) values (50, 'TECHNOLOGY', 'DENVER')&quot;;
    using (System.Data.OracleClient.OracleConnection connection
        = new System.Data.OracleClient.OracleConnection(connectionString))
    {
        System.Data.OracleClient.OracleCommand command = new System.Data.OracleClient.OracleCommand(queryString);
        // do anything
    }
} }}
Man muss also in der Praxis abwägen. Bei &quot;einfachen&quot; Bezeichnern wie MyModule passt der Ratschlag, aber es gibt eben auch andere Situationen. -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
:Ich finde diesen Code gerade noch lesbar, verstehe das Argument aber sehr gut; insbesondere wenn auf engem Raum sehr viele Bezeichner aus einer fernen Bibliothek benutzt werden, kann das schnell albern und unübersichtlich aussehen. Bei einmaligem Auftreten finde ich das Ausschreiben im Allgemeinen schon recht hilfreich.

:Im engeren Sinne meinte ich aber besonders die Imports mit Wildcards, so wie zum Beispiel:

 import myPackage.*;
 import yourPackage.*;
 
 drawLine ();
 
 Class var = new Class (); /* To which package does Class belong ? */

und ähnliche Fälle. Ich werde das demnächst einmal genauer und etwas umfangreicher formulieren. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)

== For-Schleifen ==

Mit dem was unter &quot;For-Schleifen&quot; steht, bin ich nicht ganz einverstanden bzw. erkenne nicht so ganz die Relevanz. Praktisch jede Programmiersprache, die die dortige Syntax kennt (z.B. C ab C99, C++, Java, C#, D), erlaubt auch ...
  for(int i = 0; i &lt; max; i++)
  {
   ...
  }
... mit dem entscheidenen Vorteil, dass i &quot;so lokal wie möglich ist&quot; (siehe weiter oben unter &quot;Prinzip der Lokalität&quot;), nämlich nur innerhalb des Schleifen-Blocks. Wenn wirklich nur stumpf gezählt wird und die Zähl-Variable danach nicht mehr benötigt wird, sollte immer die For-Schleife den Vorzug bekommen. Zudem würd ich die for-Schleifen noch zum &quot;einfachen Sprachumfang&quot; zählen, da immer sehr einfach und praktisch immer (in der obigen Form) identisch implementiert. Wenn man sich dagegen mal die Regeln für switch/case-Anweisungen vermeintlich ähnlicher Sprachen anguckt ... --[[Spezial:Beiträge/92.196.53.40|92.196.53.40]] 21:51, 26. Mär. 2012 (CEST)

: Zustimmung zu deinen Bedenken. Es sind wohl die Randbedingungen zu beachten: Sofern dasselbe ''i'' vorher oder nachher benutzt wird, kann &lt;tt&gt;for&lt;/tt&gt; durch eine der anderen Schleifen ersetzt werden. Du darfst Text und Gliederung gerne überarbeiten. -- [[Benutzer:Juetho|Jürgen]] 09:04, 27. Mär. 2012 (CEST)
:: Ich würd es eigentlich nur löschen wollen (was ich aber nicht tun werde). Die genannten Argumente überzeugen mich nicht und &quot;... unter Umständen &lt;small&gt;[welchen?]&lt;/small&gt; ... auschließlich ...&quot; spricht auch nicht für eine eindeutigen Standpunkt des Autors. Wenn eine Sprache einen Zählschleifenkonstrukt mitbringt, sollte man es auch nutzen dürfen, denn es macht dem Quellcode-Leser deutlich, dass da nur gezählt wird (möglichst fixe Anzahl und Schrittweite) und nicht auf die Nichterfüllung einer while-Bedingung gewartet wird. --[[Spezial:Beiträge/92.196.30.97|92.196.30.97]] 21:20, 27. Mär. 2012 (CEST)

:::Ich bedanke mich für den wichtigen und richtigen Hinweis zur Lokalität und die Nichtlöschung des Abschnittes. Die Information habe ich mit einer weiteren Ergänzung in das Wikibook eingebaut. --[[Benutzer:Bautsch|Bautsch]] 08:39, 30. Mär. 2012 (CEST)
== Standard-Vorsilben und Bezeichner ==
Bei der Schreibweise von Bezeichnern und Methoden könnte man noch anfügen, dass bestimmte Standard-Vorsilben allgemein üblich sind. '''set'''Foo '''get'''Foo und andere wie '''is'''Foo '''my'''Foo '''del'''Foo '''copy'''Foo recht gebräuchlich. Der Bezug zum Objekt bleibt dadurch gewahrt. Ebenso kann man die Joker (Metasyntaktische Variablen) Foo, Bar, Bas, für den Quellcode erläutern. (z.B. am Beispiel von Parameterlisten). Weiterhin sollten gängige Zählvariablen erläutert werden. Das i und j meist für Iterationen gebraucht werden.  --[[Benutzer:Mjchael|mjchael]] 13:57, 30. Mär. 2012 (CEST)
: my, del und  copy ist mir noch nie untergekommen. Das dürfte auch zu sprachspezifisch werden (ist es teileweise schon jetzt, finde ich). Ab irgendeinem Punkt kann man nur noch auf die Styleguides der einzelnen Sprachen verweisen. --[[Spezial:Beiträge/92.196.71.109|92.196.71.109]] 17:07, 31. Mär. 2012 (CEST)

: Eine kleine Anekdote, die von meinem Vater berichtet wurde, der über 40 Jahre in der Softwareentwicklung tätig war: Als Schleifenzähler wurde &quot;ii&quot; benutzt (doppeltes &quot;i&quot;). Dadurch kann man diese Variable mit der Suchfunktion besser finden als ein einzelnes &quot;i&quot;, das z. B. auch in anderen Variablennamen oder Kommentaren vorkommen kann. – [[Benutzer:Gebu|Gebu]] 17:57, 2. Jul. 2026 (CEST)
::Solche Konstrukte sind bei der Verwendung von Editoren mit &quot;Refactor&quot;-Funktion inzwischen ja nicht mehr notwendig, sofern die Variablen und deren Sichtbarkeitsbereiche strukturiert deklariert worden sind... --[[Benutzer:Bautsch|Bautsch]] 13:57, 3. Jul. 2026 (CEST)

== Leerräume ==

&quot;Leerräume, also zum Beispiel Leerzeichen, Zeilen- und Seitenumbrüche oder Tabulatoren, werden - genauso wie Kommentare - vom Compiler überlesen und dienen daher ausschließlich zur Verbesserung der Lesbarkeit für die Programmierer.&quot; Stimmt das wirklich immer? Zumindest für bestimmte Scriptsprachen trifft es nicht zu. In Python z.B. ist korrekte Einrückung absolut notwendig (siehe [[w:Python (Programmiersprache)#Strukturierung durch Einrücken]]). Ich würde hier zumindest einen entsprechenden Hinweis anbringen, dass es durchaus Ausnahmen geben kann. --[[Benutzer:Versat|Versat]] 09:36, 4. Dez. 2015 (CET)

: Zustimmung zu deinem Hinweis; bei Basic (vermutlich bei allen Dialekten) ist das Zeilenende (also ein einfacher Zeilenumbruch) die Markierung für den Abschluss einer Anweisung. Also ändere es passend. -- [[Benutzer:Juetho|Jürgen]] 10:03, 4. Dez. 2015 (CET)

: Danke für die Hinweise&amp;nbsp;! Ich stimme auch zu, denn auch bei FORTRAN mussten am Zeilenanfang bestimmte Einrückungen eingehalten werden, damit die Lochkarten korrekt gestanzt werden konnten. Ich hatte das verdrängt, und habe den Text jetzt entsprechend geändert. --[[Benutzer:Bautsch|Bautsch]] 16:19, 5. Dez. 2015 (CET)

: Wie ich lese, sind Tabulatoren nicht mehr erwünscht. Statt dessen haben sich vier Leerzeichen durchgesetzt. Das könnte nach einer Prüfung an passender Stelle ins Buch aufgenommen werden. Quelle: Eine Google-Suche nach „Vier Leerzeichen oder Tabulator?“ – [[Benutzer:Gebu|Gebu]] 18:13, 2. Jul. 2026 (CEST)
::Danke für den Hinweis, habe es gerade aktualisiert. Ich kenne übrigens mehrere aktuelle Programmeditoren, die noch TAB-Zeichen unterstützen und verwenden. --[[Benutzer:Bautsch|Bautsch]] 14:13, 3. Jul. 2026 (CEST)
:::Danke! – [[Benutzer:Gebu|Gebu]] 14:28, 3. Jul. 2026 (CEST)

== Beispiele Überladung des Divisionsoperators ==

Huhu, eine Frage wegen den Beispielen in diesem Abschnitt, laut Kommentar sind dort zwei Beispiele für Pascal, ist das nicht eher C, weil die Zuordnung der Werte in Pascal mit := erfolgen, oder? -- [[Benutzer:Zase Wieder|Zase Wieder]] 10:23, 28. Nov. 2023 (CET)

:Ich schätze es handelt sich hier lediglich um einen Flüchtigkeitsfehler. Kommentare und Syntaxhighlight sprechen für das Ziel Pascal. Könnte ja auch sein, dass es Zuweisungen aus dem Programmbeginn sein sollen. Nach der Projektbeschreibung (offensichtlicher Fehler) hab ich mal Doppelpunkte ergänzt. Für den Fall der Fälle: Ping@[[Benutzer:Bautsch|Bautsch]]. Viele Grüße, [[Benutzer:HirnSpuk|HirnSpuk]]&lt;sup&gt;[[Benutzer Diskussion:HirnSpuk|Disk]]&lt;/sup&gt; –  15:39, 28. Nov. 2023 (CET)

::Ich danke Euch beiden, und habe mir auch noch erlaubt, &quot;div&quot; mit kleinen Buchstaben zu schreiben... :-) --[[Benutzer:Bautsch|Bautsch]] 16:50, 28. Nov. 2023 (CET)
:::ich danke auch, nur noch eine Kleinigkeit: die Zuweisungart des Typs ist mir nicht so bekannt, ist es nicht umgekehrt  ''xxx: integer;'' statt ''int xxx;''und erfolgt diese Typenanweisung  nicht „außerhalb“ in der Präambel. Auch scheinen leider unter der Literatur Ihre/Deine Beiträge nicht mehr bei ENISA aufrufbar zu sein, gibt es Alternativen (crises verbessert google zu crisis, ist letzteres gemeint?). Danke im Voraus und danke für die ganzen Kapitel hier auf de.wikibooks.org :). --grüße [[Benutzer:Zase Wieder|Zase Wieder]] 20:45, 12. Dez. 2023 (CET)

== Veraltetes im Kommentar zu Beginn ==

Derzeit im Buch: „Dazu gehören der Dateiname, der Modulname (respektive Klassenname) …“

Beides ist meines Wissens veraltet. Außerdem widerspricht beides dem DRY-Grundsatz („Wiederhole dich nicht.“). In Java müsste beispielsweise bei Änderung des Klassennamens sowohl der Dateiname als auch der Klassenname im Kommentar zu Beginn geändert werden. – [[Benutzer:Gebu|Gebu]] 10:23, 2. Jul. 2026 (CEST)

:Da stimme ich uneingeschränkt zu ! Ist ebenfalls geändert. --[[Benutzer:Bautsch|Bautsch]] 14:33, 3. Jul. 2026 (CEST)

== Ist der Begriff „Prozeduren“ veraltet? ==

Derzeit im Buch: „… für Methoden (respektive für Prozeduren oder für Funktionen) …“.

Prozeduren gab es mal in der historischen Programmiersprache Pascal. Wird in aktuellen Programmiersprachen noch zwischen Prozedur und Funktion bzw. Methode unterschieden? – [[Benutzer:Gebu|Gebu]] 10:34, 2. Jul. 2026 (CEST)

:Na ja, &quot;veraltet&quot; würde ich nicht sagen, aber es ist tatsächlich so, dass der Begriff in vielen Programmiersprachen heute gar nicht mehr verwendet wird. Der Begriff &quot;Funktion&quot; ist jedoch keineswegs besser, weil Funktionen in der Mathematik international standardisiert sind, und deren Elemente aus einer Definitionsmenge (in der Programmierung Parameter) stets zugeordnete Elemente in einer Zielmenge (in der Programmierung Rückgabewerte) haben, was in der Programmierung gar nicht immer der Fall ist. Der Begriff &quot;Methode&quot; beschränkt sich wiederum auf die Wiederverwendbarkeit von Programmcode in der objektorientierten Programmierung, was ebenfalls nicht allgemeingültig ist. &quot;Kommandos&quot; liefern wiederum keinen Rückgabewert. Für die Programmgestaltung und die bessere Nachvollziehbarkeit ist es in jedem Fall hilfreich und im Idealfall obligatorisch, die (optionale) Verwendung von Parametern und Rückgabewerten sowie die Wiederverwendbarkeit bei der Objektorientierung zu deklarieren. Wenn man dann keine verschiedenen Begriffe für die entsprechenden Unterprogramme verwenden will, muss man halt immer dazu sagen, ob es Parameter gibt, ob es einen Rückgabewert gibt und ob das Unterprogramm modifiziert werden darf.
:Der allgemeine deutschsprachige Begriff ist &quot;Unterprogramm&quot; (&quot;subroutine&quot;), was in machen Ohren altbacken klingen mag, jedoch nach wie vor ein guter, sinnvoller und allgemein zutreffender Oberbegriff ist. Klingt jedenfalls flüssiger als und nicht so sperrig wie &quot;aufrufbare Einheit&quot; (&quot;callable unit&quot;)... --[[Benutzer:Bautsch|Bautsch]] 15:21, 3. Jul. 2026 (CEST)

== Minuszeichen im Beispiel in Component Pascal ==

Derzeit im Buch: „zahl-: LONGINT;“.

Ist hier das Minuszeichen falsch? – [[Benutzer:Gebu|Gebu]] 10:44, 2. Jul. 2026 (CEST)

== Zuweisungskompatibilität / Zeichenketten ==

Derzeit zu sehr auf die Programmiersprache C bezogen. Spätestens seit Java (seit 30 Jahren) überholt. – [[Benutzer:Gebu|Gebu]] 11:10, 2. Jul. 2026 (CEST)</text>
      <sha1>hlk2y9ww9dfofcl6ic7pbtei7xcrng6</sha1>
    </revision>
    <revision>
      <id>1088587</id>
      <parentid>1088586</parentid>
      <timestamp>2026-07-03T13:23:50Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <comment>/* Minuszeichen im Beispiel in Component Pascal */ Antwort</comment>
      <origin>1088587</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="16586" sha1="n7hiv1r00dqzw3x9ohdase6jld86fy3" xml:space="preserve">== Erweiterung ==
Diese Zusammenstellung von Hinweisen gefällt mir. In vielen Lehrbüchern werden immer wieder dieselben Ratschläge benötigt -- hier sind sie als Sammlung zu finden. ''Ich glaube, ich werde auch etwas beitragen.'' -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
:Die Unterstützung würde mich sehr freuen! --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)

Auch die folgenden Themen könnten besprochen werden.
;Untergliederung: Das Buch bekommt inzwischen so viele Einzelthemen, dass eine Gliederung in Bereiche (und damit in eigenständige Kapitel) sinnvoll wäre. ''Ich habe mir darüber noch keine genaueren Gedanken gemacht.'' -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Diese Idee ist mir auch schon gekommen, aber ich habe mir auch noch keine weiteren Gedanken gemacht. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
::: Diese Anleitung nimmt immer mehr Inhalt an (und sobald andere Programmierer es sehen, dürfte noch mehr dazu kommen). Ich empfehle deshalb die Aufteilung in einzelne Kapitel (Seiten); als Hauptthemen geht mir so etwas durch den Kopf (noch nicht als Formulierungen der Kapitel):
:::* Gestaltung von Quelltexten
:::* Konstante, Variable, Bezeichner, Deklaration
:::* Zusammenarbeit zwischen Quelldateien/Modulen/DLLs usw.
:::* Steuerung des Arbeitsablaufs
:::* alles, was zur OOP relevant ist
::: Ich bin mir noch unsicher, ob alle bisherigen Stichpunkte auf diese Weise sinnvoll untergebracht werden. Aber vielleicht kommen wir auf diese Weise zu einer Struktur &amp;ndash; denn um Struktur geht es hier schließlich. {{Smiley|lol}} -- [[Benutzer:Juetho|Jürgen]] 13:32, 6. Jan. 2012 (CET)

;Einrückungen und Zeilenumbruch: Du hast den Code automatisch eingerückt. Das sollte in einem eigenen Punkt erläutert werden. Ein Zeichen ist dafür entschieden zuwenig; man sollte mindestens zwei Zeichen verwenden. Bitte setze aber keine absoluten Regeln fest. Beispielsweise kann man bei diesen [[C++-Programmierung/ Einführung zum Buch/ Konventionen|Konventionen]] unterschiedlicher Meinung sind. Wichtig sind klare Festlegungen innerhalb eines Programms, damit die Struktur auch für neue Leser erkennbar bleibt. (Das hilft auch dem Autor eines Codes, wenn er nach zwei Wochen, Monaten oder Jahren etwas überarbeiten muss.) -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Ich bevorzuge den Tabulator - mehrfache Leerzeichen stammen aus der Zeit der ersten Texteditoren-, aber ich vermute und befürchte, dass dies in der Wiki-Software zur Zeit noch nicht unterstützt wird. Für die Compiler spielt dies keine Rolle, aber dafür umso mehr für die Menschen, die davor sitzen ;-) --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
::: Ich bevorzuge eigentlich ebenfalls Tabs, zumal in der IDE die Tab-Größe in der Regel eingestellt werden kann. Aber beim Kopieren z.B. über Foren geht der eigene Standard verloren; dann sind Leerzeichen besser, weil kompatibler. Mir ist vor allem aufgefallen, dass deine Code-Beispiele nur um ein Zeichen eingerückt sind. Es mag sein, dass das bei dir ein Tab war, und beim Herüberkopieren wurde das zu einem einsamen Leerzeichen. qed -- [[Benutzer:Juetho|Jürgen]] 13:32, 6. Jan. 2012 (CET)

;Deutsch oder Englisch: Ich empfehle, für Bezeichner generell englische Begriffe zu wählen, auch wenn ich die Verwendung der deutschen Sprache im deutschen Sprachraum entschieden bevorzuge. Zur Erläuterung meines Standpunkts (mit Beispielen) siehe [[Arbeiten mit .NET: Allgemeines/ Anhang/ Namenskonventionen#Deutsch oder Englisch?|.NET-Namenskonventionen]]. -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Damit habe ich keine Probleme, zumal ich sowieso vor hatte, das Wikibook ins Englische zu übertragen. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
:::Ich finde deutsche Bezeichner für deutschsprachige Leser verständlicher. Auch die Kommentare sollten meiner Meinung nach deutschsprachig bleiben. – [[Benutzer:Gebu|Gebu]] 17:48, 2. Jul. 2026 (CEST)

Es ist erstaunlich, was einem bei Verbessern noch so alles einfällt. Ich habe einiges vom Diskutierten bereits umgesetzt und bin mir aber bewusst, dass dies alles noch nicht fertig und noch nicht der Weisheit letzter Schluss ist. Die sinnvolle Strukturierung von Artikeln ist mindestens so herausfordernd, wie diejenige von Programmen ;-)  --[[Benutzer:Bautsch|Bautsch]] 12:49, 7. Jan. 2012 (CET)

== Kein Missbrauch bei Imports ==
Ich möchte widersprechen: Es ist kein Missbrauch, wenn &lt;tt&gt;using&lt;/tt&gt; bzw. &lt;tt&gt;imports&lt;/tt&gt; zur Verkürzung des Quellcodes genutzt wird. Gerade bei .NET mit den langen, mehrstufigen Namespace-Bezeichnern macht die ständige Wiederholung des vollständigen Bezeichners den Code sehr unübersichtlich. Der folgende Quelltext (aus der .NET-Doku kopiert) ist doch überhaupt nicht mehr lesbar, und es gibt Namespaces mit noch viel längeren Namen:
{{Syntax|lang=csharp|border=2|code=
public void InsertRow(string connectionString)
{
    string queryString = &quot;INSERT INTO Dept (DeptNo, Dname, Loc) values (50, 'TECHNOLOGY', 'DENVER')&quot;;
    using (System.Data.OracleClient.OracleConnection connection
        = new System.Data.OracleClient.OracleConnection(connectionString))
    {
        System.Data.OracleClient.OracleCommand command = new System.Data.OracleClient.OracleCommand(queryString);
        // do anything
    }
} }}
Man muss also in der Praxis abwägen. Bei &quot;einfachen&quot; Bezeichnern wie MyModule passt der Ratschlag, aber es gibt eben auch andere Situationen. -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
:Ich finde diesen Code gerade noch lesbar, verstehe das Argument aber sehr gut; insbesondere wenn auf engem Raum sehr viele Bezeichner aus einer fernen Bibliothek benutzt werden, kann das schnell albern und unübersichtlich aussehen. Bei einmaligem Auftreten finde ich das Ausschreiben im Allgemeinen schon recht hilfreich.

:Im engeren Sinne meinte ich aber besonders die Imports mit Wildcards, so wie zum Beispiel:

 import myPackage.*;
 import yourPackage.*;
 
 drawLine ();
 
 Class var = new Class (); /* To which package does Class belong ? */

und ähnliche Fälle. Ich werde das demnächst einmal genauer und etwas umfangreicher formulieren. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)

== For-Schleifen ==

Mit dem was unter &quot;For-Schleifen&quot; steht, bin ich nicht ganz einverstanden bzw. erkenne nicht so ganz die Relevanz. Praktisch jede Programmiersprache, die die dortige Syntax kennt (z.B. C ab C99, C++, Java, C#, D), erlaubt auch ...
  for(int i = 0; i &lt; max; i++)
  {
   ...
  }
... mit dem entscheidenen Vorteil, dass i &quot;so lokal wie möglich ist&quot; (siehe weiter oben unter &quot;Prinzip der Lokalität&quot;), nämlich nur innerhalb des Schleifen-Blocks. Wenn wirklich nur stumpf gezählt wird und die Zähl-Variable danach nicht mehr benötigt wird, sollte immer die For-Schleife den Vorzug bekommen. Zudem würd ich die for-Schleifen noch zum &quot;einfachen Sprachumfang&quot; zählen, da immer sehr einfach und praktisch immer (in der obigen Form) identisch implementiert. Wenn man sich dagegen mal die Regeln für switch/case-Anweisungen vermeintlich ähnlicher Sprachen anguckt ... --[[Spezial:Beiträge/92.196.53.40|92.196.53.40]] 21:51, 26. Mär. 2012 (CEST)

: Zustimmung zu deinen Bedenken. Es sind wohl die Randbedingungen zu beachten: Sofern dasselbe ''i'' vorher oder nachher benutzt wird, kann &lt;tt&gt;for&lt;/tt&gt; durch eine der anderen Schleifen ersetzt werden. Du darfst Text und Gliederung gerne überarbeiten. -- [[Benutzer:Juetho|Jürgen]] 09:04, 27. Mär. 2012 (CEST)
:: Ich würd es eigentlich nur löschen wollen (was ich aber nicht tun werde). Die genannten Argumente überzeugen mich nicht und &quot;... unter Umständen &lt;small&gt;[welchen?]&lt;/small&gt; ... auschließlich ...&quot; spricht auch nicht für eine eindeutigen Standpunkt des Autors. Wenn eine Sprache einen Zählschleifenkonstrukt mitbringt, sollte man es auch nutzen dürfen, denn es macht dem Quellcode-Leser deutlich, dass da nur gezählt wird (möglichst fixe Anzahl und Schrittweite) und nicht auf die Nichterfüllung einer while-Bedingung gewartet wird. --[[Spezial:Beiträge/92.196.30.97|92.196.30.97]] 21:20, 27. Mär. 2012 (CEST)

:::Ich bedanke mich für den wichtigen und richtigen Hinweis zur Lokalität und die Nichtlöschung des Abschnittes. Die Information habe ich mit einer weiteren Ergänzung in das Wikibook eingebaut. --[[Benutzer:Bautsch|Bautsch]] 08:39, 30. Mär. 2012 (CEST)
== Standard-Vorsilben und Bezeichner ==
Bei der Schreibweise von Bezeichnern und Methoden könnte man noch anfügen, dass bestimmte Standard-Vorsilben allgemein üblich sind. '''set'''Foo '''get'''Foo und andere wie '''is'''Foo '''my'''Foo '''del'''Foo '''copy'''Foo recht gebräuchlich. Der Bezug zum Objekt bleibt dadurch gewahrt. Ebenso kann man die Joker (Metasyntaktische Variablen) Foo, Bar, Bas, für den Quellcode erläutern. (z.B. am Beispiel von Parameterlisten). Weiterhin sollten gängige Zählvariablen erläutert werden. Das i und j meist für Iterationen gebraucht werden.  --[[Benutzer:Mjchael|mjchael]] 13:57, 30. Mär. 2012 (CEST)
: my, del und  copy ist mir noch nie untergekommen. Das dürfte auch zu sprachspezifisch werden (ist es teileweise schon jetzt, finde ich). Ab irgendeinem Punkt kann man nur noch auf die Styleguides der einzelnen Sprachen verweisen. --[[Spezial:Beiträge/92.196.71.109|92.196.71.109]] 17:07, 31. Mär. 2012 (CEST)

: Eine kleine Anekdote, die von meinem Vater berichtet wurde, der über 40 Jahre in der Softwareentwicklung tätig war: Als Schleifenzähler wurde &quot;ii&quot; benutzt (doppeltes &quot;i&quot;). Dadurch kann man diese Variable mit der Suchfunktion besser finden als ein einzelnes &quot;i&quot;, das z. B. auch in anderen Variablennamen oder Kommentaren vorkommen kann. – [[Benutzer:Gebu|Gebu]] 17:57, 2. Jul. 2026 (CEST)
::Solche Konstrukte sind bei der Verwendung von Editoren mit &quot;Refactor&quot;-Funktion inzwischen ja nicht mehr notwendig, sofern die Variablen und deren Sichtbarkeitsbereiche strukturiert deklariert worden sind... --[[Benutzer:Bautsch|Bautsch]] 13:57, 3. Jul. 2026 (CEST)

== Leerräume ==

&quot;Leerräume, also zum Beispiel Leerzeichen, Zeilen- und Seitenumbrüche oder Tabulatoren, werden - genauso wie Kommentare - vom Compiler überlesen und dienen daher ausschließlich zur Verbesserung der Lesbarkeit für die Programmierer.&quot; Stimmt das wirklich immer? Zumindest für bestimmte Scriptsprachen trifft es nicht zu. In Python z.B. ist korrekte Einrückung absolut notwendig (siehe [[w:Python (Programmiersprache)#Strukturierung durch Einrücken]]). Ich würde hier zumindest einen entsprechenden Hinweis anbringen, dass es durchaus Ausnahmen geben kann. --[[Benutzer:Versat|Versat]] 09:36, 4. Dez. 2015 (CET)

: Zustimmung zu deinem Hinweis; bei Basic (vermutlich bei allen Dialekten) ist das Zeilenende (also ein einfacher Zeilenumbruch) die Markierung für den Abschluss einer Anweisung. Also ändere es passend. -- [[Benutzer:Juetho|Jürgen]] 10:03, 4. Dez. 2015 (CET)

: Danke für die Hinweise&amp;nbsp;! Ich stimme auch zu, denn auch bei FORTRAN mussten am Zeilenanfang bestimmte Einrückungen eingehalten werden, damit die Lochkarten korrekt gestanzt werden konnten. Ich hatte das verdrängt, und habe den Text jetzt entsprechend geändert. --[[Benutzer:Bautsch|Bautsch]] 16:19, 5. Dez. 2015 (CET)

: Wie ich lese, sind Tabulatoren nicht mehr erwünscht. Statt dessen haben sich vier Leerzeichen durchgesetzt. Das könnte nach einer Prüfung an passender Stelle ins Buch aufgenommen werden. Quelle: Eine Google-Suche nach „Vier Leerzeichen oder Tabulator?“ – [[Benutzer:Gebu|Gebu]] 18:13, 2. Jul. 2026 (CEST)
::Danke für den Hinweis, habe es gerade aktualisiert. Ich kenne übrigens mehrere aktuelle Programmeditoren, die noch TAB-Zeichen unterstützen und verwenden. --[[Benutzer:Bautsch|Bautsch]] 14:13, 3. Jul. 2026 (CEST)
:::Danke! – [[Benutzer:Gebu|Gebu]] 14:28, 3. Jul. 2026 (CEST)

== Beispiele Überladung des Divisionsoperators ==

Huhu, eine Frage wegen den Beispielen in diesem Abschnitt, laut Kommentar sind dort zwei Beispiele für Pascal, ist das nicht eher C, weil die Zuordnung der Werte in Pascal mit := erfolgen, oder? -- [[Benutzer:Zase Wieder|Zase Wieder]] 10:23, 28. Nov. 2023 (CET)

:Ich schätze es handelt sich hier lediglich um einen Flüchtigkeitsfehler. Kommentare und Syntaxhighlight sprechen für das Ziel Pascal. Könnte ja auch sein, dass es Zuweisungen aus dem Programmbeginn sein sollen. Nach der Projektbeschreibung (offensichtlicher Fehler) hab ich mal Doppelpunkte ergänzt. Für den Fall der Fälle: Ping@[[Benutzer:Bautsch|Bautsch]]. Viele Grüße, [[Benutzer:HirnSpuk|HirnSpuk]]&lt;sup&gt;[[Benutzer Diskussion:HirnSpuk|Disk]]&lt;/sup&gt; –  15:39, 28. Nov. 2023 (CET)

::Ich danke Euch beiden, und habe mir auch noch erlaubt, &quot;div&quot; mit kleinen Buchstaben zu schreiben... :-) --[[Benutzer:Bautsch|Bautsch]] 16:50, 28. Nov. 2023 (CET)
:::ich danke auch, nur noch eine Kleinigkeit: die Zuweisungart des Typs ist mir nicht so bekannt, ist es nicht umgekehrt  ''xxx: integer;'' statt ''int xxx;''und erfolgt diese Typenanweisung  nicht „außerhalb“ in der Präambel. Auch scheinen leider unter der Literatur Ihre/Deine Beiträge nicht mehr bei ENISA aufrufbar zu sein, gibt es Alternativen (crises verbessert google zu crisis, ist letzteres gemeint?). Danke im Voraus und danke für die ganzen Kapitel hier auf de.wikibooks.org :). --grüße [[Benutzer:Zase Wieder|Zase Wieder]] 20:45, 12. Dez. 2023 (CET)

== Veraltetes im Kommentar zu Beginn ==

Derzeit im Buch: „Dazu gehören der Dateiname, der Modulname (respektive Klassenname) …“

Beides ist meines Wissens veraltet. Außerdem widerspricht beides dem DRY-Grundsatz („Wiederhole dich nicht.“). In Java müsste beispielsweise bei Änderung des Klassennamens sowohl der Dateiname als auch der Klassenname im Kommentar zu Beginn geändert werden. – [[Benutzer:Gebu|Gebu]] 10:23, 2. Jul. 2026 (CEST)

:Da stimme ich uneingeschränkt zu ! Ist ebenfalls geändert. --[[Benutzer:Bautsch|Bautsch]] 14:33, 3. Jul. 2026 (CEST)

== Ist der Begriff „Prozeduren“ veraltet? ==

Derzeit im Buch: „… für Methoden (respektive für Prozeduren oder für Funktionen) …“.

Prozeduren gab es mal in der historischen Programmiersprache Pascal. Wird in aktuellen Programmiersprachen noch zwischen Prozedur und Funktion bzw. Methode unterschieden? – [[Benutzer:Gebu|Gebu]] 10:34, 2. Jul. 2026 (CEST)

:Na ja, &quot;veraltet&quot; würde ich nicht sagen, aber es ist tatsächlich so, dass der Begriff in vielen Programmiersprachen heute gar nicht mehr verwendet wird. Der Begriff &quot;Funktion&quot; ist jedoch keineswegs besser, weil Funktionen in der Mathematik international standardisiert sind, und deren Elemente aus einer Definitionsmenge (in der Programmierung Parameter) stets zugeordnete Elemente in einer Zielmenge (in der Programmierung Rückgabewerte) haben, was in der Programmierung gar nicht immer der Fall ist. Der Begriff &quot;Methode&quot; beschränkt sich wiederum auf die Wiederverwendbarkeit von Programmcode in der objektorientierten Programmierung, was ebenfalls nicht allgemeingültig ist. &quot;Kommandos&quot; liefern wiederum keinen Rückgabewert. Für die Programmgestaltung und die bessere Nachvollziehbarkeit ist es in jedem Fall hilfreich und im Idealfall obligatorisch, die (optionale) Verwendung von Parametern und Rückgabewerten sowie die Wiederverwendbarkeit bei der Objektorientierung zu deklarieren. Wenn man dann keine verschiedenen Begriffe für die entsprechenden Unterprogramme verwenden will, muss man halt immer dazu sagen, ob es Parameter gibt, ob es einen Rückgabewert gibt und ob das Unterprogramm modifiziert werden darf.
:Der allgemeine deutschsprachige Begriff ist &quot;Unterprogramm&quot; (&quot;subroutine&quot;), was in machen Ohren altbacken klingen mag, jedoch nach wie vor ein guter, sinnvoller und allgemein zutreffender Oberbegriff ist. Klingt jedenfalls flüssiger als und nicht so sperrig wie &quot;aufrufbare Einheit&quot; (&quot;callable unit&quot;)... --[[Benutzer:Bautsch|Bautsch]] 15:21, 3. Jul. 2026 (CEST)

== Minuszeichen im Beispiel in Component Pascal ==

Derzeit im Buch: „zahl-: LONGINT;“.

Ist hier das Minuszeichen falsch? – [[Benutzer:Gebu|Gebu]] 10:44, 2. Jul. 2026 (CEST)

:Nein, in der Kommentarzeile darüber steht die Auflösung: &quot;Die globale Variable &quot;zahl&quot; wird mit dem Zusatz &quot;-&quot; als &quot;read-only&quot; deklariert.&quot; --[[Benutzer:Bautsch|Bautsch]] 15:23, 3. Jul. 2026 (CEST)

== Zuweisungskompatibilität / Zeichenketten ==

Derzeit zu sehr auf die Programmiersprache C bezogen. Spätestens seit Java (seit 30 Jahren) überholt. – [[Benutzer:Gebu|Gebu]] 11:10, 2. Jul. 2026 (CEST)</text>
      <sha1>n7hiv1r00dqzw3x9ohdase6jld86fy3</sha1>
    </revision>
    <revision>
      <id>1088588</id>
      <parentid>1088587</parentid>
      <timestamp>2026-07-03T13:28:03Z</timestamp>
      <contributor>
        <username>Gebu</username>
        <id>27433</id>
      </contributor>
      <comment>/* Minuszeichen im Beispiel in Component Pascal */ Antwort</comment>
      <origin>1088588</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="16675" sha1="bwynyz09lcwxhj28luqbimmw88tfc15" xml:space="preserve">== Erweiterung ==
Diese Zusammenstellung von Hinweisen gefällt mir. In vielen Lehrbüchern werden immer wieder dieselben Ratschläge benötigt -- hier sind sie als Sammlung zu finden. ''Ich glaube, ich werde auch etwas beitragen.'' -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
:Die Unterstützung würde mich sehr freuen! --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)

Auch die folgenden Themen könnten besprochen werden.
;Untergliederung: Das Buch bekommt inzwischen so viele Einzelthemen, dass eine Gliederung in Bereiche (und damit in eigenständige Kapitel) sinnvoll wäre. ''Ich habe mir darüber noch keine genaueren Gedanken gemacht.'' -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Diese Idee ist mir auch schon gekommen, aber ich habe mir auch noch keine weiteren Gedanken gemacht. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
::: Diese Anleitung nimmt immer mehr Inhalt an (und sobald andere Programmierer es sehen, dürfte noch mehr dazu kommen). Ich empfehle deshalb die Aufteilung in einzelne Kapitel (Seiten); als Hauptthemen geht mir so etwas durch den Kopf (noch nicht als Formulierungen der Kapitel):
:::* Gestaltung von Quelltexten
:::* Konstante, Variable, Bezeichner, Deklaration
:::* Zusammenarbeit zwischen Quelldateien/Modulen/DLLs usw.
:::* Steuerung des Arbeitsablaufs
:::* alles, was zur OOP relevant ist
::: Ich bin mir noch unsicher, ob alle bisherigen Stichpunkte auf diese Weise sinnvoll untergebracht werden. Aber vielleicht kommen wir auf diese Weise zu einer Struktur &amp;ndash; denn um Struktur geht es hier schließlich. {{Smiley|lol}} -- [[Benutzer:Juetho|Jürgen]] 13:32, 6. Jan. 2012 (CET)

;Einrückungen und Zeilenumbruch: Du hast den Code automatisch eingerückt. Das sollte in einem eigenen Punkt erläutert werden. Ein Zeichen ist dafür entschieden zuwenig; man sollte mindestens zwei Zeichen verwenden. Bitte setze aber keine absoluten Regeln fest. Beispielsweise kann man bei diesen [[C++-Programmierung/ Einführung zum Buch/ Konventionen|Konventionen]] unterschiedlicher Meinung sind. Wichtig sind klare Festlegungen innerhalb eines Programms, damit die Struktur auch für neue Leser erkennbar bleibt. (Das hilft auch dem Autor eines Codes, wenn er nach zwei Wochen, Monaten oder Jahren etwas überarbeiten muss.) -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Ich bevorzuge den Tabulator - mehrfache Leerzeichen stammen aus der Zeit der ersten Texteditoren-, aber ich vermute und befürchte, dass dies in der Wiki-Software zur Zeit noch nicht unterstützt wird. Für die Compiler spielt dies keine Rolle, aber dafür umso mehr für die Menschen, die davor sitzen ;-) --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
::: Ich bevorzuge eigentlich ebenfalls Tabs, zumal in der IDE die Tab-Größe in der Regel eingestellt werden kann. Aber beim Kopieren z.B. über Foren geht der eigene Standard verloren; dann sind Leerzeichen besser, weil kompatibler. Mir ist vor allem aufgefallen, dass deine Code-Beispiele nur um ein Zeichen eingerückt sind. Es mag sein, dass das bei dir ein Tab war, und beim Herüberkopieren wurde das zu einem einsamen Leerzeichen. qed -- [[Benutzer:Juetho|Jürgen]] 13:32, 6. Jan. 2012 (CET)

;Deutsch oder Englisch: Ich empfehle, für Bezeichner generell englische Begriffe zu wählen, auch wenn ich die Verwendung der deutschen Sprache im deutschen Sprachraum entschieden bevorzuge. Zur Erläuterung meines Standpunkts (mit Beispielen) siehe [[Arbeiten mit .NET: Allgemeines/ Anhang/ Namenskonventionen#Deutsch oder Englisch?|.NET-Namenskonventionen]]. -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Damit habe ich keine Probleme, zumal ich sowieso vor hatte, das Wikibook ins Englische zu übertragen. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
:::Ich finde deutsche Bezeichner für deutschsprachige Leser verständlicher. Auch die Kommentare sollten meiner Meinung nach deutschsprachig bleiben. – [[Benutzer:Gebu|Gebu]] 17:48, 2. Jul. 2026 (CEST)

Es ist erstaunlich, was einem bei Verbessern noch so alles einfällt. Ich habe einiges vom Diskutierten bereits umgesetzt und bin mir aber bewusst, dass dies alles noch nicht fertig und noch nicht der Weisheit letzter Schluss ist. Die sinnvolle Strukturierung von Artikeln ist mindestens so herausfordernd, wie diejenige von Programmen ;-)  --[[Benutzer:Bautsch|Bautsch]] 12:49, 7. Jan. 2012 (CET)

== Kein Missbrauch bei Imports ==
Ich möchte widersprechen: Es ist kein Missbrauch, wenn &lt;tt&gt;using&lt;/tt&gt; bzw. &lt;tt&gt;imports&lt;/tt&gt; zur Verkürzung des Quellcodes genutzt wird. Gerade bei .NET mit den langen, mehrstufigen Namespace-Bezeichnern macht die ständige Wiederholung des vollständigen Bezeichners den Code sehr unübersichtlich. Der folgende Quelltext (aus der .NET-Doku kopiert) ist doch überhaupt nicht mehr lesbar, und es gibt Namespaces mit noch viel längeren Namen:
{{Syntax|lang=csharp|border=2|code=
public void InsertRow(string connectionString)
{
    string queryString = &quot;INSERT INTO Dept (DeptNo, Dname, Loc) values (50, 'TECHNOLOGY', 'DENVER')&quot;;
    using (System.Data.OracleClient.OracleConnection connection
        = new System.Data.OracleClient.OracleConnection(connectionString))
    {
        System.Data.OracleClient.OracleCommand command = new System.Data.OracleClient.OracleCommand(queryString);
        // do anything
    }
} }}
Man muss also in der Praxis abwägen. Bei &quot;einfachen&quot; Bezeichnern wie MyModule passt der Ratschlag, aber es gibt eben auch andere Situationen. -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
:Ich finde diesen Code gerade noch lesbar, verstehe das Argument aber sehr gut; insbesondere wenn auf engem Raum sehr viele Bezeichner aus einer fernen Bibliothek benutzt werden, kann das schnell albern und unübersichtlich aussehen. Bei einmaligem Auftreten finde ich das Ausschreiben im Allgemeinen schon recht hilfreich.

:Im engeren Sinne meinte ich aber besonders die Imports mit Wildcards, so wie zum Beispiel:

 import myPackage.*;
 import yourPackage.*;
 
 drawLine ();
 
 Class var = new Class (); /* To which package does Class belong ? */

und ähnliche Fälle. Ich werde das demnächst einmal genauer und etwas umfangreicher formulieren. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)

== For-Schleifen ==

Mit dem was unter &quot;For-Schleifen&quot; steht, bin ich nicht ganz einverstanden bzw. erkenne nicht so ganz die Relevanz. Praktisch jede Programmiersprache, die die dortige Syntax kennt (z.B. C ab C99, C++, Java, C#, D), erlaubt auch ...
  for(int i = 0; i &lt; max; i++)
  {
   ...
  }
... mit dem entscheidenen Vorteil, dass i &quot;so lokal wie möglich ist&quot; (siehe weiter oben unter &quot;Prinzip der Lokalität&quot;), nämlich nur innerhalb des Schleifen-Blocks. Wenn wirklich nur stumpf gezählt wird und die Zähl-Variable danach nicht mehr benötigt wird, sollte immer die For-Schleife den Vorzug bekommen. Zudem würd ich die for-Schleifen noch zum &quot;einfachen Sprachumfang&quot; zählen, da immer sehr einfach und praktisch immer (in der obigen Form) identisch implementiert. Wenn man sich dagegen mal die Regeln für switch/case-Anweisungen vermeintlich ähnlicher Sprachen anguckt ... --[[Spezial:Beiträge/92.196.53.40|92.196.53.40]] 21:51, 26. Mär. 2012 (CEST)

: Zustimmung zu deinen Bedenken. Es sind wohl die Randbedingungen zu beachten: Sofern dasselbe ''i'' vorher oder nachher benutzt wird, kann &lt;tt&gt;for&lt;/tt&gt; durch eine der anderen Schleifen ersetzt werden. Du darfst Text und Gliederung gerne überarbeiten. -- [[Benutzer:Juetho|Jürgen]] 09:04, 27. Mär. 2012 (CEST)
:: Ich würd es eigentlich nur löschen wollen (was ich aber nicht tun werde). Die genannten Argumente überzeugen mich nicht und &quot;... unter Umständen &lt;small&gt;[welchen?]&lt;/small&gt; ... auschließlich ...&quot; spricht auch nicht für eine eindeutigen Standpunkt des Autors. Wenn eine Sprache einen Zählschleifenkonstrukt mitbringt, sollte man es auch nutzen dürfen, denn es macht dem Quellcode-Leser deutlich, dass da nur gezählt wird (möglichst fixe Anzahl und Schrittweite) und nicht auf die Nichterfüllung einer while-Bedingung gewartet wird. --[[Spezial:Beiträge/92.196.30.97|92.196.30.97]] 21:20, 27. Mär. 2012 (CEST)

:::Ich bedanke mich für den wichtigen und richtigen Hinweis zur Lokalität und die Nichtlöschung des Abschnittes. Die Information habe ich mit einer weiteren Ergänzung in das Wikibook eingebaut. --[[Benutzer:Bautsch|Bautsch]] 08:39, 30. Mär. 2012 (CEST)
== Standard-Vorsilben und Bezeichner ==
Bei der Schreibweise von Bezeichnern und Methoden könnte man noch anfügen, dass bestimmte Standard-Vorsilben allgemein üblich sind. '''set'''Foo '''get'''Foo und andere wie '''is'''Foo '''my'''Foo '''del'''Foo '''copy'''Foo recht gebräuchlich. Der Bezug zum Objekt bleibt dadurch gewahrt. Ebenso kann man die Joker (Metasyntaktische Variablen) Foo, Bar, Bas, für den Quellcode erläutern. (z.B. am Beispiel von Parameterlisten). Weiterhin sollten gängige Zählvariablen erläutert werden. Das i und j meist für Iterationen gebraucht werden.  --[[Benutzer:Mjchael|mjchael]] 13:57, 30. Mär. 2012 (CEST)
: my, del und  copy ist mir noch nie untergekommen. Das dürfte auch zu sprachspezifisch werden (ist es teileweise schon jetzt, finde ich). Ab irgendeinem Punkt kann man nur noch auf die Styleguides der einzelnen Sprachen verweisen. --[[Spezial:Beiträge/92.196.71.109|92.196.71.109]] 17:07, 31. Mär. 2012 (CEST)

: Eine kleine Anekdote, die von meinem Vater berichtet wurde, der über 40 Jahre in der Softwareentwicklung tätig war: Als Schleifenzähler wurde &quot;ii&quot; benutzt (doppeltes &quot;i&quot;). Dadurch kann man diese Variable mit der Suchfunktion besser finden als ein einzelnes &quot;i&quot;, das z. B. auch in anderen Variablennamen oder Kommentaren vorkommen kann. – [[Benutzer:Gebu|Gebu]] 17:57, 2. Jul. 2026 (CEST)
::Solche Konstrukte sind bei der Verwendung von Editoren mit &quot;Refactor&quot;-Funktion inzwischen ja nicht mehr notwendig, sofern die Variablen und deren Sichtbarkeitsbereiche strukturiert deklariert worden sind... --[[Benutzer:Bautsch|Bautsch]] 13:57, 3. Jul. 2026 (CEST)

== Leerräume ==

&quot;Leerräume, also zum Beispiel Leerzeichen, Zeilen- und Seitenumbrüche oder Tabulatoren, werden - genauso wie Kommentare - vom Compiler überlesen und dienen daher ausschließlich zur Verbesserung der Lesbarkeit für die Programmierer.&quot; Stimmt das wirklich immer? Zumindest für bestimmte Scriptsprachen trifft es nicht zu. In Python z.B. ist korrekte Einrückung absolut notwendig (siehe [[w:Python (Programmiersprache)#Strukturierung durch Einrücken]]). Ich würde hier zumindest einen entsprechenden Hinweis anbringen, dass es durchaus Ausnahmen geben kann. --[[Benutzer:Versat|Versat]] 09:36, 4. Dez. 2015 (CET)

: Zustimmung zu deinem Hinweis; bei Basic (vermutlich bei allen Dialekten) ist das Zeilenende (also ein einfacher Zeilenumbruch) die Markierung für den Abschluss einer Anweisung. Also ändere es passend. -- [[Benutzer:Juetho|Jürgen]] 10:03, 4. Dez. 2015 (CET)

: Danke für die Hinweise&amp;nbsp;! Ich stimme auch zu, denn auch bei FORTRAN mussten am Zeilenanfang bestimmte Einrückungen eingehalten werden, damit die Lochkarten korrekt gestanzt werden konnten. Ich hatte das verdrängt, und habe den Text jetzt entsprechend geändert. --[[Benutzer:Bautsch|Bautsch]] 16:19, 5. Dez. 2015 (CET)

: Wie ich lese, sind Tabulatoren nicht mehr erwünscht. Statt dessen haben sich vier Leerzeichen durchgesetzt. Das könnte nach einer Prüfung an passender Stelle ins Buch aufgenommen werden. Quelle: Eine Google-Suche nach „Vier Leerzeichen oder Tabulator?“ – [[Benutzer:Gebu|Gebu]] 18:13, 2. Jul. 2026 (CEST)
::Danke für den Hinweis, habe es gerade aktualisiert. Ich kenne übrigens mehrere aktuelle Programmeditoren, die noch TAB-Zeichen unterstützen und verwenden. --[[Benutzer:Bautsch|Bautsch]] 14:13, 3. Jul. 2026 (CEST)
:::Danke! – [[Benutzer:Gebu|Gebu]] 14:28, 3. Jul. 2026 (CEST)

== Beispiele Überladung des Divisionsoperators ==

Huhu, eine Frage wegen den Beispielen in diesem Abschnitt, laut Kommentar sind dort zwei Beispiele für Pascal, ist das nicht eher C, weil die Zuordnung der Werte in Pascal mit := erfolgen, oder? -- [[Benutzer:Zase Wieder|Zase Wieder]] 10:23, 28. Nov. 2023 (CET)

:Ich schätze es handelt sich hier lediglich um einen Flüchtigkeitsfehler. Kommentare und Syntaxhighlight sprechen für das Ziel Pascal. Könnte ja auch sein, dass es Zuweisungen aus dem Programmbeginn sein sollen. Nach der Projektbeschreibung (offensichtlicher Fehler) hab ich mal Doppelpunkte ergänzt. Für den Fall der Fälle: Ping@[[Benutzer:Bautsch|Bautsch]]. Viele Grüße, [[Benutzer:HirnSpuk|HirnSpuk]]&lt;sup&gt;[[Benutzer Diskussion:HirnSpuk|Disk]]&lt;/sup&gt; –  15:39, 28. Nov. 2023 (CET)

::Ich danke Euch beiden, und habe mir auch noch erlaubt, &quot;div&quot; mit kleinen Buchstaben zu schreiben... :-) --[[Benutzer:Bautsch|Bautsch]] 16:50, 28. Nov. 2023 (CET)
:::ich danke auch, nur noch eine Kleinigkeit: die Zuweisungart des Typs ist mir nicht so bekannt, ist es nicht umgekehrt  ''xxx: integer;'' statt ''int xxx;''und erfolgt diese Typenanweisung  nicht „außerhalb“ in der Präambel. Auch scheinen leider unter der Literatur Ihre/Deine Beiträge nicht mehr bei ENISA aufrufbar zu sein, gibt es Alternativen (crises verbessert google zu crisis, ist letzteres gemeint?). Danke im Voraus und danke für die ganzen Kapitel hier auf de.wikibooks.org :). --grüße [[Benutzer:Zase Wieder|Zase Wieder]] 20:45, 12. Dez. 2023 (CET)

== Veraltetes im Kommentar zu Beginn ==

Derzeit im Buch: „Dazu gehören der Dateiname, der Modulname (respektive Klassenname) …“

Beides ist meines Wissens veraltet. Außerdem widerspricht beides dem DRY-Grundsatz („Wiederhole dich nicht.“). In Java müsste beispielsweise bei Änderung des Klassennamens sowohl der Dateiname als auch der Klassenname im Kommentar zu Beginn geändert werden. – [[Benutzer:Gebu|Gebu]] 10:23, 2. Jul. 2026 (CEST)

:Da stimme ich uneingeschränkt zu ! Ist ebenfalls geändert. --[[Benutzer:Bautsch|Bautsch]] 14:33, 3. Jul. 2026 (CEST)

== Ist der Begriff „Prozeduren“ veraltet? ==

Derzeit im Buch: „… für Methoden (respektive für Prozeduren oder für Funktionen) …“.

Prozeduren gab es mal in der historischen Programmiersprache Pascal. Wird in aktuellen Programmiersprachen noch zwischen Prozedur und Funktion bzw. Methode unterschieden? – [[Benutzer:Gebu|Gebu]] 10:34, 2. Jul. 2026 (CEST)

:Na ja, &quot;veraltet&quot; würde ich nicht sagen, aber es ist tatsächlich so, dass der Begriff in vielen Programmiersprachen heute gar nicht mehr verwendet wird. Der Begriff &quot;Funktion&quot; ist jedoch keineswegs besser, weil Funktionen in der Mathematik international standardisiert sind, und deren Elemente aus einer Definitionsmenge (in der Programmierung Parameter) stets zugeordnete Elemente in einer Zielmenge (in der Programmierung Rückgabewerte) haben, was in der Programmierung gar nicht immer der Fall ist. Der Begriff &quot;Methode&quot; beschränkt sich wiederum auf die Wiederverwendbarkeit von Programmcode in der objektorientierten Programmierung, was ebenfalls nicht allgemeingültig ist. &quot;Kommandos&quot; liefern wiederum keinen Rückgabewert. Für die Programmgestaltung und die bessere Nachvollziehbarkeit ist es in jedem Fall hilfreich und im Idealfall obligatorisch, die (optionale) Verwendung von Parametern und Rückgabewerten sowie die Wiederverwendbarkeit bei der Objektorientierung zu deklarieren. Wenn man dann keine verschiedenen Begriffe für die entsprechenden Unterprogramme verwenden will, muss man halt immer dazu sagen, ob es Parameter gibt, ob es einen Rückgabewert gibt und ob das Unterprogramm modifiziert werden darf.
:Der allgemeine deutschsprachige Begriff ist &quot;Unterprogramm&quot; (&quot;subroutine&quot;), was in machen Ohren altbacken klingen mag, jedoch nach wie vor ein guter, sinnvoller und allgemein zutreffender Oberbegriff ist. Klingt jedenfalls flüssiger als und nicht so sperrig wie &quot;aufrufbare Einheit&quot; (&quot;callable unit&quot;)... --[[Benutzer:Bautsch|Bautsch]] 15:21, 3. Jul. 2026 (CEST)

== Minuszeichen im Beispiel in Component Pascal ==

Derzeit im Buch: „zahl-: LONGINT;“.

Ist hier das Minuszeichen falsch? – [[Benutzer:Gebu|Gebu]] 10:44, 2. Jul. 2026 (CEST)

:Nein, in der Kommentarzeile darüber steht die Auflösung: &quot;Die globale Variable &quot;zahl&quot; wird mit dem Zusatz &quot;-&quot; als &quot;read-only&quot; deklariert.&quot; --[[Benutzer:Bautsch|Bautsch]] 15:23, 3. Jul. 2026 (CEST)
::Danke, das hatte ich übersehen. – [[Benutzer:Gebu|Gebu]] 15:28, 3. Jul. 2026 (CEST)

== Zuweisungskompatibilität / Zeichenketten ==

Derzeit zu sehr auf die Programmiersprache C bezogen. Spätestens seit Java (seit 30 Jahren) überholt. – [[Benutzer:Gebu|Gebu]] 11:10, 2. Jul. 2026 (CEST)</text>
      <sha1>bwynyz09lcwxhj28luqbimmw88tfc15</sha1>
    </revision>
    <revision>
      <id>1088589</id>
      <parentid>1088588</parentid>
      <timestamp>2026-07-03T13:31:00Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <comment>/* Zuweisungskompatibilität / Zeichenketten */ Antwort</comment>
      <origin>1088589</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="17261" sha1="7ymg0n708ggdhd3cf3of8cbqo1n5sn0" xml:space="preserve">== Erweiterung ==
Diese Zusammenstellung von Hinweisen gefällt mir. In vielen Lehrbüchern werden immer wieder dieselben Ratschläge benötigt -- hier sind sie als Sammlung zu finden. ''Ich glaube, ich werde auch etwas beitragen.'' -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
:Die Unterstützung würde mich sehr freuen! --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)

Auch die folgenden Themen könnten besprochen werden.
;Untergliederung: Das Buch bekommt inzwischen so viele Einzelthemen, dass eine Gliederung in Bereiche (und damit in eigenständige Kapitel) sinnvoll wäre. ''Ich habe mir darüber noch keine genaueren Gedanken gemacht.'' -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Diese Idee ist mir auch schon gekommen, aber ich habe mir auch noch keine weiteren Gedanken gemacht. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
::: Diese Anleitung nimmt immer mehr Inhalt an (und sobald andere Programmierer es sehen, dürfte noch mehr dazu kommen). Ich empfehle deshalb die Aufteilung in einzelne Kapitel (Seiten); als Hauptthemen geht mir so etwas durch den Kopf (noch nicht als Formulierungen der Kapitel):
:::* Gestaltung von Quelltexten
:::* Konstante, Variable, Bezeichner, Deklaration
:::* Zusammenarbeit zwischen Quelldateien/Modulen/DLLs usw.
:::* Steuerung des Arbeitsablaufs
:::* alles, was zur OOP relevant ist
::: Ich bin mir noch unsicher, ob alle bisherigen Stichpunkte auf diese Weise sinnvoll untergebracht werden. Aber vielleicht kommen wir auf diese Weise zu einer Struktur &amp;ndash; denn um Struktur geht es hier schließlich. {{Smiley|lol}} -- [[Benutzer:Juetho|Jürgen]] 13:32, 6. Jan. 2012 (CET)

;Einrückungen und Zeilenumbruch: Du hast den Code automatisch eingerückt. Das sollte in einem eigenen Punkt erläutert werden. Ein Zeichen ist dafür entschieden zuwenig; man sollte mindestens zwei Zeichen verwenden. Bitte setze aber keine absoluten Regeln fest. Beispielsweise kann man bei diesen [[C++-Programmierung/ Einführung zum Buch/ Konventionen|Konventionen]] unterschiedlicher Meinung sind. Wichtig sind klare Festlegungen innerhalb eines Programms, damit die Struktur auch für neue Leser erkennbar bleibt. (Das hilft auch dem Autor eines Codes, wenn er nach zwei Wochen, Monaten oder Jahren etwas überarbeiten muss.) -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Ich bevorzuge den Tabulator - mehrfache Leerzeichen stammen aus der Zeit der ersten Texteditoren-, aber ich vermute und befürchte, dass dies in der Wiki-Software zur Zeit noch nicht unterstützt wird. Für die Compiler spielt dies keine Rolle, aber dafür umso mehr für die Menschen, die davor sitzen ;-) --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
::: Ich bevorzuge eigentlich ebenfalls Tabs, zumal in der IDE die Tab-Größe in der Regel eingestellt werden kann. Aber beim Kopieren z.B. über Foren geht der eigene Standard verloren; dann sind Leerzeichen besser, weil kompatibler. Mir ist vor allem aufgefallen, dass deine Code-Beispiele nur um ein Zeichen eingerückt sind. Es mag sein, dass das bei dir ein Tab war, und beim Herüberkopieren wurde das zu einem einsamen Leerzeichen. qed -- [[Benutzer:Juetho|Jürgen]] 13:32, 6. Jan. 2012 (CET)

;Deutsch oder Englisch: Ich empfehle, für Bezeichner generell englische Begriffe zu wählen, auch wenn ich die Verwendung der deutschen Sprache im deutschen Sprachraum entschieden bevorzuge. Zur Erläuterung meines Standpunkts (mit Beispielen) siehe [[Arbeiten mit .NET: Allgemeines/ Anhang/ Namenskonventionen#Deutsch oder Englisch?|.NET-Namenskonventionen]]. -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Damit habe ich keine Probleme, zumal ich sowieso vor hatte, das Wikibook ins Englische zu übertragen. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
:::Ich finde deutsche Bezeichner für deutschsprachige Leser verständlicher. Auch die Kommentare sollten meiner Meinung nach deutschsprachig bleiben. – [[Benutzer:Gebu|Gebu]] 17:48, 2. Jul. 2026 (CEST)

Es ist erstaunlich, was einem bei Verbessern noch so alles einfällt. Ich habe einiges vom Diskutierten bereits umgesetzt und bin mir aber bewusst, dass dies alles noch nicht fertig und noch nicht der Weisheit letzter Schluss ist. Die sinnvolle Strukturierung von Artikeln ist mindestens so herausfordernd, wie diejenige von Programmen ;-)  --[[Benutzer:Bautsch|Bautsch]] 12:49, 7. Jan. 2012 (CET)

== Kein Missbrauch bei Imports ==
Ich möchte widersprechen: Es ist kein Missbrauch, wenn &lt;tt&gt;using&lt;/tt&gt; bzw. &lt;tt&gt;imports&lt;/tt&gt; zur Verkürzung des Quellcodes genutzt wird. Gerade bei .NET mit den langen, mehrstufigen Namespace-Bezeichnern macht die ständige Wiederholung des vollständigen Bezeichners den Code sehr unübersichtlich. Der folgende Quelltext (aus der .NET-Doku kopiert) ist doch überhaupt nicht mehr lesbar, und es gibt Namespaces mit noch viel längeren Namen:
{{Syntax|lang=csharp|border=2|code=
public void InsertRow(string connectionString)
{
    string queryString = &quot;INSERT INTO Dept (DeptNo, Dname, Loc) values (50, 'TECHNOLOGY', 'DENVER')&quot;;
    using (System.Data.OracleClient.OracleConnection connection
        = new System.Data.OracleClient.OracleConnection(connectionString))
    {
        System.Data.OracleClient.OracleCommand command = new System.Data.OracleClient.OracleCommand(queryString);
        // do anything
    }
} }}
Man muss also in der Praxis abwägen. Bei &quot;einfachen&quot; Bezeichnern wie MyModule passt der Ratschlag, aber es gibt eben auch andere Situationen. -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
:Ich finde diesen Code gerade noch lesbar, verstehe das Argument aber sehr gut; insbesondere wenn auf engem Raum sehr viele Bezeichner aus einer fernen Bibliothek benutzt werden, kann das schnell albern und unübersichtlich aussehen. Bei einmaligem Auftreten finde ich das Ausschreiben im Allgemeinen schon recht hilfreich.

:Im engeren Sinne meinte ich aber besonders die Imports mit Wildcards, so wie zum Beispiel:

 import myPackage.*;
 import yourPackage.*;
 
 drawLine ();
 
 Class var = new Class (); /* To which package does Class belong ? */

und ähnliche Fälle. Ich werde das demnächst einmal genauer und etwas umfangreicher formulieren. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)

== For-Schleifen ==

Mit dem was unter &quot;For-Schleifen&quot; steht, bin ich nicht ganz einverstanden bzw. erkenne nicht so ganz die Relevanz. Praktisch jede Programmiersprache, die die dortige Syntax kennt (z.B. C ab C99, C++, Java, C#, D), erlaubt auch ...
  for(int i = 0; i &lt; max; i++)
  {
   ...
  }
... mit dem entscheidenen Vorteil, dass i &quot;so lokal wie möglich ist&quot; (siehe weiter oben unter &quot;Prinzip der Lokalität&quot;), nämlich nur innerhalb des Schleifen-Blocks. Wenn wirklich nur stumpf gezählt wird und die Zähl-Variable danach nicht mehr benötigt wird, sollte immer die For-Schleife den Vorzug bekommen. Zudem würd ich die for-Schleifen noch zum &quot;einfachen Sprachumfang&quot; zählen, da immer sehr einfach und praktisch immer (in der obigen Form) identisch implementiert. Wenn man sich dagegen mal die Regeln für switch/case-Anweisungen vermeintlich ähnlicher Sprachen anguckt ... --[[Spezial:Beiträge/92.196.53.40|92.196.53.40]] 21:51, 26. Mär. 2012 (CEST)

: Zustimmung zu deinen Bedenken. Es sind wohl die Randbedingungen zu beachten: Sofern dasselbe ''i'' vorher oder nachher benutzt wird, kann &lt;tt&gt;for&lt;/tt&gt; durch eine der anderen Schleifen ersetzt werden. Du darfst Text und Gliederung gerne überarbeiten. -- [[Benutzer:Juetho|Jürgen]] 09:04, 27. Mär. 2012 (CEST)
:: Ich würd es eigentlich nur löschen wollen (was ich aber nicht tun werde). Die genannten Argumente überzeugen mich nicht und &quot;... unter Umständen &lt;small&gt;[welchen?]&lt;/small&gt; ... auschließlich ...&quot; spricht auch nicht für eine eindeutigen Standpunkt des Autors. Wenn eine Sprache einen Zählschleifenkonstrukt mitbringt, sollte man es auch nutzen dürfen, denn es macht dem Quellcode-Leser deutlich, dass da nur gezählt wird (möglichst fixe Anzahl und Schrittweite) und nicht auf die Nichterfüllung einer while-Bedingung gewartet wird. --[[Spezial:Beiträge/92.196.30.97|92.196.30.97]] 21:20, 27. Mär. 2012 (CEST)

:::Ich bedanke mich für den wichtigen und richtigen Hinweis zur Lokalität und die Nichtlöschung des Abschnittes. Die Information habe ich mit einer weiteren Ergänzung in das Wikibook eingebaut. --[[Benutzer:Bautsch|Bautsch]] 08:39, 30. Mär. 2012 (CEST)
== Standard-Vorsilben und Bezeichner ==
Bei der Schreibweise von Bezeichnern und Methoden könnte man noch anfügen, dass bestimmte Standard-Vorsilben allgemein üblich sind. '''set'''Foo '''get'''Foo und andere wie '''is'''Foo '''my'''Foo '''del'''Foo '''copy'''Foo recht gebräuchlich. Der Bezug zum Objekt bleibt dadurch gewahrt. Ebenso kann man die Joker (Metasyntaktische Variablen) Foo, Bar, Bas, für den Quellcode erläutern. (z.B. am Beispiel von Parameterlisten). Weiterhin sollten gängige Zählvariablen erläutert werden. Das i und j meist für Iterationen gebraucht werden.  --[[Benutzer:Mjchael|mjchael]] 13:57, 30. Mär. 2012 (CEST)
: my, del und  copy ist mir noch nie untergekommen. Das dürfte auch zu sprachspezifisch werden (ist es teileweise schon jetzt, finde ich). Ab irgendeinem Punkt kann man nur noch auf die Styleguides der einzelnen Sprachen verweisen. --[[Spezial:Beiträge/92.196.71.109|92.196.71.109]] 17:07, 31. Mär. 2012 (CEST)

: Eine kleine Anekdote, die von meinem Vater berichtet wurde, der über 40 Jahre in der Softwareentwicklung tätig war: Als Schleifenzähler wurde &quot;ii&quot; benutzt (doppeltes &quot;i&quot;). Dadurch kann man diese Variable mit der Suchfunktion besser finden als ein einzelnes &quot;i&quot;, das z. B. auch in anderen Variablennamen oder Kommentaren vorkommen kann. – [[Benutzer:Gebu|Gebu]] 17:57, 2. Jul. 2026 (CEST)
::Solche Konstrukte sind bei der Verwendung von Editoren mit &quot;Refactor&quot;-Funktion inzwischen ja nicht mehr notwendig, sofern die Variablen und deren Sichtbarkeitsbereiche strukturiert deklariert worden sind... --[[Benutzer:Bautsch|Bautsch]] 13:57, 3. Jul. 2026 (CEST)

== Leerräume ==

&quot;Leerräume, also zum Beispiel Leerzeichen, Zeilen- und Seitenumbrüche oder Tabulatoren, werden - genauso wie Kommentare - vom Compiler überlesen und dienen daher ausschließlich zur Verbesserung der Lesbarkeit für die Programmierer.&quot; Stimmt das wirklich immer? Zumindest für bestimmte Scriptsprachen trifft es nicht zu. In Python z.B. ist korrekte Einrückung absolut notwendig (siehe [[w:Python (Programmiersprache)#Strukturierung durch Einrücken]]). Ich würde hier zumindest einen entsprechenden Hinweis anbringen, dass es durchaus Ausnahmen geben kann. --[[Benutzer:Versat|Versat]] 09:36, 4. Dez. 2015 (CET)

: Zustimmung zu deinem Hinweis; bei Basic (vermutlich bei allen Dialekten) ist das Zeilenende (also ein einfacher Zeilenumbruch) die Markierung für den Abschluss einer Anweisung. Also ändere es passend. -- [[Benutzer:Juetho|Jürgen]] 10:03, 4. Dez. 2015 (CET)

: Danke für die Hinweise&amp;nbsp;! Ich stimme auch zu, denn auch bei FORTRAN mussten am Zeilenanfang bestimmte Einrückungen eingehalten werden, damit die Lochkarten korrekt gestanzt werden konnten. Ich hatte das verdrängt, und habe den Text jetzt entsprechend geändert. --[[Benutzer:Bautsch|Bautsch]] 16:19, 5. Dez. 2015 (CET)

: Wie ich lese, sind Tabulatoren nicht mehr erwünscht. Statt dessen haben sich vier Leerzeichen durchgesetzt. Das könnte nach einer Prüfung an passender Stelle ins Buch aufgenommen werden. Quelle: Eine Google-Suche nach „Vier Leerzeichen oder Tabulator?“ – [[Benutzer:Gebu|Gebu]] 18:13, 2. Jul. 2026 (CEST)
::Danke für den Hinweis, habe es gerade aktualisiert. Ich kenne übrigens mehrere aktuelle Programmeditoren, die noch TAB-Zeichen unterstützen und verwenden. --[[Benutzer:Bautsch|Bautsch]] 14:13, 3. Jul. 2026 (CEST)
:::Danke! – [[Benutzer:Gebu|Gebu]] 14:28, 3. Jul. 2026 (CEST)

== Beispiele Überladung des Divisionsoperators ==

Huhu, eine Frage wegen den Beispielen in diesem Abschnitt, laut Kommentar sind dort zwei Beispiele für Pascal, ist das nicht eher C, weil die Zuordnung der Werte in Pascal mit := erfolgen, oder? -- [[Benutzer:Zase Wieder|Zase Wieder]] 10:23, 28. Nov. 2023 (CET)

:Ich schätze es handelt sich hier lediglich um einen Flüchtigkeitsfehler. Kommentare und Syntaxhighlight sprechen für das Ziel Pascal. Könnte ja auch sein, dass es Zuweisungen aus dem Programmbeginn sein sollen. Nach der Projektbeschreibung (offensichtlicher Fehler) hab ich mal Doppelpunkte ergänzt. Für den Fall der Fälle: Ping@[[Benutzer:Bautsch|Bautsch]]. Viele Grüße, [[Benutzer:HirnSpuk|HirnSpuk]]&lt;sup&gt;[[Benutzer Diskussion:HirnSpuk|Disk]]&lt;/sup&gt; –  15:39, 28. Nov. 2023 (CET)

::Ich danke Euch beiden, und habe mir auch noch erlaubt, &quot;div&quot; mit kleinen Buchstaben zu schreiben... :-) --[[Benutzer:Bautsch|Bautsch]] 16:50, 28. Nov. 2023 (CET)
:::ich danke auch, nur noch eine Kleinigkeit: die Zuweisungart des Typs ist mir nicht so bekannt, ist es nicht umgekehrt  ''xxx: integer;'' statt ''int xxx;''und erfolgt diese Typenanweisung  nicht „außerhalb“ in der Präambel. Auch scheinen leider unter der Literatur Ihre/Deine Beiträge nicht mehr bei ENISA aufrufbar zu sein, gibt es Alternativen (crises verbessert google zu crisis, ist letzteres gemeint?). Danke im Voraus und danke für die ganzen Kapitel hier auf de.wikibooks.org :). --grüße [[Benutzer:Zase Wieder|Zase Wieder]] 20:45, 12. Dez. 2023 (CET)

== Veraltetes im Kommentar zu Beginn ==

Derzeit im Buch: „Dazu gehören der Dateiname, der Modulname (respektive Klassenname) …“

Beides ist meines Wissens veraltet. Außerdem widerspricht beides dem DRY-Grundsatz („Wiederhole dich nicht.“). In Java müsste beispielsweise bei Änderung des Klassennamens sowohl der Dateiname als auch der Klassenname im Kommentar zu Beginn geändert werden. – [[Benutzer:Gebu|Gebu]] 10:23, 2. Jul. 2026 (CEST)

:Da stimme ich uneingeschränkt zu ! Ist ebenfalls geändert. --[[Benutzer:Bautsch|Bautsch]] 14:33, 3. Jul. 2026 (CEST)

== Ist der Begriff „Prozeduren“ veraltet? ==

Derzeit im Buch: „… für Methoden (respektive für Prozeduren oder für Funktionen) …“.

Prozeduren gab es mal in der historischen Programmiersprache Pascal. Wird in aktuellen Programmiersprachen noch zwischen Prozedur und Funktion bzw. Methode unterschieden? – [[Benutzer:Gebu|Gebu]] 10:34, 2. Jul. 2026 (CEST)

:Na ja, &quot;veraltet&quot; würde ich nicht sagen, aber es ist tatsächlich so, dass der Begriff in vielen Programmiersprachen heute gar nicht mehr verwendet wird. Der Begriff &quot;Funktion&quot; ist jedoch keineswegs besser, weil Funktionen in der Mathematik international standardisiert sind, und deren Elemente aus einer Definitionsmenge (in der Programmierung Parameter) stets zugeordnete Elemente in einer Zielmenge (in der Programmierung Rückgabewerte) haben, was in der Programmierung gar nicht immer der Fall ist. Der Begriff &quot;Methode&quot; beschränkt sich wiederum auf die Wiederverwendbarkeit von Programmcode in der objektorientierten Programmierung, was ebenfalls nicht allgemeingültig ist. &quot;Kommandos&quot; liefern wiederum keinen Rückgabewert. Für die Programmgestaltung und die bessere Nachvollziehbarkeit ist es in jedem Fall hilfreich und im Idealfall obligatorisch, die (optionale) Verwendung von Parametern und Rückgabewerten sowie die Wiederverwendbarkeit bei der Objektorientierung zu deklarieren. Wenn man dann keine verschiedenen Begriffe für die entsprechenden Unterprogramme verwenden will, muss man halt immer dazu sagen, ob es Parameter gibt, ob es einen Rückgabewert gibt und ob das Unterprogramm modifiziert werden darf.
:Der allgemeine deutschsprachige Begriff ist &quot;Unterprogramm&quot; (&quot;subroutine&quot;), was in machen Ohren altbacken klingen mag, jedoch nach wie vor ein guter, sinnvoller und allgemein zutreffender Oberbegriff ist. Klingt jedenfalls flüssiger als und nicht so sperrig wie &quot;aufrufbare Einheit&quot; (&quot;callable unit&quot;)... --[[Benutzer:Bautsch|Bautsch]] 15:21, 3. Jul. 2026 (CEST)

== Minuszeichen im Beispiel in Component Pascal ==

Derzeit im Buch: „zahl-: LONGINT;“.

Ist hier das Minuszeichen falsch? – [[Benutzer:Gebu|Gebu]] 10:44, 2. Jul. 2026 (CEST)

:Nein, in der Kommentarzeile darüber steht die Auflösung: &quot;Die globale Variable &quot;zahl&quot; wird mit dem Zusatz &quot;-&quot; als &quot;read-only&quot; deklariert.&quot; --[[Benutzer:Bautsch|Bautsch]] 15:23, 3. Jul. 2026 (CEST)
::Danke, das hatte ich übersehen. – [[Benutzer:Gebu|Gebu]] 15:28, 3. Jul. 2026 (CEST)

== Zuweisungskompatibilität / Zeichenketten ==

Derzeit zu sehr auf die Programmiersprache C bezogen. Spätestens seit Java (seit 30 Jahren) überholt. – [[Benutzer:Gebu|Gebu]] 11:10, 2. Jul. 2026 (CEST)

:Den Einwand kann ich nicht so recht nachvollziehen. C wird heute noch massiv eingesetzt, beispielsweise bei der Programmierung von Microcontrollern. Da es keine booleschen Werte gibt, kann für logische Werte gar keine Kompatibilität geprüft werden. Zeigervariablen werden nicht auf Zuweisungskompatibilität geprüft, und das betrifft dann leider auch Zeichenketten, die üblicherweise als char [] deklariert wurden. Dies erklärt, warum C so oft als Negativbeispiel herhalten muss, überholt ist das aber auf keinen Fall. --[[Benutzer:Bautsch|Bautsch]] 15:31, 3. Jul. 2026 (CEST)</text>
      <sha1>7ymg0n708ggdhd3cf3of8cbqo1n5sn0</sha1>
    </revision>
    <revision>
      <id>1088593</id>
      <parentid>1088589</parentid>
      <timestamp>2026-07-03T18:25:44Z</timestamp>
      <contributor>
        <username>Gebu</username>
        <id>27433</id>
      </contributor>
      <comment>/* Ist der Begriff „Prozeduren“ veraltet? */ Antwort</comment>
      <origin>1088593</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="17478" sha1="ow2viza4kqkoph12q6zr02ixixwpc3o" xml:space="preserve">== Erweiterung ==
Diese Zusammenstellung von Hinweisen gefällt mir. In vielen Lehrbüchern werden immer wieder dieselben Ratschläge benötigt -- hier sind sie als Sammlung zu finden. ''Ich glaube, ich werde auch etwas beitragen.'' -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
:Die Unterstützung würde mich sehr freuen! --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)

Auch die folgenden Themen könnten besprochen werden.
;Untergliederung: Das Buch bekommt inzwischen so viele Einzelthemen, dass eine Gliederung in Bereiche (und damit in eigenständige Kapitel) sinnvoll wäre. ''Ich habe mir darüber noch keine genaueren Gedanken gemacht.'' -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Diese Idee ist mir auch schon gekommen, aber ich habe mir auch noch keine weiteren Gedanken gemacht. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
::: Diese Anleitung nimmt immer mehr Inhalt an (und sobald andere Programmierer es sehen, dürfte noch mehr dazu kommen). Ich empfehle deshalb die Aufteilung in einzelne Kapitel (Seiten); als Hauptthemen geht mir so etwas durch den Kopf (noch nicht als Formulierungen der Kapitel):
:::* Gestaltung von Quelltexten
:::* Konstante, Variable, Bezeichner, Deklaration
:::* Zusammenarbeit zwischen Quelldateien/Modulen/DLLs usw.
:::* Steuerung des Arbeitsablaufs
:::* alles, was zur OOP relevant ist
::: Ich bin mir noch unsicher, ob alle bisherigen Stichpunkte auf diese Weise sinnvoll untergebracht werden. Aber vielleicht kommen wir auf diese Weise zu einer Struktur &amp;ndash; denn um Struktur geht es hier schließlich. {{Smiley|lol}} -- [[Benutzer:Juetho|Jürgen]] 13:32, 6. Jan. 2012 (CET)

;Einrückungen und Zeilenumbruch: Du hast den Code automatisch eingerückt. Das sollte in einem eigenen Punkt erläutert werden. Ein Zeichen ist dafür entschieden zuwenig; man sollte mindestens zwei Zeichen verwenden. Bitte setze aber keine absoluten Regeln fest. Beispielsweise kann man bei diesen [[C++-Programmierung/ Einführung zum Buch/ Konventionen|Konventionen]] unterschiedlicher Meinung sind. Wichtig sind klare Festlegungen innerhalb eines Programms, damit die Struktur auch für neue Leser erkennbar bleibt. (Das hilft auch dem Autor eines Codes, wenn er nach zwei Wochen, Monaten oder Jahren etwas überarbeiten muss.) -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Ich bevorzuge den Tabulator - mehrfache Leerzeichen stammen aus der Zeit der ersten Texteditoren-, aber ich vermute und befürchte, dass dies in der Wiki-Software zur Zeit noch nicht unterstützt wird. Für die Compiler spielt dies keine Rolle, aber dafür umso mehr für die Menschen, die davor sitzen ;-) --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
::: Ich bevorzuge eigentlich ebenfalls Tabs, zumal in der IDE die Tab-Größe in der Regel eingestellt werden kann. Aber beim Kopieren z.B. über Foren geht der eigene Standard verloren; dann sind Leerzeichen besser, weil kompatibler. Mir ist vor allem aufgefallen, dass deine Code-Beispiele nur um ein Zeichen eingerückt sind. Es mag sein, dass das bei dir ein Tab war, und beim Herüberkopieren wurde das zu einem einsamen Leerzeichen. qed -- [[Benutzer:Juetho|Jürgen]] 13:32, 6. Jan. 2012 (CET)

;Deutsch oder Englisch: Ich empfehle, für Bezeichner generell englische Begriffe zu wählen, auch wenn ich die Verwendung der deutschen Sprache im deutschen Sprachraum entschieden bevorzuge. Zur Erläuterung meines Standpunkts (mit Beispielen) siehe [[Arbeiten mit .NET: Allgemeines/ Anhang/ Namenskonventionen#Deutsch oder Englisch?|.NET-Namenskonventionen]]. -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
::Damit habe ich keine Probleme, zumal ich sowieso vor hatte, das Wikibook ins Englische zu übertragen. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)
:::Ich finde deutsche Bezeichner für deutschsprachige Leser verständlicher. Auch die Kommentare sollten meiner Meinung nach deutschsprachig bleiben. – [[Benutzer:Gebu|Gebu]] 17:48, 2. Jul. 2026 (CEST)

Es ist erstaunlich, was einem bei Verbessern noch so alles einfällt. Ich habe einiges vom Diskutierten bereits umgesetzt und bin mir aber bewusst, dass dies alles noch nicht fertig und noch nicht der Weisheit letzter Schluss ist. Die sinnvolle Strukturierung von Artikeln ist mindestens so herausfordernd, wie diejenige von Programmen ;-)  --[[Benutzer:Bautsch|Bautsch]] 12:49, 7. Jan. 2012 (CET)

== Kein Missbrauch bei Imports ==
Ich möchte widersprechen: Es ist kein Missbrauch, wenn &lt;tt&gt;using&lt;/tt&gt; bzw. &lt;tt&gt;imports&lt;/tt&gt; zur Verkürzung des Quellcodes genutzt wird. Gerade bei .NET mit den langen, mehrstufigen Namespace-Bezeichnern macht die ständige Wiederholung des vollständigen Bezeichners den Code sehr unübersichtlich. Der folgende Quelltext (aus der .NET-Doku kopiert) ist doch überhaupt nicht mehr lesbar, und es gibt Namespaces mit noch viel längeren Namen:
{{Syntax|lang=csharp|border=2|code=
public void InsertRow(string connectionString)
{
    string queryString = &quot;INSERT INTO Dept (DeptNo, Dname, Loc) values (50, 'TECHNOLOGY', 'DENVER')&quot;;
    using (System.Data.OracleClient.OracleConnection connection
        = new System.Data.OracleClient.OracleConnection(connectionString))
    {
        System.Data.OracleClient.OracleCommand command = new System.Data.OracleClient.OracleCommand(queryString);
        // do anything
    }
} }}
Man muss also in der Praxis abwägen. Bei &quot;einfachen&quot; Bezeichnern wie MyModule passt der Ratschlag, aber es gibt eben auch andere Situationen. -- [[Benutzer:Juetho|Jürgen]] 09:28, 5. Jan. 2012 (CET)
:Ich finde diesen Code gerade noch lesbar, verstehe das Argument aber sehr gut; insbesondere wenn auf engem Raum sehr viele Bezeichner aus einer fernen Bibliothek benutzt werden, kann das schnell albern und unübersichtlich aussehen. Bei einmaligem Auftreten finde ich das Ausschreiben im Allgemeinen schon recht hilfreich.

:Im engeren Sinne meinte ich aber besonders die Imports mit Wildcards, so wie zum Beispiel:

 import myPackage.*;
 import yourPackage.*;
 
 drawLine ();
 
 Class var = new Class (); /* To which package does Class belong ? */

und ähnliche Fälle. Ich werde das demnächst einmal genauer und etwas umfangreicher formulieren. --[[Benutzer:Bautsch|Bautsch]] 01:55, 6. Jan. 2012 (CET)

== For-Schleifen ==

Mit dem was unter &quot;For-Schleifen&quot; steht, bin ich nicht ganz einverstanden bzw. erkenne nicht so ganz die Relevanz. Praktisch jede Programmiersprache, die die dortige Syntax kennt (z.B. C ab C99, C++, Java, C#, D), erlaubt auch ...
  for(int i = 0; i &lt; max; i++)
  {
   ...
  }
... mit dem entscheidenen Vorteil, dass i &quot;so lokal wie möglich ist&quot; (siehe weiter oben unter &quot;Prinzip der Lokalität&quot;), nämlich nur innerhalb des Schleifen-Blocks. Wenn wirklich nur stumpf gezählt wird und die Zähl-Variable danach nicht mehr benötigt wird, sollte immer die For-Schleife den Vorzug bekommen. Zudem würd ich die for-Schleifen noch zum &quot;einfachen Sprachumfang&quot; zählen, da immer sehr einfach und praktisch immer (in der obigen Form) identisch implementiert. Wenn man sich dagegen mal die Regeln für switch/case-Anweisungen vermeintlich ähnlicher Sprachen anguckt ... --[[Spezial:Beiträge/92.196.53.40|92.196.53.40]] 21:51, 26. Mär. 2012 (CEST)

: Zustimmung zu deinen Bedenken. Es sind wohl die Randbedingungen zu beachten: Sofern dasselbe ''i'' vorher oder nachher benutzt wird, kann &lt;tt&gt;for&lt;/tt&gt; durch eine der anderen Schleifen ersetzt werden. Du darfst Text und Gliederung gerne überarbeiten. -- [[Benutzer:Juetho|Jürgen]] 09:04, 27. Mär. 2012 (CEST)
:: Ich würd es eigentlich nur löschen wollen (was ich aber nicht tun werde). Die genannten Argumente überzeugen mich nicht und &quot;... unter Umständen &lt;small&gt;[welchen?]&lt;/small&gt; ... auschließlich ...&quot; spricht auch nicht für eine eindeutigen Standpunkt des Autors. Wenn eine Sprache einen Zählschleifenkonstrukt mitbringt, sollte man es auch nutzen dürfen, denn es macht dem Quellcode-Leser deutlich, dass da nur gezählt wird (möglichst fixe Anzahl und Schrittweite) und nicht auf die Nichterfüllung einer while-Bedingung gewartet wird. --[[Spezial:Beiträge/92.196.30.97|92.196.30.97]] 21:20, 27. Mär. 2012 (CEST)

:::Ich bedanke mich für den wichtigen und richtigen Hinweis zur Lokalität und die Nichtlöschung des Abschnittes. Die Information habe ich mit einer weiteren Ergänzung in das Wikibook eingebaut. --[[Benutzer:Bautsch|Bautsch]] 08:39, 30. Mär. 2012 (CEST)
== Standard-Vorsilben und Bezeichner ==
Bei der Schreibweise von Bezeichnern und Methoden könnte man noch anfügen, dass bestimmte Standard-Vorsilben allgemein üblich sind. '''set'''Foo '''get'''Foo und andere wie '''is'''Foo '''my'''Foo '''del'''Foo '''copy'''Foo recht gebräuchlich. Der Bezug zum Objekt bleibt dadurch gewahrt. Ebenso kann man die Joker (Metasyntaktische Variablen) Foo, Bar, Bas, für den Quellcode erläutern. (z.B. am Beispiel von Parameterlisten). Weiterhin sollten gängige Zählvariablen erläutert werden. Das i und j meist für Iterationen gebraucht werden.  --[[Benutzer:Mjchael|mjchael]] 13:57, 30. Mär. 2012 (CEST)
: my, del und  copy ist mir noch nie untergekommen. Das dürfte auch zu sprachspezifisch werden (ist es teileweise schon jetzt, finde ich). Ab irgendeinem Punkt kann man nur noch auf die Styleguides der einzelnen Sprachen verweisen. --[[Spezial:Beiträge/92.196.71.109|92.196.71.109]] 17:07, 31. Mär. 2012 (CEST)

: Eine kleine Anekdote, die von meinem Vater berichtet wurde, der über 40 Jahre in der Softwareentwicklung tätig war: Als Schleifenzähler wurde &quot;ii&quot; benutzt (doppeltes &quot;i&quot;). Dadurch kann man diese Variable mit der Suchfunktion besser finden als ein einzelnes &quot;i&quot;, das z. B. auch in anderen Variablennamen oder Kommentaren vorkommen kann. – [[Benutzer:Gebu|Gebu]] 17:57, 2. Jul. 2026 (CEST)
::Solche Konstrukte sind bei der Verwendung von Editoren mit &quot;Refactor&quot;-Funktion inzwischen ja nicht mehr notwendig, sofern die Variablen und deren Sichtbarkeitsbereiche strukturiert deklariert worden sind... --[[Benutzer:Bautsch|Bautsch]] 13:57, 3. Jul. 2026 (CEST)

== Leerräume ==

&quot;Leerräume, also zum Beispiel Leerzeichen, Zeilen- und Seitenumbrüche oder Tabulatoren, werden - genauso wie Kommentare - vom Compiler überlesen und dienen daher ausschließlich zur Verbesserung der Lesbarkeit für die Programmierer.&quot; Stimmt das wirklich immer? Zumindest für bestimmte Scriptsprachen trifft es nicht zu. In Python z.B. ist korrekte Einrückung absolut notwendig (siehe [[w:Python (Programmiersprache)#Strukturierung durch Einrücken]]). Ich würde hier zumindest einen entsprechenden Hinweis anbringen, dass es durchaus Ausnahmen geben kann. --[[Benutzer:Versat|Versat]] 09:36, 4. Dez. 2015 (CET)

: Zustimmung zu deinem Hinweis; bei Basic (vermutlich bei allen Dialekten) ist das Zeilenende (also ein einfacher Zeilenumbruch) die Markierung für den Abschluss einer Anweisung. Also ändere es passend. -- [[Benutzer:Juetho|Jürgen]] 10:03, 4. Dez. 2015 (CET)

: Danke für die Hinweise&amp;nbsp;! Ich stimme auch zu, denn auch bei FORTRAN mussten am Zeilenanfang bestimmte Einrückungen eingehalten werden, damit die Lochkarten korrekt gestanzt werden konnten. Ich hatte das verdrängt, und habe den Text jetzt entsprechend geändert. --[[Benutzer:Bautsch|Bautsch]] 16:19, 5. Dez. 2015 (CET)

: Wie ich lese, sind Tabulatoren nicht mehr erwünscht. Statt dessen haben sich vier Leerzeichen durchgesetzt. Das könnte nach einer Prüfung an passender Stelle ins Buch aufgenommen werden. Quelle: Eine Google-Suche nach „Vier Leerzeichen oder Tabulator?“ – [[Benutzer:Gebu|Gebu]] 18:13, 2. Jul. 2026 (CEST)
::Danke für den Hinweis, habe es gerade aktualisiert. Ich kenne übrigens mehrere aktuelle Programmeditoren, die noch TAB-Zeichen unterstützen und verwenden. --[[Benutzer:Bautsch|Bautsch]] 14:13, 3. Jul. 2026 (CEST)
:::Danke! – [[Benutzer:Gebu|Gebu]] 14:28, 3. Jul. 2026 (CEST)

== Beispiele Überladung des Divisionsoperators ==

Huhu, eine Frage wegen den Beispielen in diesem Abschnitt, laut Kommentar sind dort zwei Beispiele für Pascal, ist das nicht eher C, weil die Zuordnung der Werte in Pascal mit := erfolgen, oder? -- [[Benutzer:Zase Wieder|Zase Wieder]] 10:23, 28. Nov. 2023 (CET)

:Ich schätze es handelt sich hier lediglich um einen Flüchtigkeitsfehler. Kommentare und Syntaxhighlight sprechen für das Ziel Pascal. Könnte ja auch sein, dass es Zuweisungen aus dem Programmbeginn sein sollen. Nach der Projektbeschreibung (offensichtlicher Fehler) hab ich mal Doppelpunkte ergänzt. Für den Fall der Fälle: Ping@[[Benutzer:Bautsch|Bautsch]]. Viele Grüße, [[Benutzer:HirnSpuk|HirnSpuk]]&lt;sup&gt;[[Benutzer Diskussion:HirnSpuk|Disk]]&lt;/sup&gt; –  15:39, 28. Nov. 2023 (CET)

::Ich danke Euch beiden, und habe mir auch noch erlaubt, &quot;div&quot; mit kleinen Buchstaben zu schreiben... :-) --[[Benutzer:Bautsch|Bautsch]] 16:50, 28. Nov. 2023 (CET)
:::ich danke auch, nur noch eine Kleinigkeit: die Zuweisungart des Typs ist mir nicht so bekannt, ist es nicht umgekehrt  ''xxx: integer;'' statt ''int xxx;''und erfolgt diese Typenanweisung  nicht „außerhalb“ in der Präambel. Auch scheinen leider unter der Literatur Ihre/Deine Beiträge nicht mehr bei ENISA aufrufbar zu sein, gibt es Alternativen (crises verbessert google zu crisis, ist letzteres gemeint?). Danke im Voraus und danke für die ganzen Kapitel hier auf de.wikibooks.org :). --grüße [[Benutzer:Zase Wieder|Zase Wieder]] 20:45, 12. Dez. 2023 (CET)

== Veraltetes im Kommentar zu Beginn ==

Derzeit im Buch: „Dazu gehören der Dateiname, der Modulname (respektive Klassenname) …“

Beides ist meines Wissens veraltet. Außerdem widerspricht beides dem DRY-Grundsatz („Wiederhole dich nicht.“). In Java müsste beispielsweise bei Änderung des Klassennamens sowohl der Dateiname als auch der Klassenname im Kommentar zu Beginn geändert werden. – [[Benutzer:Gebu|Gebu]] 10:23, 2. Jul. 2026 (CEST)

:Da stimme ich uneingeschränkt zu ! Ist ebenfalls geändert. --[[Benutzer:Bautsch|Bautsch]] 14:33, 3. Jul. 2026 (CEST)

== Ist der Begriff „Prozeduren“ veraltet? ==

Derzeit im Buch: „… für Methoden (respektive für Prozeduren oder für Funktionen) …“.

Prozeduren gab es mal in der historischen Programmiersprache Pascal. Wird in aktuellen Programmiersprachen noch zwischen Prozedur und Funktion bzw. Methode unterschieden? – [[Benutzer:Gebu|Gebu]] 10:34, 2. Jul. 2026 (CEST)

:Na ja, &quot;veraltet&quot; würde ich nicht sagen, aber es ist tatsächlich so, dass der Begriff in vielen Programmiersprachen heute gar nicht mehr verwendet wird. Der Begriff &quot;Funktion&quot; ist jedoch keineswegs besser, weil Funktionen in der Mathematik international standardisiert sind, und deren Elemente aus einer Definitionsmenge (in der Programmierung Parameter) stets zugeordnete Elemente in einer Zielmenge (in der Programmierung Rückgabewerte) haben, was in der Programmierung gar nicht immer der Fall ist. Der Begriff &quot;Methode&quot; beschränkt sich wiederum auf die Wiederverwendbarkeit von Programmcode in der objektorientierten Programmierung, was ebenfalls nicht allgemeingültig ist. &quot;Kommandos&quot; liefern wiederum keinen Rückgabewert. Für die Programmgestaltung und die bessere Nachvollziehbarkeit ist es in jedem Fall hilfreich und im Idealfall obligatorisch, die (optionale) Verwendung von Parametern und Rückgabewerten sowie die Wiederverwendbarkeit bei der Objektorientierung zu deklarieren. Wenn man dann keine verschiedenen Begriffe für die entsprechenden Unterprogramme verwenden will, muss man halt immer dazu sagen, ob es Parameter gibt, ob es einen Rückgabewert gibt und ob das Unterprogramm modifiziert werden darf.
:Der allgemeine deutschsprachige Begriff ist &quot;Unterprogramm&quot; (&quot;subroutine&quot;), was in machen Ohren altbacken klingen mag, jedoch nach wie vor ein guter, sinnvoller und allgemein zutreffender Oberbegriff ist. Klingt jedenfalls flüssiger als und nicht so sperrig wie &quot;aufrufbare Einheit&quot; (&quot;callable unit&quot;)... --[[Benutzer:Bautsch|Bautsch]] 15:21, 3. Jul. 2026 (CEST)
::Ich finde den Begriff „Unterprogramm“ nicht altbacken. Er wird beispielsweise in der aktuellen Auflage des Fachbuchs „Java ist auch eine Insel“ benutzt. – [[Benutzer:Gebu|Gebu]] 20:25, 3. Jul. 2026 (CEST)

== Minuszeichen im Beispiel in Component Pascal ==

Derzeit im Buch: „zahl-: LONGINT;“.

Ist hier das Minuszeichen falsch? – [[Benutzer:Gebu|Gebu]] 10:44, 2. Jul. 2026 (CEST)

:Nein, in der Kommentarzeile darüber steht die Auflösung: &quot;Die globale Variable &quot;zahl&quot; wird mit dem Zusatz &quot;-&quot; als &quot;read-only&quot; deklariert.&quot; --[[Benutzer:Bautsch|Bautsch]] 15:23, 3. Jul. 2026 (CEST)
::Danke, das hatte ich übersehen. – [[Benutzer:Gebu|Gebu]] 15:28, 3. Jul. 2026 (CEST)

== Zuweisungskompatibilität / Zeichenketten ==

Derzeit zu sehr auf die Programmiersprache C bezogen. Spätestens seit Java (seit 30 Jahren) überholt. – [[Benutzer:Gebu|Gebu]] 11:10, 2. Jul. 2026 (CEST)

:Den Einwand kann ich nicht so recht nachvollziehen. C wird heute noch massiv eingesetzt, beispielsweise bei der Programmierung von Microcontrollern. Da es keine booleschen Werte gibt, kann für logische Werte gar keine Kompatibilität geprüft werden. Zeigervariablen werden nicht auf Zuweisungskompatibilität geprüft, und das betrifft dann leider auch Zeichenketten, die üblicherweise als char [] deklariert wurden. Dies erklärt, warum C so oft als Negativbeispiel herhalten muss, überholt ist das aber auf keinen Fall. --[[Benutzer:Bautsch|Bautsch]] 15:31, 3. Jul. 2026 (CEST)</text>
      <sha1>ow2viza4kqkoph12q6zr02ixixwpc3o</sha1>
    </revision>
  </page>
  <page>
    <title>Traktorenlexikon: Foton Lovol</title>
    <ns>0</ns>
    <id>91138</id>
    <revision>
      <id>1088594</id>
      <parentid>966943</parentid>
      <timestamp>2026-07-03T20:30:12Z</timestamp>
      <contributor>
        <username>Middle Distance Biker 39</username>
        <id>103785</id>
      </contributor>
      <minor />
      <comment>/* Arbos */ Typo</comment>
      <origin>1088594</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="3979" sha1="ee0e9zl94qdgdgnpzqxutj7dj3lsvcz" xml:space="preserve">{{:Traktorenlexikon: Navigation}}

Foton Lovol ist ein Fahrzeug- und Motorenhersteller aus China.

Der Internetauftritt zu Beginn 2018 scheint darauf hinzuweisen das die Produkte wie Traktoren und Erntemaschinen nur noch Lovol heissen sollen. Jedenfalls steht nur noch '''Lovol''' auf der Motorhaube bei aktuellen Bildern.&lt;ref&gt;http://www.fotonlovol.com/products/AgricultureEquipment.htm&lt;/ref&gt;

==Geschichte==
'''1988''' Gründung in China, damals noch unter teilweiser staatlicher Regie

'''1996''' Begin der Traktorproduktion, erst mit relativ kleinen Modellen für den chinesischen Markt 

'''2015''' Foton Lovol übernimmt den italienischen Hersteller [[Traktorenlexikon: Goldoni|Goldoni]]&lt;ref&gt;https://www.topagrar.com/news/Technik-Techniknews-Chinesischer-Landmaschinenkonzern-setzt-Fuss-nach-Europa-2603473.html&lt;/ref&gt;

'''2015''' Auf der Agritechnica stellt Foton Lovol [[Traktorenlexikon: Arbos|Arbos]] als wiederbelebte Marke speziell für den europäischen Markt vor. Ebenfalls 2015 wurde [[Traktorenlexikon: Goldoni|Goldoni]] aufgekauft.

==Typen==

Foton Lovol produziert 12 Traktorserien mit mehr als 5000 verschiedene Modellvarianten. Mehr als 700 Produktsparten werden weltweit exportiert.

Die Leistung der Traktoren bewegt sich zwischen 25 und 185 PS. Die Traktoren sind sowohl für den Hobbylandwirt als auch für den professionellen Agrarbetrieb geeignet.

===Foton Lovol===
Aktuell steht bei diesen Modellen nur '''Lovol''' auf der Motorhaube und die Modellbezeichnung.&lt;ref&gt;http://www.fotonlovol.com/products/Tractors.htm&lt;/ref&gt;

Es wurden bzw. werden Schlepper mit folgenden Typenbezeichnungen vertrieben:
====TE====
* {{:Traktorenlexikon: Create|TE-254}}
* {{:Traktorenlexikon: Create|TE-354}}

====TB====
Die hintere Ziffer bei der Modellnummer bedeutet: 0 = Hinterradversion &lt;=&gt; 4 = Allrad
* {{:Traktorenlexikon: Create|TB-354E}}
* {{:Traktorenlexikon: Create|TB-404}}
* {{:Traktorenlexikon: Create|TB-454}}
* {{:Traktorenlexikon: Create|TB-504}}
* {{:Traktorenlexikon: Create|TB-604}}

====TG====
Die grossen Traktoren dieser Marke:
* {{:Traktorenlexikon: Create|TE-1254}}
* {{:Traktorenlexikon: Create|TE-1454}}
* {{:Traktorenlexikon: Create|TE-1654}}
* {{:Traktorenlexikon: Create|TE-1854}}

====TA====
Diese Baureihe ist relativ &quot;einfach&quot; ausgestattet.
Die hintere Ziffer bei der Modellnummer bedeutet: 0 = Hinterradversion &lt;=&gt; 4 = Allrad
* {{:Traktorenlexikon: Create|TA-604E}}
* {{:Traktorenlexikon: Create|TA-654E}}
* {{:Traktorenlexikon: Create|TA-704E}}
* {{:Traktorenlexikon: Create|TA-754E}}

====TD====
Diese Baureihe ist im Vergleich zur TA-Baureihe relativ komfortabel ausgestattet.
Die hintere Ziffer bei der Modellnummer bedeutet: 0 = Hinterradversion &lt;=&gt; 4 = Allrad
* {{:Traktorenlexikon: Create|TD-820}}
* {{:Traktorenlexikon: Create|TD-900}}

===Arbos===
Die ersten Traktoren dieser wiederbelebten Marke konnte man 2015 auf der Agritechnica sehen:
====Serie 5000====
* {{:Traktorenlexikon: Create|Arbos 5100}}
* {{:Traktorenlexikon: Create|Arbos 5115}}
* {{:Traktorenlexikon: Create|Arbos 5130}}

====Serie 3000====
Kompakte, wendige Traktoren für z.B. Gewächshäuser. Man sieht den Einfluss von Goldoni.
* {{:Traktorenlexikon: Create|Arbos 3040}}
* {{:Traktorenlexikon: Create|Arbos 3050}}

====Serie 4000====
Kompakte, wendige Modelle z.B. für den Wein- und Obstanbau.
* {{:Traktorenlexikon: Create|Arbos 4060}}
* {{:Traktorenlexikon: Create|Arbos 4080}}

* {{:Traktorenlexikon: Create|Arbos 4090}}
* {{:Traktorenlexikon: Create|Arbos 4100}}
* {{:Traktorenlexikon: Create|Arbos 4110}}

Kompakte, wendige Knickschlepper z.B. für den Wein- und Obstanbau.
* {{:Traktorenlexikon: Create|Arbos 4070 E}}
* {{:Traktorenlexikon: Create|Arbos 4080 E}}
* {{:Traktorenlexikon: Create|Arbos 4090 E}}
* {{:Traktorenlexikon: Create|Arbos 4100 E}}

== Weblinks ==

* [http://www.fotonlovol.com www.fotonlovol.com]
* [http://www.foton-traktor.com www.foton-traktor.com]
* [http://arbos.com/products/tractors Arbos]

{{:Traktorenlexikon: Navigation}}</text>
      <sha1>ee0e9zl94qdgdgnpzqxutj7dj3lsvcz</sha1>
    </revision>
  </page>
  <page>
    <title>Astronomie von der Frühgeschichte bis zur Neuzeit/ Die Himmelstafel von Tal-Qadi</title>
    <ns>0</ns>
    <id>109600</id>
    <revision>
      <id>1088597</id>
      <parentid>1086682</parentid>
      <timestamp>2026-07-04T08:30:46Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <comment>/* Ähnliche archäologische Objekte */ Rückseite Stele</comment>
      <origin>1088597</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="104285" sha1="sqnmajh1j69tic81cieoquzjy90bsxl" xml:space="preserve">&lt;noinclude&gt;
{{:Die Himmelstafel von Tal-Qadi/ Navigation}}
{{Druckversion}}
&lt;/noinclude&gt;
[[Datei:Stone from Tal-Qadi Temple, National Museum of Archaeology, Valletta 001.jpg|mini|hochkant=2|Die Himmelstafel von Tal-Qadi in einer Vitrine des ''National Museum of Archaeology'' in Valletta (Malta).]]
[[Datei:Massstaebliche.Replik.Himmelstafel.Tal-Qadi.Buchenholz.jpg|mini|hochkant=2|Maßstäbliche Replik der Himmelstafel von Tal-Qadi aus Buchenholz.]]
[[Datei:Himmelstafel-Tal-Qadi-eingepasst.P1022936.png|mini|hochkant=2|In den Sternenhimmel eingepasste Himmelstafel von Tal-Qadi mit Lage der Ekliptik.]]
[[Datei:Astronomer.Tal-qadi.sky.tablet.png|mini|rechts|hochkant=2|Animiertes Bild eines Astronomen auf Malta, der vor 4500 Jahren die Himmelstafel von Tal-Qadi in Richtung des untergehenden Sternbilds Stier hält.]]

Dieses Kapitel befasst sich aus astronomischer Sicht mit dem archäologischen Fund einer zirka 4500&amp;nbsp;Jahre alten Kalksteintafel aus Malta, auf der ein Ausschnitt des Sternenhimmels dargestellt sein könnte.

Die beschriebenen Untersuchungen verfolgen zwei Haupthypothesen:

# Auf der '''Himmelstafel von Tal-Qadi''' sind Ausschnitte des Sternenhimmels dargestellt.
# Die fünf fächerartig dargestellten Segmente zeigen einen zusammenhängenden Ausschnitt des Sternenhimmels (von links nach rechts):
## Teile des heutigen Sternbilds '''Orion'''.
## Den Kopf des Stieres im heutigen Sternbild '''Stier''' (Taurus).
## Der Bogen der '''Ekliptik''' über dem Horizont.
## Den offenen Sternhaufen der '''Plejaden''' (das Siebengestirn).
## Die hellsten Sterne, die am östlichen Horizont vor den Plejaden aufgehen.

Unabhängig von diesen unbeweisbaren Hypothesen, wird in diesem Beitrag nachgewiesen, dass die im Sternbild Stier (Taurus) am Goldenen Tor der Ekliptik ausgerichtete Himmelstafel von Tal-Qadi heute genauso wie vor Jahrtausenden unmittelbar zur Vermessung der ekliptikalen Breite von Mond und Planeten verwendet werden kann. Mit Hilfe derartiger Beobachtungen lassen sich nicht nur die siderische und drakonitische Periode des Mondes sowie der Meton-Zyklus bestimmen, sondern auch Sternbedeckungen (insbesondere von Siebengestirn, Aldebaran und Regulus) sowie Mond- und Sonnenfinsternisse untersuchen und langfristig vorhersagen.

Zusammen mit anderen Befunden geben die Darstellungen auf der Himmelstafel von Tal-Qadi zahlreiche Hinweise darauf, dass die neolithischen Bewohner der Insel Malta bereits über herausragende astronomische Kenntnisse und Fähigkeiten verfügt haben dürften.

==Vorrede==
Die Sterne haben in den Mythen aller Völker und zu allen Zeiten eine herausragende Stellung eingenommen. Sie wurden häufig als sich offenbarende Erscheinungsformen beziehungsweise als die himmlischen „Standorte“ von Gottheiten betrachtet. Im Altertum und selbst noch das Mittelalter hindurch bis zur Renaissance konnte der Mensch den Nachthimmel lediglich mit bloßem Auge betrachten. Dabei konnte jedoch schon festgestellt werden, dass die ungefähr 5000 sichtbaren Fixsterne untereinander eine ewig feststehende geometrische Konstellation bilden, nur dass zu verschiedenen Tages- und Jahreszeiten immer ein etwas anderer Ausschnitt des Universums zu sehen ist. Während die Sterne des Fixsternhimmels für die Navigation von Seefahrern oder von Wüstenwanderern von großer Bedeutung waren, wurden die gegenüber dem Fixsternhimmel beweglichen Himmelsobjekte häufig für astrologische Ausdeutungen herangezogen.

Der Anblick unserer Galaxis, der '''Milchstraße''', der der benachbarten '''Andromedagalaxie''' oder der offenen Sternhaufen, allen voran die '''Plejaden (Messier 45)''', aber auch die '''Hyaden''', die '''Krippe (Praesepe, Messier 44)''' oder der '''Doppelsternhaufen h&amp;nbsp;Persei und χ&amp;nbsp;Persei''', wurde sicherlich immer schon als geheimnisvoll erfahren. Auch hell und farbig leuchtende Sterne wie die Roten Riesen '''Aldebaran''', '''Antares''', '''Arktur''', '''Beteigeuze''' oder '''Pollux''' sowie bläuliche Sterne wie '''Spica''' oder '''Wega''' oder der hellste und somit am stärksten farbig szintillierende Stern '''Sirius''' waren schon immer besonders auffällig. Die hellsten Fixsterne sind an wenigen Händen abzählbar und konnten nicht nur verhältnismäßig leicht ins Gedächtnis eingeprägt werden, sondern erhielten zur Identifikation oder für die Kommunikation mit anderen Menschen sogar Eigennamen.

Zu den besonderen, jedoch weitgehend unregelmäßigen Erscheinungen am Himmel zählen neben den Meteoren (inklusive der Photometeore, der Elektrometeore, der Lithometeore und der Hydrometeore) auch Supernovae und Kometen.&lt;ref&gt;Fernando Coimbra: ''The Sky on the Rocks - Cometary Images in Rock Art'', in: ''11/ Prehistoric art: signs, symbols, myth, ideology - Arte Pré-histórica: signos, simbolos, mitos, ideologia'', Congresso Internacional da IFRAO 2009, Piauí, Brasil&lt;/ref&gt; Im Mittel war in den letzten 2000&amp;nbsp;Jahren ungefähr alle 200&amp;nbsp;Jahre eine Supernova mit bloßem Auge zu sehen. Der Komet Halley ist in China bereits im Jahr&amp;nbsp;240 vor Christus belegt.&lt;ref&gt;[http://www.astrocorner.de/index/02_wissen/01_kosmologie/01_sonnensystem/06_kometen/1p.php Halley (1986) - Begleiter der Jahrhunderte], Astro Corner&lt;/ref&gt; Der vorletzte Periheldurchgang des langperiodischen Kometen C2020 F3 (NEOWISE) dürfte beispielsweise während des Neolithikums stattgefunden haben. Es gab also immer wieder auch heute oft noch unvorhersagbare Ereignisse, wie das Auftreten von Novae, Kometen oder Sternschnuppen, die von den vielen Kulturen mythisch verarbeitet wurden. Hierzu gehören des Weiteren sicherlich auch die zahlreichen und vielfältigen atmosphärischen Erscheinungen, wie zum Beispiel Halos und Nebensonnen, ausbrechende Geysire, Aschewolken von Vulkanausbrüchen oder Polarlichter. Polarlichter sind zwar mit abnehmendem Breitengrad immer seltener zu beobachten, jedoch sind diese gelegentlich auch im Mittelmeerraum zu sehen, und es gibt auch entsprechende historische Berichte wie über das Carrington-Ereignis Anfang September 1859 oder sogar aus Babylonien.&lt;ref&gt;F. Richard Stephenson, David M. Willis, Thomas J. Hallinan: [https://academic.oup.com/astrogeo/article/45/6/6.15/216214 The earliest datable observation of the aurora borealis], Astronomy &amp; Geophysics, Volume 45, Issue 6, December 2004, Pages 6.15–6.17&lt;/ref&gt;&lt;ref&gt;Vergleiche hierzu auch [https://www.bibleserver.com/EU/Hesekiel1 Hesekiel 1], Einheitsübersetzung, bibleserver.com&lt;/ref&gt;

Beim regelmäßigen Betrachten des Nachthimmels fiel den ersten Menschen gewiss schon auf, dass '''sieben besondere Wandelgestirne''' sich mehr oder weniger regelhaft und immerwährend gegenüber dem Fixsternhimmel bewegen, allen voran die '''Sonne''' und der '''Mond''', aber auch die fünf Planeten '''Merkur''', '''Venus''', '''Mars''', '''Jupiter''' und '''Saturn'''.

→ Siehe auch '''[[Quadriviale Kuriositäten‎/ Zahlen#Zur Sieben|Exkurs „Zur Sieben“]]'''.

Im Laufe der Zeit ziehen die Wandelgestirne entlang der Ekliptiklinie einmal mehr und einmal weniger dicht an Fixsternen vorbei und ziehen dabei auch durch Asterismen, bei denen von den Beobachtern sicherlich schon seit vielen Jahrtausenden benachbarte Sterne geometrisch in Verbindung gebracht wurden, um sie leichter wiedererkennen zu können.

→ Siehe auch '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische Bezugssysteme#Die Ekliptik|Exkurs „Die Ekliptik“]]'''.

Manchmal treffen sich sogar zwei oder sogar mehrere von diesen Wandelgestirnen bei einer '''Konjunktion''' scheinbar an einer Stelle des Himmels. Auch deren scheinbare Begegnung mit ekliptiknahen Sternen oder sogar deren Bedeckung hat immer wieder die Aufmerksamkeit von Beobachtern erregt. So erwähnt zum Beispiel Aristoteles (*&amp;nbsp;384 vor Christus; †&amp;nbsp;322 vor Christus) in seiner Schrift „Meteorologikon“ (altgriechisch: ''Μετεωρολογικῶν''), dass er 360 vor Christus die scheinbare Verschmelzung vom Planeten Jupiter und einem Stern im Sternbild Zwillinge (Gemini) beobachtet hat, ohne dass dabei ein Komet entstanden sei.

→ Siehe auch '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Aristotelische_Jupiter-Konjunktion|Abschnitt „Aristotelische Jupiter-Konjunktion“]]'''.

Auf der geografischen Breite von Malta gab es bei Abwesenheit von moderner Lichtverschmutzung aufgrund des trockenen und ausgeglichenen Klimas sehr gute astronomische Beobachtungsbedingungen. Das wurde auch Ende des 18.&amp;nbsp;Jahrhunderts in einem Brief an den französischen Astronomen Jérôme de Lalande (1732–1807) dokumentiert, als der Naturforscher Déodat Gratet de Dolomieu (1750–1801) den dort tätigen Großmeister des Malteserordens, Emmanuel de Rohan-Polduc (1725–1797), überzeugte, ein Sternenobservatorium zu errichten.&lt;ref&gt;Frank Ventura: ''Grand Master de Rohan's astronomical observatory (1783-1789)'', in: ''Melita Historica'', New Series, 10, 3, Seiten 245 bis 255, 1990&lt;/ref&gt; Dort konnten regelmäßig Mondfinsternisse, aber immer wieder auch totale Sonnenfinsternisse beobachtet werden, wie zum Beispiel mit hoher Wahrscheinlichkeit die Sonnenfinsternis in den Morgenstunden vom 18.&amp;nbsp;Mai 2146 vor Christus.&lt;ref&gt;Rita Gautschy: [http://www.gautschy.ch/~rita/archast/solec/PLOTS/2150v/solec-21460518.png solar eclipse -2146/05/18], Kanon der Sonnenfinsternisse von 2501 vor Christus bis 1000 nach Christus, Version 2.0, Januar 2012&lt;/ref&gt;

→ Siehe auch '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen|Exkurs „Konjunktionen“]]'''.

Leider sind nicht viele solcher astronomischen Ereignisse und Sachverhalte schriftlich festgehalten worden, oder sie harren noch ihrer Entdeckung und Entschlüsselung. Es darf aber davon ausgegangen werden, dass in interessierten und unterrichteten Kreisen eine mündliche Tradierung von Wissen stattfand, sicherlich auch in den mehr oder weniger geheimen Kreisen von Priestern oder zum Beispiel auch bei den Kelten, die lange Zeit keine Schriftzeichen verwendeten. Auch schon lange bevor die Notenschrift mit adiastematischen Neumen erfunden wurde, konnten komponierte Melodien über viele Generationen weitergegeben werden. Durch den Vergleich der frühen Handschriften von geographisch weit entfernten Orten ergibt sich, dass die Reproduktion dieser Melodien aus der Erinnerung der Schreiber erstaunlich zuverlässig funktioniert hat. Verschiedene Urfassungen der Odyssee von Homer wurden jahrhundertelang durch Sänger vorgetragen und rein mündlich überliefert. Im Mittelalter konnten viele Mönche alle 150 Psalmen des Psalters auswendig rezitieren. Aus der Tatsache, dass nirgends aufgeschrieben wurde, dass die spätmittelalterlichen Folianten für den Gebrauch im Chor von Kirchen so groß beschriftet werden mussten, damit nicht nur mehrere Sänger gleichzeitig, sondern auch altersweitsichtige Sänger aus größerer Distanz die Texte und Noten überhaupt noch lesen konnten, kann nicht geschlossen werden, dass dies keine Rolle gespielt hat. Für solche Analysen müssen möglichst viele Indizien ermittelt und Hypothesen geprüft werden, ohne dass letztlich ein Beweis erbracht werden kann. Umgekehrt darf auch bei bekannten Schriftzeugnissen nicht immer davon ausgegangen werden, dass sie Tatsachen entsprechen - sie können unzuverlässiger sein als eine mündliche Überlieferung.

Die intelligenten Menschen des Altertums waren sicherlich nicht wesentlich weniger verständig als wir es heute sind, sie wussten damals nur erheblich weniger über abstrakte Zusammenhänge in der Natur. Das scheinbar merkwürdige, mystische und damals noch völlig unerklärliche Verhalten der Wandelgestirne fesselte mit Gewissheit schon im Altertum einige unserer Vorfahren, und viele Mythen sind daraus schließlich erwachsen. Erst viel später in der Neuzeit konnten die physikalischen Zusammenhänge in der Himmelsmechanik gefunden und beschrieben werden. Durch die Erfindung des optischen Fernrohrs vor gut 300&amp;nbsp;Jahren erfolgte ein sprunghafter Erkenntnisgewinn. Aber auch durch die natürliche Betrachtung der Verhältnisse am Himmel konnten bereits lange vorher zahlreiche beachtenswerte Sachverhalte erkannt und für die Beschreibung der Welt oder sogar für nützliche Vorhersagen verwendet werden. Diese reale Weltanschauung hatte zusammen mit dem über Generationen überlieferten Wissen der Vorfahren gewiss einen erheblichen Einfluss auf die kulturelle und gesellschaftliche Entwicklung, sei es, dass Kalender implementiert wurden oder mythischer Glaube zu Religionen zusammengeführt wurde oder beides in Kombination passierte.

Zwischen den Disziplinen '''Astronomie''' (altgriechisch ''ἄστρον'' und ''νόμος'' = ''Sterngesetz'') und '''Astrologie''' (altgriechisch ''ἄστρον'' und ''λόγος'' = ''Sternlehre'') gab es im Altertum selbst bis zur Renaissance noch gar keinen Unterschied. Durch die langfristige und regelmäßige Beobachtung des Sternenhimmels ergab sich ein Erkenntnisgewinn, und nur hierdurch entstand die Möglichkeit, Kalender zu führen oder bestimmte Konstellationen vorhersagen zu können. Daraus konnten sich ein entsprechendes mathematisches Vorstellungsvermögen und eine geometrische Ordnung entwickeln, die für lange Zeit allerdings weitgehend nur mündlich überliefert wurden und denen heute daher nur mühsam und freilich immer nur unvollkommen in den zahlreichen verschiedenen Traditionen nachgespürt werden kann. Es ist in diesem Kontext wenig verwunderlich, dass die '''Astronomie''' im Mittelalter zusammen mit der '''Arithmetik''', der '''Geometrie''' und der '''Musik''' zu den vier freien Künsten des '''Quadriviums''' gehörte.

→ Siehe auch '''[[Quadriviale Kuriositäten]]'''.

Die Vorgänge am Himmel sind in der Tat nach wie vor recht abstrakt und komplex sowie nur mit umfassendem Wissen zu verstehen und miteinander in Bezug zu bringen. Leider geht dieses Wissen heute bei vielen Menschen zunehmend verloren, da der Nachthimmel durch die starke '''Lichtverschmutzung''' kaum noch eine umfassende und regelmäßige Beobachtung zulässt, so dass das Interesse an diesen Vorgängen entsprechend abnimmt. Vielleicht tragen diese Ausführungen hier dazu bei, dass dieses Interesse geweckt wird oder bereits vorhandene Kenntnisse vertieft werden können.

Die '''Archäoastronomie''' ist eine junge Wissenschaft, die sich insbesondere im deutschsprachigen Raum noch kaum etablieren konnte. Eventuell tragen die hier dargestellten Ergebnisse auch dazu bei, diese Disziplin ein wenig voranzubringen sowie interessierten Kreisen die astronomischen Grundlagen für die Einordnung von archäoastronomischen Sachverhalten näher zu bringen und hierfür wichtige Aspekte darzustellen. Diese Abhandlung legt den Schwerpunkt daher weniger auf die archäologischen Aspekte des Fundes, sondern stellt vielmehr den Versuch dar, die Darstellungen auf der Steintafel ausgehend von den bisherigen Befunden aus astronomischer, geometrischer und geographischer Sichtweise zu interpretieren. Eventuell kann sie auf diese Weise dazu beitragen, den Fund in einen erweiterten Kontext einzuordnen.

Anhand der seit Jahrtausenden ohne Fernrohre in freier Natur zu beobachtenden Himmelserscheinungen konnten in der Astronomie bereits viele grundlegende Sachverhalte erkannt und miteinander in Bezug gebracht werden. Der Dichter '''Johann Wolfgang von Goethe''' hat 1816 in seinem Werk ''Künstlers Apotheose'' unter der Überschrift „Ein Liebhaber zum Schüler“ den Kern dieser Betrachtungsweise wunderbar zum Ausdruck gebracht:

&lt;blockquote&gt;
Mein Herr, mir ist verwunderlich,&lt;br/&gt;
Dass Sie hier Ihre Zeit verschwenden&lt;br/&gt;
Und auf dem rechten Wege sich&lt;br/&gt;
Schnurstracks an die Natur nicht wenden;&lt;br/&gt;
Die Natur ist aller Meister Meister&amp;nbsp;!&lt;br/&gt;
Sie zeigt uns erst den Geist der Geister,&lt;br/&gt;
Lässt uns den Geist der Körper sehn,&lt;br/&gt;
Lehrt jedes Geheimnis uns verstehn.&lt;br/&gt;
Ich bitte, lassen Sie sich raten&amp;nbsp;!&lt;br/&gt;
Was hilft es, immer fremden Taten&lt;br/&gt;
Mit größter Sorgfalt nach zu gehn&amp;nbsp;?&lt;br/&gt;
Sie sind nicht auf der rechten Spur;&lt;br/&gt;
Natur, mein Herr&amp;nbsp;! Natur&amp;nbsp;! Natur&amp;nbsp;!&lt;br/&gt;
&lt;/blockquote&gt;

==Tal-Qadi==
[[Datei:Malta_-_Naxxar_-_Triq_l-Imdawra_-_Tal-Qadi_Temple_02_ies.jpg|mini|rechts|hochkant=2|Stark zerstörter und verfremdeter Zustand der Ruine von Tal-Qadi im Jahr&amp;nbsp;2014.]]

Die Besiedlung Maltas mit Ackerbauern der '''Stentinello'''-Kultur lässt sich ungefähr 5200 vor Christus nachweisen. Die ersten Siedler haben das Mittelmeer vermutlich von der 80&amp;nbsp;Kilometer entfernten Südküste Siziliens aus überquert und zuerst '''Gozo''' erreicht, die als kleinere Nachbarinsel fünf Kilometer nordwestlich der Hauptinsel Malta liegt. Gut 1000&amp;nbsp;Jahre später begannen die Menschen der maltesischen Megalithkultur Tempel zu bauen und für das unterirdische ''Hypogäum von Ħal-Saflieni'' Felsen auszuhöhlen. Aus großen Steinblöcken wurden erste Kultplätze errichtet.

Der Ort '''Tal-Qadi''' auf Malta wurde bereits 4000&amp;nbsp;vor Christus von Menschen genutzt. Die ersten Tempelgebäude von Tal-Qadi wurden zwischen 3300&amp;nbsp;und 3000&amp;nbsp;vor Christus gebaut und waren danach für mehrere Jahrhunderte in Gebrauch. Dieser Zeitabschnitt wird auch '''Tarxien-Phase''' der Insel genannt.

→ Es gibt zahlreiche Gründe, die dafürsprechen, dass das maltesische Tarxien mit dem biblischen '''Tarschisch''' identisch ist, siehe auch '''[[Die_Himmelstafel_von_Tal-Qadi/_Tarxien|Exkurs „Tarxien“]]'''.

Gleichzeitig mit dem Tempelgebäude in Tal-Qadi existierten auch schon die bekannten älteren Tempelanlagen in '''{{w|Mnajdra}}''' an der südlichen Küste von Malta sowie in '''{{w|Ġgantija}}''' auf der Insel Gozo.

Die Tempelanlage von Tal-Qadi liegt zehn Kilometer nordwestlich der maltesischen Hauptstadt '''Valletta''' im nördlichen Teil der Inselrepublik in der Nähe der heutigen Kleinstadt Sàn Pawl il-Baħar. Die Lage ist bei 35°56'12&quot; nördlicher Breite und 14°25'14&quot; östlicher Länge. Die Höhe über dem Meeresspiegel des Mittelmeers beträgt rund 16&amp;nbsp;Meter. Im Altertum bis auch noch in die römische Zeit reichte das Ufer des Mittelmeers bis fast an den Tempelhügel von Tal-Qadi heran. Heute ist die Uferlinie durch Verlandung gut einen Kilometer von der Salina Bay entfernt.&lt;ref&gt;[http://www.it-tarka.com/tal-qadi-temple.php The Tal-Qadi Temple], Harsien Patrimonju Mosti, Triq il-Wied, Mosta, Malta&lt;/ref&gt;

Bekannt ist Malta auch die allerdings erst nach der Tempelperiode entstandenen zahlreichen Furchen auf der Erdoberfläche, die vermutlich für den Transport schwerer Gegenstände oder von Wasser in den Felsen geschliffen wurden. Die Stelle in der Nähe vom Ort Dingli, wo sich mehrere Furchen schneiden, wird auch {{w|Clapham Junction (Malta)|Clapham Junction}} genannt.

&lt;gallery caption=&quot;Geographische Lage von Tal-Qadi&quot; heights=&quot;480&quot; widths=&quot;480&quot; mode=&quot;packed&quot;&gt;
Mediterranean Sea 16.61811E 38.99124N.jpg|Der Mittelmeerraum mit der zentral gelegenen Insel Malta in der Bildmitte.
Malta_in_its_region_(special_marker).svg|Lage der Insel Malta im Mittelmeer.
Reliefkarte_Malta_Tal-Qadi.png|Reliefkarte von Malta mit der Lage von Tal-Qadi ({{Koordinate Text|35_56_12_N_14_25_14_E_type:building(866)_region:MT|35° 46,2′ Nord, 14° 25,2′ Ost}}).
&lt;/gallery&gt;

===Bezüge der Tempelanlage zum Himmelssystem===
Aus der Archäologie sind verschiedene Beispiele bekannt, wie im Altertum mit Hilfe von ausgerichteten Gebäuden oder Gegenständen Himmelsrichtungen ermittelt sowie die Auf- und Untergänge von Gestirnen bestimmt und vorhergesagt werden konnten. Genannt seien exemplarisch die Kreisgrabenanlage von '''Goseck''' in Sachsen-Anhalt (4900&amp;nbsp;vor Christus)&lt;ref&gt;[https://www.scinexx.de/dossierartikel/2-000-jahre-vor-stonehenge/ 2.000 Jahre vor Stonehenge… – Das Sonnenobservatorium von Goseck], scienexx, 1. Februar 2008&lt;/ref&gt;, die Tempelanlagen in '''Mnajdra''' auf Malta (um 3500&amp;nbsp;vor Christus), die Himmelsscheibe von '''Nebra''' (um 2000&amp;nbsp;vor Christus) oder das '''[[Das Belchen-System|Belchen-System]]''' der Kelten in den Vogesen, bei dem vom Elsässer Belchen aus gesehen die vier anderen, weiter östlich gelegenen Belchen der Region in Bezug auf die Sonnenaufgänge eine Kalenderfunktion haben.&lt;ref&gt;Rolf d'Aujourd'hui: [https://hls-dhs-dss.ch/de/articles/016127/2002-05-07/ Belchen], Historisches Lexikon der Schweiz, 7. Mai 2002, Bern&lt;/ref&gt; Der älteste bekannte Sonnenkalender Europas aus der Jungsteinzeit soll sich in der Höhle von '''Magura''' im äußersten Nordwesten Bulgariens beziehungsweise des Balkangebirges befinden.&lt;ref&gt;Kiril Kirilov: [https://magnaaura.wordpress.com/2014/11/01/an-excerpt-of-my-magura-cave-paintings-study/ An excerpt of my Magura cave paintings study], 1. November 2014&lt;/ref&gt;

→ Siehe auch '''[[Die Höhlenmalerei in der Magura-Höhle]]'''.

Von der Tempelruine Tal-Qadi aus gesehen befindet sich in Richtung Westen (bei einem Azimut von 270&amp;nbsp;Bogengrad, die Richtung zum Sonnenuntergang bei der Tag-und-Nacht-Gleiche im Frühjahr und im Herbst) die gut erkennbare Schneise eines natürlichen Tals, in Richtung Osten liegt ein über 50&amp;nbsp;Meter hoher Hügel, der den Horizont verdeckt.


Der Ätna auf Sizilien ist bei guten Sichtverhältnissen in nördlicher Richtung über die in anderthalb Kilometer Entfernung befindliche schmale Bucht mit Salinen östlich von Sàn Pawl il-Baħar in gut 200&amp;nbsp;Kilometern sichtbar. Nur in dieser Richtung ist das Mittelmeer heute von der Tempelanlage aus von einem um einige Meter erhöhten Standpunkt zu sehen. Vor der Verlandung seit dem Altertum dürfte das Ufer der heutigen Salinen bis an Tal-Qadi herangereicht haben.&lt;ref&gt;[http://www.it-tarka.com/tal-qadi-temple.php The Tal-Qadi Temple], Harsien Patrimonju Mosti, Mosta. Malta&lt;/ref&gt; Für die Orientierung am Nachthimmel war und ist in der nördlichen Hemisphäre der Himmelsnordpol ein wichtiger Bezugspunkt. Der Polarstern war im Altertum wegen der Präzession der Erdachse noch nicht an der Stelle des Himmelsnordpols und konnte daher nicht unmittelbar zur Bestimmung der Nordrichtung herangezogen werden. Diese kann von der Tempelanlage aus allerdings leicht durch die Anvisierung der Meeresbucht in Richtung des Ätnas identifiziert werden. Dies war umso einfacher, wenn der Vulkan aktiv war und eine große, weit sichtbare Rauchsäule erzeugte,&lt;ref&gt;[https://maltadaily.mt/fuming-mount-etna-spotted-from-valletta-and-captured-in-gorgeous-photo/ Fuming Mount Etna spotted from Valletta and captured in gorgeous photo], Malta Daily, 17. Dezember 2021&lt;/ref&gt; und sogar nachts, wenn die entsprechende Feuersäule wahrnehmbar war.&lt;ref&gt;[https://maltadaily.mt/local-photographer-captures-gorgeous-photo-of-etna-eruption-on-st-pauls/ Local photographer captures gorgeous photo of Etna eruption on St. Paul’s], Malta Daily, 11. Februar 2022&lt;/ref&gt; Derartige Ereignisse sind in den Überlieferungen aus dem Altertum zur geographischen Orientierung belegt, wie zum Beispiel beim Auszug der Israeliten aus der Sklaverei des Pharaos in Ägypten etwa zwischen 1500&amp;nbsp;und 1000&amp;nbsp;vor Christus (vergleiche Exodus 13,21+22):&lt;ref&gt;[https://www.bibleserver.com/EU/2.Mose13%2C21-22 Exodus 13,21+22], bibleserver.com, Einheitsübersetzung 2016&lt;/ref&gt;

&lt;blockquote&gt;
21 Der HERR zog vor ihnen her,&lt;br/&gt;
bei Tag in einer Wolkensäule, um ihnen den Weg zu zeigen,&lt;br/&gt;
bei Nacht in einer Feuersäule, um ihnen zu leuchten.&lt;br/&gt;
So konnten sie Tag und Nacht unterwegs sein.&lt;br/&gt;
22 Die Wolkensäule wich bei Tag nicht von der Spitze des Volkes&lt;br/&gt;
und die Feuersäule nicht bei Nacht.
&lt;/blockquote&gt;

Die Ausrichtung der Tempelanlage von Westen nach Osten ist im Vergleich zu allen anderen maltesischen Tempelanlagen außergewöhnlich, da diese größtenteils entlang der Hauptachse der Insel von Nordwesten nach Südosten ausgerichtet sind. In Nord-Süd-Richtung hatte das Gebäude in Tal-Qadi eine Länge von rund 30 Meter, und in Ost-West-Ostrichtung waren es etwa 25&amp;nbsp;Meter. Wo sich der Eingang des Tempels befand, lässt sich allerdings nicht mehr eindeutig feststellen.&lt;ref name=”Micallef”&gt;Chris Micallef: „The Tal-Qadi Stone: A Moon Calendar or Star Map“, The Oracle, Number 2, 2001, pages 36 to 44&lt;/ref&gt; 

Der von Norden rechtsläufig gemessene Azimut (Horizontalwinkel) der noch erkennbaren Achse im Tempel weist im Osten nach 76&amp;nbsp;Bogengrad (heute Richtung zum Sonnenaufgang am 20.&amp;nbsp;April und am 23.&amp;nbsp;August) beziehungsweise in westlicher Gegenrichtung nach 256&amp;nbsp;Bogengrad (heute Richtung zum Sonnenuntergang am 18.&amp;nbsp;Februar und am 22.&amp;nbsp;Oktober). 3500&amp;nbsp;bis 2500&amp;nbsp;vor Christus ergaben sich diese Azimute für die auf- und untergehende Sonne zu anderen Jahreszeiten, nach Julianischem Datum nämlich Mitte Mai (einen Monat nach der Tag-und-Nacht-Gleiche) beziehungsweise Mitte September (einen Monat vor der Tag-und-Nacht-Gleiche) am Morgen im Osten sowie Mitte März (einen Monat vor der Tag-und-Nacht-Gleiche) beziehungsweise Mitte November (einen Monat nach der Tag-und-Nacht-Gleiche) am Abend im Westen.

==Die Kalksteintafel==
===Beschreibung===
[[Datei:Himmelstafel.Tal-Qadi.2048.png|mini|hochkant=2|Skizze der Einritzungen auf der Himmelstafel von Tal-Qadi nach einer photographischen Aufnahme vom ''Institute for Studies of the Study of the Ancient World'' der ''New York University''.&lt;ref name=&quot;NYU&quot;&gt;[https://isaw.nyu.edu/exhibitions/fire/checklist/25-stone-fragment-with-incised-rays-stars-and.jpg Stone fragment with incised rays, stars, and crescent], New York University, Institute for Studies of the Study of the Ancient World, Globigerina Limestone. H. 23.5, W. 30.0, D. 4.5 cm Tal-Qadi Temple (Malta) HM–NMA: 21314&lt;/ref&gt;]]

In der Tempelanlage von Tal-Qadi wurde bei den durch den maltesischen Archäologen Thermistocles Żammit und dessen britischen Kollegen Lewis Upton Way 1927 begonnenen Ausgrabungen eine fächerartige Kalksteintafel mit Einritzungen gefunden.&lt;ref name=&quot;Kurzmann1&quot; /&gt; Die meisten Markierungen erinnern deutlich an die Darstellung von Sternen, was den Fund zu einem der ältesten archäoastronomischen Objekte macht. Die Tafel befindet sich im National Museum of Archaeology in Valletta.&lt;ref&gt;[https://heritagemalta.org/national-museum-of-archaeology/ National Museum of Archaeology]&lt;/ref&gt;

Es ist unklar, ob die gefundene Kalksteintafel weitgehend vollständig ist oder nur ein Fragment einer größeren Platte ist, allerdings sind einige Seiten auffällig gerade und glatt gearbeitet.&lt;ref name=&quot;Kurzmann2&quot; /&gt; Die Kalksteintafel hat die Form eines unregelmäßigen Sechsecks, ist 29&amp;nbsp;Zentimeter breit, 24&amp;nbsp;Zentimeter hoch und ungefähr 5&amp;nbsp;Zentimeter dick. Kalkstein hat keine große Härte und kann daher auch ohne Metallwerkzeuge bearbeitet und geritzt werden, und so wurden auf der ebenen Oberfläche zahlreiche Symbole und graphische Elemente dargestellt. Allerdings gibt es auch viele natürliche Unebenheiten, und es kann nicht an allen Stellen eindeutig erkannt werden, ob die Oberfläche natürliche, bewusst von Menschenhand gemachte, unbeabsichtigte oder auf Beschädigungen zurückzuführende Strukturen aufweist. Die Provenienz der Steintafel ist offenbar noch nicht untersucht worden, wie zum Beispiel anhand der chemischen Analyse der Zusammensetzung des Gesteins.

Entsprechend der Abmessungen ergibt sich für die Steintafel eine Fläche von knapp 500 Quadratzentimetern. Mit einer Dichte von 2,7 bis 2,9 Gramm pro Kubikzentimeter für Kalkstein&lt;ref&gt;[http://www.steine-und-minerale.de/atlas.php?f=3&amp;l=K&amp;name=Kalkstein Kalkstein - Eigenschaften, Entstehung und Verwendung], steine-und-minerale.de&lt;/ref&gt; beträgt die Masse der Tafel also rund sechs Kilogramm. Damit ist sie portabel und kann mit einem entsprechenden Kraftaufwand für einige Minuten in den Händen gehalten werden.

Die Darstellung wird durch vier gerade Linien strahlenförmig in fünf ungefähr gleichgroße Winkelsegmente mit jeweils rund 20&amp;nbsp;Bogengrad geteilt. Die Linien haben einen gemeinsamen Schnittpunkt etwas außerhalb der Tafel und gehen dabei radial von dem Eckpunkt links der längsten und geraden Kante aus. In den beiden jeweils links und rechts befindlichen Segmenten sind sternförmige Symbole dargestellt. Im linken Segment ist ein einzelnes Sternsymbol erkennbar, in den drei anderen mehrere Sternsymbole. Das mittlere Segment zeigt nur eine halbkreisförmige Figur, deren gerade Kante senkrecht auf der Richtung zum Zentrum der Radialstrahlen und auf der Seite zu diesem Zentrum liegt. Die beiden rechten Segmente werden von einer deutlich breiter ausgeprägten Furche durchquert.

====Ähnliche archäologische Objekte ====
[[Datei:Fragment-de-STELE_8206.jpg|mini|links|Vorderseite der Kalksteinstele vom Rocher des Doms.]]

In Avignon gibt es eine 26&amp;nbsp;Zentimeter hohe Kalksteinstele der Lagozza-Kultur des ausgehenden Neolithikums, auf der im unteren Bereich etwas nach rechts versetzt ein der Himmelstafel von Tal-Qadi sehr ähnliches sternförmiges Symbol mit acht Strahlen dargestellt ist.&lt;ref&gt;[https://www.musee-calvet.org/beaux-arts-archeologie/fr/oeuvre/stele-du-rocher-des-doms Stèle du rocher des Doms], Avignon Musée Calvet, Collections permanentes Préhistoire&lt;/ref&gt;&lt;ref&gt;Jean-Pierre Girault, Jean Gascó: [https://www.uxellodunum.com/uploads/1/1/6/9/116911940/texte_steles_issolud_v2_reduit.pdf DEUX STÈLES PROTOHISTORIQUES REDÉCOUVERTES AU PUY D’ISSOLUD (VAYRAC, LOT)], PDF-Datei, französisch&lt;/ref&gt; Auf der Rückseite befinden sich mehrere Bohrungen, deren Anordnung eine große Ähnlichkeit mit der Sternenregion im Bereich des Wintersechsecks zeigt.

Für weitere Betrachtungen zur Stele siehe '''[[Quadriviale Kuriositäten/ Die Stele vom Rocher des Doms|Exkurs „Die Stele vom Rocher des Doms“]]'''.

Ferner wurde in der Höhle von ''Buracas da Serra'' im Alvaiázere-Berg im heutigen Portugal im Distrikt Leiria bei der Stadt Alvaiázere eine in anderthalb Metern Höhe, rund fünf Millimeter tief in den Stein geritzte, sternenartige Struktur gefunden. Sie befindet sich auf einem kleinen Vorsprung des Felses, ist ungefähr zehn mal fünf Zentimeter groß und hat insgesamt sechs Strahlen, die zur Achse des längsten Doppelstrahls spiegelsymmetrisch sind. Die Darstellung tritt vollkommen isoliert auf und kann nur schwierig gedeutet werden. Es wurde vermutet, dass ein Komet oder der Meteor eines Meteoriten dargestellt sein könnte, der am Himmel beobachtet wurde.&lt;ref&gt;Alexandra Figueiredo, Fernando Augusto Coimbra, Cláudio Monteiro, Nuno Ribeiro: ''PRELIMINARY ANALYSIS OF THE ROCK ART FROM BURACAS DA SERRA, ALVAIÁZERE (PORTUGAL) - ESTUDIO PRELIMINAR DEL ARTE RUPESTRE DE LA SIERRA DE BURACAS, ALVAIÁZERE (PORTUGAL)'', in: ''REVISTA CUADERNOS DE ARTE PREHISTÓRICO'', Seiten 127 bis140, 15. Juni 2017, ISSN 0719-7012&lt;/ref&gt;
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

===Interpretation===
Der italienische Archäologe Luigi Maria Ugolini (*&amp;nbsp;1895; †&amp;nbsp;1936) mutmaßte bereits 1934, dass die Steintafel eine astrologische Funktion hätte und dass darauf Sterne und eine Mondsichel zu sehen seien.&lt;ref&gt;Luigi Maria Ugolini: ''Malta: Origini della Civilta Mediterranea'', Seite 128, Malta, La Libreria dello Stato, 1934&lt;/ref&gt;

Schon früh sind die drei dargestellten Sterngruppen mit Sternzeichen in Verbindung gebracht worden. Es wurde gemutmaßt, dass die drei Sterngruppen für die drei Sternzeichen '''Skorpion''', '''Jungfrau''' und '''Löwe''' stehen, oder dass die vorhandene Tafel lediglich ein Fragment einer größeren Tafel sei, die einen Mondphasenkalender dargestellt hat. Das Symbol im mittleren Segment wurde hierbei mit einem Halbmond in Zusammenhang gebracht.&lt;ref name=”Micallef” /&gt;

Es besteht die Möglichkeit, dass die auf der Himmelstafel dargestellte Himmelsregion mit den dann und dort untergehenden Gestirnen damals vom Tempel von Tal-Qadi aus insbesondere abends und in westlicher Richtung beobachtet wurde.&lt;ref&gt;Siehe auch Klaus Albrecht: ''Die „Sternenkarte“ von Tal-Qadi (Malta) und die Ausrichtung des Tempels von Tal-Qadi nach Osten'', Kapitel 9 in: Gudrun Wolfschmidt (Herausgeberin): ''Orientierung, Navigation und Zeitbestimmung - Wie der Himmel den Lebensraum des Menschen prägt'', Tagung der Gesellschaft für Archäoastronomie in Hamburg 2017, aus der Reihe ''Nuncius Hamburgensis - Beiträge zur Geschichte der Naturwissenschaften'', Band 42&lt;/ref&gt;

[[Datei:Taurus-arts.png|mini|hochkant=2|Moderne künstlerische Untermalung des Nachthimmels mit Ausschnitten der benachbarten Sternbilder '''Orion''' und '''Stier''' (Taurus). Links unten der Arm und der Bogen vom Jäger Orion und in der Mitte der Kopf des Stieres mit '''Aldebaran''' und den '''Hyaden''' sowie der Rumpf des Tieres mit den '''Plejaden''' weiter oben rechts. Der Stern '''Omikron Tauri''' (ο&amp;nbsp;Tauri) liegt rechts unten im linken Vorderhuf, und die beiden Sterne '''Tien Kuan''' (ζ&amp;nbsp;Tauri) und '''Elnath''' (β&amp;nbsp;Tauri) liegen links oben in den Spitzen der Hörner. Oberhalb der Plejaden am Bildrand ist ein Fuß des Sternbilds Perseus mit den beiden Sternen ζ&amp;nbsp;Persei und '''Atik''' (ο&amp;nbsp;Persei) zu sehen.]]

Neueren Untersuchungen des Archäologen Peter Kurzmann zu Folge könnte es sich bei den sieben sternförmigen Darstellungen direkt links der Mitte um den Stern '''Aldebaran''' (α&amp;nbsp;Tauri) mit den zum offenen Sternhaufen der '''Hyaden''' gehörigen Sternen γ, δ, ε und θ&amp;nbsp;Tauri im heutigen Sternbild '''Stier''' (Taurus) sowie den beiden Spitzen der Stierhörner und '''Tien Kuan''' (ζ&amp;nbsp;Tauri) und '''Elnath''' (β&amp;nbsp;Tauri) handeln.&lt;ref name=&quot;Kurzmann1&quot; /&gt;

Der Stern ε&amp;nbsp;Tauri wird auch '''Ain''' genannt. Die beiden Sterne Aldebaran und Ain stehen für die Augen des Stieres, und es ist interessant darauf hinzuweisen, dass Aldebaran und Ain nicht nur die astronomischen Namen α&amp;nbsp;Tauri (alpha Tauri) und ε&amp;nbsp;Tauri (epsilon Tauri) haben, sondern dass sie auch mit dem ersten Buchstaben Aleph [[Datei:PhoenicianA-01.svg|30px]] und dem Buchstaben Ain [[Datei:PhoenicianO-01.svg|30px]] des bereits im zweiten vorchristlichen Jahrtausend verwendeten phönizischen Alphabets in Zusammenhang gebracht werden können.&lt;ref name=&quot;ErnstVonBunsen&quot;&gt;Ernst von Bunsen: ''Die Plejaden und der Thierkreis oder: Das Geheimnis der Symbole'', Verlag von Mitscher und Röstell, Berlin, 1879&lt;/ref&gt; Im später eingeführten hebräischen Alphabet entsprechen diese dem ersten Buchstaben Aleph und dem Buchstaben Ajin (zu Deutsch &quot;Auge&quot;). Diese Buchstaben tauchen auch im eng verwandten paläohebräischen Alphabet als Aleph und Ayin auf. Ferner ist bemerkenswert, dass der Frühlingspunkt auf der scheinbaren Sonnenbahn (Ekliptik) vor 5000&amp;nbsp;Jahren zwischen den ekliptikalen Längen dieser beiden Sterne lag und dass die Sonne während eines Sonnenjahres vom Anfang bei Aldebaran auf dieser Bahn bis zum Ende bei Ain zog. Im Christentum wird das &quot;A und O&quot; auf die ''Offenbarung des Johannes'' bezogen:&lt;ref&gt;[https://www.bibleserver.com/EU/Offenbarung22%2C13 Offenbarung des Johannes, Kapitel 22, Vers 13], bibleserver.com, Einheitsübersetzung&lt;/ref&gt;

&lt;blockquote&gt;
Ich bin das Alpha und das Omega, der Erste und der Letzte, der Anfang und das Ende.
&lt;/blockquote&gt;

→ Siehe auch Exkurs '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Ochs_und_Esel|Ochs und Esel]]'''.

Die Konstellation rechts der Mitte könnten die sieben Hauptsterne des offenen Sternhaufens der '''Plejaden''', ebenfalls zum Sternbild Stier (Taurus) gehörig, sowie ganz rechts das nördlich angrenzende Sternbild '''Perseus''' darstellen. Der einzelne Stern links wurde mit einem der drei hellsten Sterne des nördlichen Sternhimmels südlich der genannten Sternhaufen in Verbindung gebracht:&lt;ref name=&quot;Kurzmann1&quot;&gt;Peter Kurzmann: [https://www.archaeologie-online.de/artikel/2014/die-neolithische-sternkarte-von-tal-qadi-auf-malta/ Die neolithische Sternkarte von Tal-Qadi auf Malta], Archäologie online, 25. Juli 2014&lt;/ref&gt;
* Der markante Rote Überriese '''Beteigeuze''' (α&amp;nbsp;Orionis) im Sternbild Orion, die Schulter des Himmelsjägers (auch als linker Schulterstern bezeichnet, weil er vom Betrachter aus links oben ist).
* Der hellste Stern im Sternbild Orion '''Rigel''' (β&amp;nbsp;Orionis), der gegenüberliegende Fuß des Himmelsjägers.
* Der hellste Stern des Sternhimmels '''Sirius''' (α&amp;nbsp;Canis Majoris) im Hals- und Kopfbereich des Sternbilds Großer Hund (Canis Major).

In einer weiteren Untersuchung von Peter Kurzmann wird darauf hingewiesen, dass die Kanten der Steintafel nicht gebrochen, sondern bearbeitet und teilweise recht gerade sind, so dass davon ausgegangen werden kann, dass die Geometrie der Steintafel beabsichtigt ist und dass es sich nicht um ein Bruchstück aus einer größeren Tafel handeln dürfte. Eine in der Tafel erkennbare fünfeckige Struktur hat Ähnlichkeiten mit den Grundrissen maltesischer Tempel.&lt;ref name=&quot;Kurzmann2&quot;&gt;Peter Kurzmann: [https://www.archaeologie-online.de/artikel/2016/weitere-untersuchungen-zur-neolithischen-sternkarte-von-tal-qadi-malta/ Weitere Untersuchungen zur neolithischen Sternkarte von Tal-Qadi auf Malta], Archäologie online, 10. Juli 2016&lt;/ref&gt;

Auch in einer anderen Tempelanlage auf Malta, im Südtempel von Mnajdra, haben sich Hinweise auf die mögliche Beobachtung der Plejaden im Altertum gefunden.&lt;ref name=&quot;Ventura&quot;&gt;Frank Ventura, Michael Hoskin: [[doi:10.1007/978-1-4614-6141-8_133|Temples of Malta]], in: Clive Ruggles (Herausgeber), ''Handbook of Archaeoastronomy and Ethnoastronomy'', 7. Juli 2014, Seiten 1421-1430, Springer, New York, ISBN 978-1-4614-6140-1&lt;/ref&gt;

Andere Forscher gehen davon aus, dass das halbkreisförmige Symbol eine Vogelbarke sei, mit der die Bewohner Maltas damals das Mittelmeer befahren hätten. Die Sternkonstellationen seien Abbilder der Adria-Region, des östlichen Mittelmeers und des Schwarzen Meers.&lt;ref&gt;Kai Helge Wirth: „The Zodiac of Malta - The Tal Qadi Stone Enigma - Ultimate proof of Newtons Theory”, 2016, 2. Auflage, ISBN 978-3741250590&lt;/ref&gt; Folgt man diesem Ansatz, liegt die Basis der Steintafel nicht im Zentrum der Strahlen, sondern genau gegenüber, damit die Barke richtig, nämlich im Wasser schwimmend ausgerichtet wäre. Es wird mit Verweis auf Isaac Newtons Schrift ''The Chronology of Ancient Kingdoms Amended''&lt;ref&gt;Isaac Newton: [http://www.argonauts-book.com/isaac-newton.html The Chronology of Ancient Kingdoms Amended], London, 1728&lt;/ref&gt; davon ausgegangen, dieser hätte postuliert, dass Sternbilder zur Navigation verwendet wurden. In der Chronik finden sich zwar Verweise auf die Navigation mit Sternen und auf die Verwendung von Sternbildern im Altertum, jedoch betrifft dies weder die Zeit vor 4500&amp;nbsp;Jahren noch werden Navigation und Sternbilder von Newton in eine direkte Beziehung gebracht. Vielmehr weist er nur darauf hin, dass im Altertum zur Navigation die Auf- und Untergänge (Morgenerst und Morgenletzt beziehungsweise Abenderst und Abendletzt) einzelner Gestirne beobachtet wurden (auch heliakische und akronychische Auf- und Untergänge genannt). Von Übereinstimmungen von Sternbildern mit geographischen Gegebenheiten ist bei Newton ebenfalls keine Rede.&lt;ref&gt;Isaac Newton: [http://www.newtonproject.ox.ac.uk/view/texts/normalized/THEM00185 A Short Chronicle from the First Memory of Things in Europe, to the Conquest of Persia by Alexander the Great]&lt;/ref&gt;

Im Folgenden werden einige der erwähnten Himmelsobjekte sowie einige astronomische Sachverhalte etwas näher beschrieben und in Zusammenhang gebracht.

==Die Plejaden==
[[Datei:Die.Plejaden.P1044869.jpg|mini|rechts|Die hellsten Sterne im offenen Sternhaufen der Plejaden.]]

Der mit bloßem Auge sichtbare und sehr auffällige offene Sternhaufen der Plejaden (Siebengestirn, „M45“ im Messier-Katalog) befindet sich am Rand unserer Milchstraße im Sternbild Stier (Taurus), umfasst deutlich über 1000 Sterne und ist ungefähr 125&amp;nbsp;Millionen Jahre alt. In sehr vielen Kulturen haben die Plejaden einen Eigennamen, und auch deren hellste Sterne wurden in der Tradition der antiken griechischen Mythologie mit den Namen der Plejaden genannten Nymphen und deren Eltern versehen.

→ Ausführungen zu den Plejaden finden sich im '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die Plejaden|Exkurs „Die Plejaden“]]'''.

===Sichtbarkeit===
Die Plejaden stehen von Malta aus gesehen heute sowohl am 20.&amp;nbsp;Mai (in Konjunktion zur Sonne sind sie dann unsichtbar) als auch am 18.&amp;nbsp;November (in Opposition zur Sonne und um Mitternacht mit einer Höhe von 78&amp;nbsp;Bogengrad sehr hoch über dem südlichen Horizont) im Meridian. Der Meridian ist der gedachte Großkreis, der sowohl durch die beiden Himmelspole als auch durch den Zenit und den Nadir läuft. Im Winter und im Frühjahr sind die Plejaden am Abendhimmel in westlicher Richtung und im Sommer und im Herbst am Morgenhimmel in östlicher Richtung zu beobachten.

Die folgende Tabelle gibt die Zeitpunkte der ersten und letzten zu beobachtenden Auf- und Untergänge der Plejaden für Malta an (das Julianische Datum des Frühlingsanfangs war vor 5000&amp;nbsp;Jahren der 14.&amp;nbsp;April). Heliakisch bedeutet hierbei &quot;zur Sonne gehörend&quot;, also in Nähe zur aufgehenden Sonne. Diese muss allerdings unter dem Horizont stehen, und der Abstand zur Sonne (also die Elongation) muss mehr als 18&amp;nbsp;Bogengrad betragen, damit das in der Atmosphäre gestreute Sonnenlicht die Plejaden nicht überstrahlt. Die akronychischen, also &quot;am Rand der beginnenden Nacht&quot; befindlichen Aufgänge (Abenderst) sowie die heliakischen Untergänge (Morgenletzt) spielen für Fixsterne (und somit auch für die Plejaden) keine Rolle, da diese im Gegensatz zum Mond, zu den Planeten und zu Kometen in den Nächten zwischen Morgenerst und Abendletzt immer zu sehen sind:

{| class=&quot;wikitable&quot;
|+ Die Lage der Plejaden am Sternenhimmel
!title=&quot;Ereignis&quot;|Ereignis
!title=&quot;Astronomische Bezeichnung&quot;|Astronomische&lt;br/&gt;Bezeichnung
!title=&quot;Datum heute&quot;|Datum&lt;br/&gt;heute
!title=&quot;Julianisches Datum vor 5000 Jahren&quot;|Julianisches Datum&lt;br/&gt;vor 5000 Jahren
!title=&quot;Tageszeit&quot;|Tageszeit
!title=&quot;Richtung&quot;|Richtung
!title=&quot;Höhe&quot;|Höhe
|-
| Abendletzt || Akronychischer Untergang || 30. April || 17. März || Am Abend || Westen || Am Horizont
|-
| Sonnennähe || Konjunktion zur Sonne || 20. Mai || 6. April || Am Mittag || Süden || Dicht am Zenit
|-
| Morgenerst || Heliakischer Aufgang || 10. Juni || 27. April || Am Morgen || Osten || Am Horizont
|-
| Sonnenferne || Opposition zur Sonne || 18. November || 7. Oktober || Um Mitternacht || Süden || Dicht am Zenit
|}

Von Malta aus gesehen kreuzten um 3000&amp;nbsp;vor Christus die Plejaden den Horizont beim Untergang in recht steilem Winkel, so dass sie besonders gut zu beobachten waren. Damals wie heute gehen die Plejaden auf der Linie des Horizonts ungefähr bei 7&amp;nbsp;Bogengrad nördlich der Ekliptik bei einem Azimut von rund 60&amp;nbsp;Bogengrad im Osten auf und bei 5&amp;nbsp;Bogengrad nördlich der Ekliptik bei einem Azimut von rund 300&amp;nbsp;Bogengrad im Westen unter.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Astronomische Bezugssysteme==
Die wichtigsten astronomischen Bezugssysteme für die Beschreibung des von der Erde aus beobachteten Sternenhimmels werden bei einer Armillarsphäre mit drei beweglichen Ringen, die die drei astronomischen Ebenen des Horizonts, des Himmelsäquators und der Ekliptik realisiert. Mit einfachen Ausführungen von solchen Armillarsphären beobachteten schon die Babylonier in der Antike das Geschehen am Nachthimmel.

→ Ausführungen zu den '''astronomischen Bezugssystemen'''

* des '''Horizonts''' mit den vier Himmelsrichtungen, dem '''Zenit''' und dem '''Nadir''',
* des '''Himmelsäquators''' mit den beiden '''Himmelspolen''', dem '''Frühlingspunkt''' und dem '''Herbstpunkt'''
* sowie der '''Ekliptik''' mit dem '''Goldenen Tor der Ekliptik''', dem '''Himmelsstier''' und dem '''Trichter der Thuraya'''

finden sich im '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische Bezugssysteme|Exkurs „Astronomische Bezugssysteme“]]'''.

==Tage, Monate und Jahre==
Das '''Sonnenjahr''' (auch tropisches Jahr, altgriechisch ''τρόπος'' (''tropos'') = ''Drehung'') beschreibt einen vollständigen Umlauf der Erde um die Sonne und hat 365,242&amp;nbsp;Tage - das sind knapp fünfeinviertel Tage mehr als 360, die Zahl, die im Gradsystem der Winkelmessung einem vollen Kreis entspricht. Da es knapp einen Vierteltag länger ist als 365&amp;nbsp;Tage, wird in den Kalender fast alle vier Jahre der 29.&amp;nbsp;Februar als Schalttag am ehemaligen Ende des Kalenderjahres (der September war der siebente Monat, der Oktober der achte und so weiter) eingeschoben, damit die Jahreszeiten synchron mit dem Sonnenlauf bleiben. Dadurch bleibt auch der Zeitpunkt im '''Sonnenkalender''', in dem die Sonne bei der Tag-und-Nacht-Gleiche den Frühlingspunkt erreicht, immer am gleichen Tag, nämlich dem '''Frühlingsanfang'''.

===Mondzyklen===
[[Datei:Vollmond.P1080516.jpg|mini|rechts|hochkant=2|Um Mitternacht fast im Zenit stehender Dezember-Vollmond.]]

Der '''Mond''' hat von allen wandelnden Gestirnen die kürzeste siderische Umlaufzeit, die nur einen '''Monat''' beträgt, und er ändert mit seinen ständig wechselnden Mondphasen täglich sein Aussehen und seine Lage in Bezug zum Fixsternhimmel. Mit einem scheinbaren Winkeldurchmesser, der mehr oder weniger so groß ist, wie derjenige der Sonne, kann er sehr gut und einfach beobachtet werden. Dies gilt insbesondere auch bei der Bedeckung von Sternen und Planeten ('''Okkultation''') oder auch bei der Bedeckung der Sonne während einer '''Sonnenfinsternis'''. Der Mond kann während seiner Vollmondphase vom Erdschatten getroffen werden, so dass es zu einer '''Mondfinsternis''' kommt, bei der der Mond im Falle der Totalität eine stark rötliche Verfärbung erfährt („Blutmond“).

Da der Mond hell genug ist, im Gegensatz zur Sonne jedoch nicht blendet, kann er sowohl am Tag als auch in der Nacht beobachtet werden, sofern er über dem Horizont und nicht zu dicht an der Sonne steht. Dies macht ihn zum vorrangigen Objekt für die Beobachtung und die Gestaltung von '''Mondkalendern'''. Ein Mondviertel dauert ungefähr '''sieben Tage''' beziehungsweise eine '''Woche''', und in jedem der '''vier Mondviertel''' steht er zu einer bestimmten Tageszeit in einem anderen Himmelsquadranten und somit in einer anderen der vier Himmelsrichtungen. Viele alte Mondkalender basieren daher auf der Einteilung der Ekliptik in 27 oder 28 '''Mondhäuser''', in denen der Mond sich immer ungefähr einen Tag lang aufhält. Ein Mondjahr hat zwölf synodische Monate beziehungsweise 354,37&amp;nbsp;Tage - das sind gut fünfeinhalb Tage weniger als 360.

Durch die Beobachtung von '''mehrjährigen Mondzyklen''' können Finsternisse und Bedeckungen vorhergesagt werden.

→ Ausführungen zu verschiedenen Mondzyklen finden sich im '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Mondzyklen|Exkurs „Mondzyklen“]]'''.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

===Der Kalenderstein vom Tempel Mnajdra===
[[Datei:Kalenderstein.Mnajdra.labelled.png|mini|rechts|hochkant=2|Skizze der Lochreihen auf dem Kalenderstein von Mnajdra nach Ventura und Hoskin.&lt;ref name=&quot;Ventura&quot; /&gt;]]

Indizien für die Beobachtung des Mondes durch die Neolithiker auf Malta sind auf Kalendersteinen vom maltesischen Tempel Mnajdra zu finden, die ebenfalls aus der Tempelperiode der Insel stammen.&lt;ref name=&quot;Ventura&quot; /&gt; Die Verehrung des Mondes spiegelt sich auch in einem runden Mondstein mit sechs Zentimetern Durchmesser wider, der im Hypogäum von Ħal-Saflieni gefunden wurde und aus dieser Zeit stammt.&lt;ref&gt;Daniel Cilia: [https://web.infinito.it/utenti/m/malta_mega_temples/TempleFig/%20Pres,Misc/pages/face.htm Found in a house at Hal Saflieni, stone], The Megalithic Temples of Malta – the world's most ancient stone architecture, 4. August 2004&lt;/ref&gt;

Es ist interessant festzustellen, dass auf dem östlichen Kalenderstein mehrere Lochreihen mit verschiedenen typischen Lochzahlen auftreten, die mit lunaren und solaren Kalendern im Zusammenhang stehen dürften. Die Stele ist heute so aufgestellt, dass die Bohrungen in horizontaler Richtung verlaufen, sie wurde möglicherweise jedoch senkrecht nach unten auf dem noch liegenden Stein durchgeführt, um die Wirkung der Gravitation ausnutzen zu können. So ausgerichtet wäre es dann auch möglich gewesen, für Markierungs- oder Zählzwecke beispielsweise kugelförmige Steine in die Löcher zu legen.

→ Ausführungen zu diesen Kalendersteinen finden sich im '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Mondzyklen#Der Kalenderstein vom Tempel Mnajdra|Exkurs „Mondzyklen“ im Abschnitt „Der Kalenderstein vom Tempel Mnajdra“]]'''.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Interpretation==
[[Datei:Goldenes.Tor.der.Ekliptik.abends.West.png|mini|hochkant=3|Skizze der Himmelsregion mit dem Sternengürtel am westlichen Nachthimmel, der auf der Himmelstafel von Tal-Qadi möglicherweise dargestellt ist.]]

Die Sterne sind keineswegs gleichmäßig über dem Himmel verteilt. Besonders viele, mit bloßem Auge jedoch meist nicht als einzelner Lichtpunkt auflösbar, verschmelzen in unserer Galaxie zu einem uns ringförmig umgebenden Lichtteppich, der '''Milchstraße'''. Unabhängig davon gibt es Regionen mit überwiegend schwach leuchtenden Sternen, wie den '''Trichter der Thuraya''', und Bereiche mit zahlreichen hellen Sternen, wie den im Folgenden beschriebenen '''Sternengürtel'''. 

Der Sternengürtel vom hellsten Stern des Firmaments '''Sirius''' im Sternbild '''Großer Hund''' (Canis Major), über das sehr markante Sternbild '''Orion''' mit dem Roten Überriesen '''Beteigeuze''' und dem sehr hellen Stern '''Rigel''', die sehr auffälligen offenen Sternhaufen der '''Hyaden''' mit dem sehr hellen Roten Riesen '''Aldebaran''' und '''Plejaden''' im Sternbild '''Stier''' (Taurus), das sich direkt angrenzende Sternbild '''Fuhrmann''' (Auriga) mit dem sehr hellen Stern '''Capella''', das ebenfalls seit sehr langer Zeit etablierte Sternbild '''Perseus''' mit dem Hauptstern '''Mirfak''' bis hin zum Sternbild '''Kassiopeia''' (&quot;Himmels-W&quot;) ist auf der nördlichen Halbkugel der Erde gut erkennbar und einprägsam. Dieser Sternengürtel überbrückt zudem den schwach mit Sternen besetzen Ausschnitt unserer Milchstraße und grenzt ungefähr mittig an den sich nach Westen hin öffnenden Trichter der Thuraya.

Ein weiterer sich kreisförmig über den gesamten Himmel spannende Gürtel, in welchem sich die sieben hellen Wandelgestirne, '''Sonne''', '''Mond''', '''Merkur''', '''Venus''', '''Mars''', '''Jupiter''', und '''Saturn''' bewegen, wird durch die bogenförmige Linie der '''Ekliptik''' beschrieben. Siehe hierzu auch '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Die_Ekliptik|Exkurs „Die Ekliptik“]]'''.

Der Schnittpunkt des oben genannten Sternengürtels mit der Ekliptiklinie befindet sich im '''Goldenen Tor der Ekliptik''' im Sternbild Stier (Taurus). In diesem Schnittpunkt lag vor 4500 Jahren zudem der '''Frühlingspunkt'''. Insofern ist es also nicht überraschend, wenn dieser Schnittpunkt als leicht und zuverlässig aufzufindender Referenzpunkt für freiäugige astronomische Beobachtungen ausgewählt wird, zum Beispiel, um die ekliptikalen Breiten und Längen der Wandelgestirne oder die Mondphasen zu untersuchen.

[[Datei:Orion.Aldebaran.Mars.P1024912.jpg|mini|hochkant=6|zentriert|Das Sternbild '''Orion''' in der linken Bildhälfte mit dem Roten Überriesen '''Beteigeuze''' (α&amp;nbsp;Orionis, links oben), das Sternbild '''Stier''' (Taurus) in der rechten Bildhälfte mit dem Roten Riesen '''Aldebaran''' (α&amp;nbsp;Tauri, links oben in der V-förmigen Konstellation des offenen Sternhaufens der '''Hyaden''') und dem offenen Sternhaufen der '''Plejaden''' (rechts oben). Der rote Planet '''Mars''' (rechts unterhalb der Plejaden) auf dem Weg in das Goldene Tor der Ekliptik. Ganz rechts unten der helle Stern Menkar (α&amp;nbsp;Ceti) und der Stern Kaffaljidhma (γ&amp;nbsp;Ceti) im Sternbild Walfisch (Cetus).]]
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

Ausgehend von der Hypothese, dass die beiden Winkelsegmente links und rechts der Mitte der Himmelstafel von Tal-Qadi die Asterismen der '''Hyaden''' und der '''Plejaden''' im Sternbild Stier (Taurus) zeigen, die das '''Goldene Tor der Ekliptik''' bilden, könnte das halbkreisförmige Symbol im dazwischenliegenden mittleren Segment für den Bogen der Ekliptik über dem Horizont stehen. Im Goldenen Tor der Ekliptik können alle sieben gegenüber dem Fixsternhimmel hindurchziehenden Wandelgestirne beobachtet werden. Genau an dieser Stelle befand sich während der maltesischen Tarxien-Phase der Frühlingspunkt der Sonne respektive der Herbstpunkt des Vollmonds.

Bei der astronomischen Beobachtung der Hyaden und der Plejaden können mit Hilfe der entsprechend ausgerichteten und eingepassten Himmelstafel jederzeit und an jeder Stelle des Himmels unmittelbar '''Lage und Neigung der Ekliptik''' abgelesen werden, ohne die Wandelgestirne oder gar deren Lauf beobachten zu müssen. Mit dieser Kenntnis ist es dann ebenfalls möglich, die jeweilige Lage der beobachteten Wandelgestirne auf der Ekliptik zu bestimmen, also eine Messung der '''ekliptikalen Länge''' zum Beispiel vom Frühlingspunkt aus oder von der langen rechten Kante der Himmelstafel aus vorzunehmen.

Die Ekliptik steht bei der unten beschriebenen Ausrichtung senkrecht in der Mitte dieser Kante. Von dort aus kann entlang der Kante nach oben oder nach unten die '''ekliptikalen Breite''' abgelesen werden. Somit ist bei längerfristiger Beobachtung eine Bestimmung der '''drakonitischen Periode''' zwischen den Durchgängen des Mondes durch die Mondknoten auf der Ekliptik möglich.

Die Höhe über der Ekliptik ist bei der Sonne definitionsgemäß Null, und bei den sichtbaren Planeten sowie dem Mond beträgt die Abweichung nur einige Grad. Somit tritt der Mond bei der Ausrichtung der Tafel alle 27&amp;nbsp;1/3 Tage senkrecht über die rechte untere Kante der Himmelstafel in das Goldene Tor der Ekliptik. Trifft er hierbei ungefähr vier Bogengrad nördlich der Ekliptik auf die Kante, kommt es einen Tag später zu einer '''Bedeckung der Plejaden durch den Mond'''. Läuft die Mondbahn hingegen auf der gegenüberliegenden Seite ungefähr fünf Bogengrad südlich auf die Kante, kommt es anderthalb Tage später zu einer '''Bedeckung des Sterns Aldebaran durch den Mond'''. Beides sind außergewöhnliche und besondere astronomische Ereignisse.&lt;ref&gt;Dirk Lorenzen: [https://www.deutschlandfunk.de/aldebaran-bedeckung-am-fruehen-morgen-sternbedeckung-wie.732.de.html?dram:article_id=399510 Aldebaran-Bedeckung am frühen Morgen - Sternbedeckung wie einst bei Copernicus], Deutschlandfunk, 5. November 2017&lt;/ref&gt; In diesem Kontext ist hervorzuheben, dass es nach der Bedeckung des Siebengestirns durch den absteigenden Mond eine Woche später häufig ebenfalls zur Bedeckung des Königssterns '''Regulus''' durch den Mond kommt (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Mondzyklen#Der_drakonitische_Zyklus|„Der drakonitische Zyklus“]] und [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|„Das Goldene Tor der Ekliptik“]]).

Befindet sich der Mond bei dieser Beobachtung in der Nähe der Ekliptik, also in der Mitte der rechten unteren Kante der Himmelstafel, kann es bei zeitlicher Nähe zum Vollmond zu '''Mondfinsternissen''' und bei zeitlicher Nähe zum Neumond zu '''Sonnenfinsternissen''' kommen. Bei regelmäßiger und langfristiger Beobachtung anhand der im Goldenen Tor der Ekliptik auftretenden ekliptikalen Breiten und Mondphasen konnte der 19-jährige [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Mondzyklen#Der_Meton-Zyklus|'''Meton-Zyklus''']] zu allen Zeiten nachvollzogen werden. So erschien der Vollmond zum Beispiel in der Nacht vom 29.&amp;nbsp;zum 30.&amp;nbsp;November 2020 im Goldenen Tor der Ekliptik ('''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische Bezugssysteme#Das Goldene Tor der Ekliptik|Bild siehe Exkurs „Astronomische Bezugssysteme“]]'''). An folgenden Vormittag kam es wegen der betragsmäßig hinreichend geringen ekliptikalen Breite von -1,8&amp;nbsp;Grad zu einer partiellen Halbschattenmondfinsternis, die in diesem Fall allerdings nur außerhalb von Europa auf der Nachtseite der Erde sichtbar war.&lt;ref&gt;[https://www.timeanddate.de/finsternis/mond/2020-november-30 29–30. November 2020 Halbschatten-Mondfinsternis], timeanddate.de, Time and Date AS, Stavanger, Norwegen&lt;/ref&gt;

===Zuordnung der Sterne zur Darstellung===
Ob und welche Sternbilder vor 4500&amp;nbsp;Jahren in Gebrauch waren, ist unbekannt. Da in der Dämmerung und bei vorhandenem Mondlicht nur die hellsten Sterne des Firmaments zu sehen sind, empfiehlt es sich, für eine Zuordnung der auf der Himmelstafel dargestellten Sterne insbesondere diese in Betracht zu ziehen. Die folgende Tabelle zeigt die hellsten Objekte im Bereich der möglicherweise auf der Himmelstafel von Tal-Qadi dargestellten Himmelsregion:

[[Datei:Himmelstafel.Tal-Qadi.helle.Sterne.png|mini|hochkant=2|rechts|Die hellsten Himmelsobjekte im Bereich der grob eingepassten Himmelstafel von Tal-Qadi.]]

{| class=&quot;wikitable sortable&quot;
!title=&quot;Eigenname&quot;| Eigenname
!title=&quot;Astronomische Bezeichnung&quot;| Astronomische&lt;br/&gt;Bezeichnung
!title=&quot;Scheinbare Helligkeit&quot;| Scheinbare&lt;br/&gt;Helligkeit
|-
| Sirius || α Canis Majoris|| -1,5&lt;sup&gt;m&lt;/sup&gt;
|-
| Capella || α Aurigae || 0,0&lt;sup&gt;m&lt;/sup&gt;
|-
| Rigel || β Orionis || 0,0&lt;sup&gt;m&lt;/sup&gt;
|-
| '''Beteigeuze''' || α Orionis || 0,5&lt;sup&gt;m&lt;/sup&gt;
|-
| '''Hyaden''' || Sternhaufen (Taurus) || 0,5&lt;sup&gt;m&lt;/sup&gt;
|-
| '''Aldebaran''' || α Tauri || 1,0&lt;sup&gt;m&lt;/sup&gt;
|-
| '''Plejaden''' || Sternhaufen (Taurus) || 1,5&lt;sup&gt;m&lt;/sup&gt;
|-
| Alnilam || ε Orionis || 1,5&lt;sup&gt;m&lt;/sup&gt;
|-
| Alnitak || ζ Orionis || 1,5&lt;sup&gt;m&lt;/sup&gt;
|-
| Bellatrix || γ Orionis || 1,5&lt;sup&gt;m&lt;/sup&gt;
|-
| Elnath || β Tauri || 1,5&lt;sup&gt;m&lt;/sup&gt;
|-
| Alamak || γ Andromedae || 2,0&lt;sup&gt;m&lt;/sup&gt;
|-
| Algol || β Persei || 2,0&lt;sup&gt;m&lt;/sup&gt;
|-
| Caph || β Cassiopeiae || 2,0&lt;sup&gt;m&lt;/sup&gt;
|-
| Hamal || α Arietis || 2,0&lt;sup&gt;m&lt;/sup&gt;
|-
| Menkalinan || β Aurigae || 2,0&lt;sup&gt;m&lt;/sup&gt;
|-
| Mintaka || δ Orionis || 2,0&lt;sup&gt;m&lt;/sup&gt;
|-
| Mirfak || α Persei || 2,0&lt;sup&gt;m&lt;/sup&gt;
|-
| Saiph || κ Orionis || 2,0&lt;sup&gt;m&lt;/sup&gt;
|-
| Schedir || α Cassiopeiae || 2,0&lt;sup&gt;m&lt;/sup&gt;
|-
| Tsih || γ Cassiopeiae || 2,0&lt;sup&gt;m&lt;/sup&gt;
|-
| Ruchbah || δ Cassiopeiae || 2,7&lt;sup&gt;m&lt;/sup&gt;
|}

Abgesehen von den in Bezug auf die beschriebene Region auf der linken Seite deutlich abgelegenen Sterne Sirius, Rigel und Saiph und den weit oberhalb gelegen Sternen Menkalinan und Capella im Sternbild Fuhrmann (Auriga) können alle anderen hellen Sterne der Himmelstafel zugeordnet werden.

&lt;gallery caption=&quot;Einpassung der Himmelstafel von Tal-Qadi in den Fixsternhimmel&quot; widths=&quot;360&quot; heights=&quot;360&quot; perrow=&quot;4&quot;&gt;
Himmelstafel.Tal-Qadi.Abstand.png|Die geometrischen Verhältnisse beim hier beschriebenen Einpassen der Himmelstafel von Tal-Qadi während einer Beobachtung. Bei einem Betrachtungsabstand von 60&amp;nbsp;Zentimetern kann die Himmelstafel von altersweitsichtigen Personen auch bei schlechten Lichtverhältnissen ohne eine Sehhilfe scharf gesehen werden, wie zum Beispiel von älteren und erfahrenen Tempeldienern, die die Tafel in Tal-Qadi benutzt haben könnten.
Himmelstafel.Tal-Qadi.Zuordnung.png|Mögliche Zuordnung der hellsten Himmelsobjekte zu den im Bereich der eingepassten Himmelstafel von Tal-Qadi dargestellten Sterne.
Himmelstafel.Tal-Qadi.Winkel.png|Die Winkelmaße der fünf Segmente der Himmelstafel, die insgesamt einen Winkel von 110&amp;nbsp;Bogengrad aufspannen. Der Winkel von 24&amp;nbsp;Bogengrad im rechten Segment entspricht exakt der Neigung der Ekliptik zum Äquator vor 5000&amp;nbsp;Jahren (heute 23,4&amp;nbsp;Bogengrad). Wenn die rechte lange Kante senkrecht zur Ekliptiklinie auf den Nordpol der Ekliptik N&lt;sub&gt;Ek&lt;/sub&gt; ausgerichtet war, zeigte die Linie zwischen dem vierten und fünften Segment demzufolge in Richtung Himmelsnordpol N&lt;sub&gt;Äq&lt;/sub&gt;, von Tal-Qadi aus gesehen 36&amp;nbsp;Bogengrad über dem Horizont ungefähr in die Richtung, wo sich der Ätna befindet. Die Winkel der drei mittleren Segmente mit dem Goldenen Tor der Ekliptik addieren sich zu 60&amp;nbsp;Bogengrad.
Himmelstafel.Tal-Qadi.Himmelsstier.png|Markierung des '''Himmelsstieres '''auf der Himmelstafel von Tal-Qadi. Der Körper des Stieres umspannt exakt die lange gerade Kante der Himmelstafel, die senkrecht und mittig auf der Ekliptiklinie steht. Siehe hierzu auch '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|Wikibook „Die Himmelstafel von Tal-Qadi“, Kapitel „Astronomische Bezugssysteme“, Abschnitt „Der Himmelsstier“]]'''.
&lt;/gallery&gt;

Es sei angemerkt, dass unter den hier genannten Voraussetzungen das radiale Zentrum der Begrenzungslinien der fünf Segmente der Himmelstafel beim Stern '''ο&amp;nbsp;Tauri''' (omikron Tauri) liegt, der zwar mit einer scheinbaren Helligkeit von 3,5&lt;sup&gt;m&lt;/sup&gt; nicht ganz so hell wie die anderen beschriebenen Sterne im Sternbild '''Stier''' (Taurus) ist, aber dennoch zu den gut erkennbaren Sternen der Region zählt und sich daher sehr gut für eine präzise Einpassung der Tafel verwenden lässt.

Schließlich sei darauf hingewiesen, dass die Himmelstafel durch den großen dargestellten Winkelbereich auch bei störenden Wolken korrekt eingepasst werden kann. Beteigeuze, Aldebaran, Mirfak und Algol sowie die Cassiopeia-Sterne sind über einen so weiten Bereich verteilt, dass auch bei verdeckter Sicht auf vereinzelte Himmelsregionen immer eine zuverlässige Ausrichtung der Himmelstafel möglich ist.

====Linkes Segment (1)====
&lt;gallery widths=&quot;360&quot; heights=&quot;360&quot; caption=&quot;Erstes Segment&quot; perrow=&quot;1&quot;&gt;
Himmelstafel.Tal-Qadi.Zuordnung.1.png
&lt;/gallery&gt;

Der einzelne Stern im linken Segment könnte in dieser Konstellation zum hellsten Stern des gesamten Nachthimmels '''Sirius''' im Sternbild Großer Hund (Canis Major) passen, der auch schon im alten Ägypten im 3.&amp;nbsp;Jahrtausend vor Christus eine Kalenderfunktion hatte, da sein Auftauchen in der Morgendämmerung die Nilflut ankündigte.

Zwischen Sirius und dem Goldenen Tor der Ekliptik liegt allerdings das auffällige Sternbild '''Orion'''. Die Sumerer sahen in diesem Sternbild ein Schaf, der Jäger der griechischen Mythologie Orion und das Sternbild Orion sind erst später belegt. Dessen auffällig roter Schulterstern '''Beteigeuze''' kommt aus geometrischer Sicht eher als der auf der linken Seite der Tafel einzeln dargestellte Stern in Frage. Die sechs zwischen dem radialen Zentrum der Himmelstafel und Beteigeuze dargestellten Linien können in der heutigen Darstellung des Orion hierbei dem aus den '''sechs π-Sternen''' bestehenden Bogen (der zentrale und mit 3&lt;sup&gt;m&lt;/sup&gt; hellste dieser Reihe '''π&lt;sup&gt;3&lt;/sup&gt;&amp;nbsp;Orionis''' wird nach seinem arabischen Namen ''al-thābit'' auch '''Tabit''' genannt), dem Arm zum Stern der Schulter '''Bellatrix''', der Schulterlinie zum Stern der anderen Schulter Beteigeuze sowie unterhalb davon zum Gürtel mit den drei '''Gürtelsternen''' '''Mintaka''', '''Alnilam''' und '''Alnitak''' entsprechen.

====Halblinkes Segment (2)====
&lt;gallery widths=&quot;360&quot; heights=&quot;360&quot; caption=&quot;Zweites Segment&quot; perrow=&quot;1&quot;&gt;
Himmelstafel.Tal-Qadi.Zuordnung.2.png
&lt;/gallery&gt;

Der Y-förmige Teil des Sternbilds '''Taurus''' (Stier) besteht heute aus den folgenden hellen Himmelsobjekten:
* Nördlich der Ekliptik:
** '''Elnath''' (β&amp;nbsp;Tauri, rechte Hornspitze, gehört gleichzeitig zum Sternbild '''Auriga''' (Fuhrmann))
* Südlich der Ekliptik:
** Offener Sternhaufen der '''Hyaden''' (Kopf des Stieres, inklusive '''Ain''')
** '''Aldebaran''' (α&amp;nbsp;Tauri, rotes, rechtes Auge)
** '''Tien Kuan''' (ζ&amp;nbsp;Tauri, linke Hornspitze)

Die Linien zwischen unterhalb der Hyaden können mit den dunkleren, noch mit bloßem Auge sichtbaren Sternen im Sternbild Stier (namentlich '''λ&amp;nbsp;Tauri''' (3,5&lt;sup&gt;m&lt;/sup&gt;) und '''e&amp;nbsp;Tauri''' (5&lt;sup&gt;m&lt;/sup&gt;)) zusammenhängen und auf den Stern '''ο&amp;nbsp;Tauri''' an der unteren Spitze der ausgerichteten Himmelstafel zulaufen.

Die Spitze zwischen dem halblinken und dem mittleren Segment markiert das vierte Mondhaus '''Manazil al-Qamar Aldebaran''', also beim ''Nachfolgenden'' der Plejaden, dem Roten Riesen Aldebaran, (indisch: ''Nakshatra Rohini'', ''der Rötliche'') .

====Mittleres Segment (3)====
&lt;gallery widths=&quot;360&quot; heights=&quot;360&quot; caption=&quot;Drittes Segment&quot; perrow=&quot;1&quot;&gt;
Himmelstafel.Tal-Qadi.Zuordnung.3.png
&lt;/gallery&gt;
[[Datei:Ekliptik.Horizont.png|mini|hochkant=2|Die Ekliptik über dem Horizont in Blickrichtung Süden beim Sonnenuntergang zum Frühlingsanfang.]]

Der Bogen mit der dazwischenliegenden geraden Linie im mittleren Segment der Himmelskarte von Tal-Qadi dürfte kein Symbol für ein Tor sein. Tore mit halbrunden Bogen waren während der Entstehungszeit der Himmelstafel in der Tarxien-Phase noch gar nicht verbreitet.

Es muss in diesem Zusammenhang jedoch zur Kenntnis genommen werden, dass die Ekliptik vom Horizontsystem der Erde aus gesehen einen konvexen Kreisbogen darstellt, der den Horizont an zwei Punkten schneidet und sich unterhalb von diesem fortsetzt. Wegen der großen Ähnlichkeit ist es nicht abwegig anzunehmen, dass das im mittleren Segment der Steintafel gezeigte Symbol, das genau im Goldenen Tor der Ekliptik liegt, den Kreisbogen der Ekliptik über dem Horizont und auch noch etwas unterhalb des Horizonts darstellt.

Vor 4500&amp;nbsp;Jahren befand sich der Frühlingspunkt auf der ausgerichteten Himmelstafel in dem D-förmigen Symbol dieses mittleren Segments.

&lt;div class=&quot;tright&quot; style=&quot;clear:none;&quot;&gt;
[[Datei:Monduntergang.P1067556.jpg|mini|Monduntergang am Horizont des westlichen Morgenhimmels.]]
&lt;/div&gt;

Neben der einfachen Deutung des Kreisbogens im mittleren Winkelsegment der Himmelstafel als Bogen der Ekliptik über dem Horizont gibt es noch eine weitere Möglichkeit für eine Erklärung: heute kann zur Wintersonnenwende morgens alle 19&amp;nbsp;Jahre der Vollmond im Goldenen Tor der Ekliptik beim Untergang beobachtet werden, wo er dann direkt über dem westlichen Horizont oder an der oberen Kante der eingepassten Himmelstafel als nach oben gewölbter Halbkreis zu sehen ist.

====Halbrechtes Segment (4)====
&lt;gallery widths=&quot;360&quot; heights=&quot;360&quot; caption=&quot;Viertes Segment&quot; perrow=&quot;1&quot;&gt;
Himmelstafel.Tal-Qadi.Zuordnung.4.png
&lt;/gallery&gt;
[[Datei:Himmelstafel.Tal-Qadi.eingepasst.Detail.mit.Mond.png|mini|hochkant=2|rechts|Detail an der rechten, 22 Zentimeter langen Kante der in 60&amp;nbsp;Zentimeter Betrachtungsabstand eingepassten Himmelstafel mit maßstäblich dargestellten Vollmonden. Die roten Linien zeigen die senkrecht auf der rechten Kante der Tafel stehende Ekliptik sowie parallel dazu die beiden extremen ekliptikalen Breiten der Mondbahn nördlich und südlich der Ekliptik an. Trifft der Mond die Kerbe an der langen Kante der Himmelstafel (grau), kommt es einen Tag später zu einer Bedeckung der Plejaden. Auch bei der maximal südlichsten Lage der Ekliptik ist an der langen Kante eine eingekerbte Markierung zu erkennen. Trifft der Mond diese Stelle, kommt es anderthalb Tage später zur Bedeckung des Sterns Aldebaran.]]

Im Sternbild '''Taurus''' (Stier) liegt nördlich der Ekliptik der offene Sternhaufen der '''Plejaden''', die im halbrechten Segment dargestellt sind. Im Schwerpunkt dieser Darstellung befinden sich nach der Ausrichtung der Himmelstafel die Plejaden und somit die ekliptikale Länge des dritten Mondhauses '''Manazil al-Qamar Thuraya''' (indisch: ''Nakshatra Krittika''). Von Plejaden in Richtung radialem Zentrum der Himmelstafel sind mehrere Striche vorhanden, die die entsprechenden dort liegenden Sterne andeuten könnten (namentlich '''ξ&amp;nbsp;Tauri''' (3,5&lt;sup&gt;m&lt;/sup&gt;), '''s&amp;nbsp;Tauri''' (5&lt;sup&gt;m&lt;/sup&gt;) und '''f&amp;nbsp;Tauri''' (4&lt;sup&gt;m&lt;/sup&gt;)). Die Plejaden kreuzten den Horizont vor 5000&amp;nbsp;Jahren beim Untergang fast senkrecht und exakt im Westen und beim Aufgang exakt im Osten, da deren Deklination damals null Bogengrad betrug.

An der Stelle und in der Richtung, wo in den beiden rechten Winkelsegmenten die dicke Querfurche erkennbar ist, verläuft am Nachthimmel ungefähr die –&amp;nbsp;an dieser Stelle allerdings nur schwach ausgeprägte&amp;nbsp;– Milchstraße. Jenseits der Milchstraße liegen im Segment rechts der Mitte gegenüber den Plejaden zwei Sterne, die mit den beiden Hauptsternen '''Menkalinan''' (links) und '''Capella''' (rechts) des Sternbilds '''Fuhrmann''' (Auriga) identifiziert werden könnten.

Aufgrund der Erfahrungen mit dem Einpassen einer maßstäblichen Replik der Sterntafel in die Konstellation scheinen die beiden Sterne '''ζ&amp;nbsp;Persei''' (4&lt;sup&gt;m&lt;/sup&gt;) und '''Atik''' ('''ο&amp;nbsp;Persei''', 2,7&lt;sup&gt;m&lt;/sup&gt;) dargestellt sein, die heute den hinteren Fuß des Sternbilds '''Perseus''' direkt nördlich der Plejaden bilden. Bei den Babyloniern wurde dieses Sternbild - vermutlich wegen der nach vorne gebeugten Anmutung - als '''Alter Mann''' (SU.GI) bezeichnet. Bei den Beduinen werden die beiden Sterne '''al-Atiq''' (bestehend aus ζ&amp;nbsp;Persei und ο&amp;nbsp;Persei) seit Urzeiten als das Schulterblatt von '''Thuraya''' (auch '''al-Thurayya''') angesehen.&lt;ref&gt;Emilie Savage-Smith: ''Islamicate Celestial Globes - Their History, Construction, and Use'', Smithsonian Studies in History and Technology, Nummer 46, Smithsonian Institution Press, Washington, D.C., 1985&lt;/ref&gt; Die beiden Arme der Thuraya breiten sich vom Betrachter aus gesehen von den Plejaden im Sternbild Stier (Taurus) nach links bis zu '''Menkar''' im Sternbild Walfisch (Cetus) und nach rechts über das Sternbild Perseus bis hin zum Sternbild Kassiopeia (Cassiopeia) aus, wo sich jeweils die Hände befinden. Die deutlich kürzere Hand auf der linken Seite gilt als die amputierte Hand, und die Hand auf der rechten Seite als die mit Henna tätowierte Hand. An der Stelle des tätowierten Handgelenks befinden sich die beiden mondgroßen, mit bloßem Auge sichtbaren offenen Sternhaufen '''h und χ Persei'''.&lt;ref&gt;Danielle Adams: [http://onesky.arizona.edu/2015/12/thuraya-the-abundant-darling-of-the-heavens/ Thuraya, the Abundant Darling of the Heavens - The quintessential asterism], Two Deserts, one sky - Arab Star Calendars, 3 December 2015&lt;/ref&gt;

Eine weitere Möglichkeit der Deutung wäre, dass alle neun mit bloßem Auge sichtbaren Sterne des offenen Sternhaufens der Plejaden in diesem Winkelsegment dargestellt sind, also zusätzlich zu den sieben Hauptsternen auch '''Celaeno''' und '''Asterope''', beziehungsweise die beiden Eltern, also der Titan Atlas und die Okeanide Pleione, mit all ihren sieben Töchtern Alkyone, Asterope, Elektra, Kelaeno, Maia, Merope und Taygete.

====Rechtes Segment (5)====
&lt;gallery widths=&quot;360&quot; heights=&quot;360&quot; caption=&quot;Fünftes Segment&quot; perrow=&quot;1&quot;&gt;
Himmelstafel.Tal-Qadi.Zuordnung.5.png
&lt;/gallery&gt;

Das rechte Segment zeigt einen Stern, der zu dem sehr hellen, mitten in der Milchstraße liegenden Stern '''Mirfak''' im Sternbild '''Perseus''' passt. Diesseits der Milchstraße gibt es in diesem Segment die drei hellen Sterne '''Algol''' im Sternbild '''Perseus''', '''Alamak''' im Sternbild '''Andromeda''' und ganz unten eventuell auch noch '''Hamal''' im Sternbild '''Widder''' (Aries). Dahinter liegt das sehr auffällige Sternbild '''Kassiopeia''' (Cassiopeia oder auch '''Himmels-W''') mit seinen fünf Sternen, von denen Segin (ε&amp;nbsp;Cassiopeiae, 3,3&lt;sup&gt;m&lt;/sup&gt;) allerdings erkennbar dunkler ist als '''Ruchbah''', '''Tsih''', '''Shedar''' und '''Caph'''.

Die Konstellation dieser vier Sterne könnte also in der rechten Ecke der Himmelstafel angedeutet sein. Hierzu kann zur Kenntnis genommen werden, dass von Malta aus gesehen heute lediglich die Sternbilder Giraffe (Carmelopardalis), Kassiopeia, Kepheus (Cepheus) und Kleiner Bär (Ursa Minor) vollständig zirkumpolar sind. Von diesen vier Sternbildern hat nur das Sternbild Kassiopeia vier Sterne zweiter Größenklasse (2&lt;sup&gt;m&lt;/sup&gt;) und ist somit zu jedem Zeitpunkt der Nacht und sogar in der Dämmerung einfach und eindeutig zu erkennen. Vor 4500&amp;nbsp;Jahren lag der nördliche Himmelspol allerdings zwischen dem Großen Wagen im Großen Bären (Ursa Major) und dem Kleinen Bären (Ursa Minor), und nur die heutigen Sternbilder Kleiner Bär (Ursa Minor) und der langegezogene Drache (Draco) waren damals zirkumpolar. Das Sternbild Kassiopeia stand aber immerhin 15&amp;nbsp;Stunden lang täglich über dem Horizont und kündigte mit seinem Aufgang rechtzeitig den Aufgang der Plejaden an.

In diesem Zusammenhang sei auch darauf hingewiesen, dass die Trennlinie zwischen dem halbrechten und dem rechten Segment der ausgerichteten Himmelstafel damals genau auf die Pole des Himmelsäquators gezeigt hat. Ferner zeigt die senkrecht auf der Ekliptik stehende langen Kante der ausgerichteten Tafel naturgemäß auf die beiden Himmelspole des ekliptikalen Koordinatensystems. Die '''Schiefe der Ekliptik''' zum Datum 2500 vor Christi Geburt entspricht mit 24 Bogengrad erstaunlich genau dem Winkel des rechten Segments der Himmelstafel.

Die lange Kante der ausgerichteten Himmelstafel befindet sich im zweiten Mondhaus '''Manazil al-Qamar Botein''', also im '''Bäuchlein''' des Widderlammes, (indisch: ''Nakshatra Bharani'', der ''Wegtragende'') und lässt sich zum Ablesen der vom Mond erreichten ekliptikalen Breiten verwenden. Die markante Kerbe an dieser Kante markiert die nördliche ekliptikale Breite der Plejaden. Die ekliptikalen Breiten des Mondes ändern sich an dieser Stelle wegen der Nähe zum Maximum der nördlichen ekliptikalen Breite nur langsam, so dass es am Folgetag zur '''Bedeckung der Plejaden durch den Mond''' kommen wird, wenn der Mond auf diese Kerbe stößt. Dies war zu allen Zeiten ein besonderes Ereignis, so dass diese auffällige Markierung eventuell auch in diesem Zusammenhang als ein Werkzeug für eine solche Vorhersage gesehen werden kann. Da die von dieser Kerbe ausgehende Furche in Richtung des vierten Winkelsegments der Himmelstafel in noch größere nördliche ekliptikale Breiten führt, könnte diese Furche eventuell auch die Tatsache symbolisieren, dass der Mond sogar außerhalb des Goldenen Tors der Ekliptik nördlich an den Plejaden vorbeiziehen kann.

===Lage der Ekliptik in Malta===
[[Datei:Himmelstafel.Tal-Qadi.W.png|mini|rechts|hochkant=2|Lage von '''Horizont''' (grün), '''Himmelsachse''' (blau) und '''Ekliptik''' (rot) mit dem '''Frühlingspunkt im Westpunkt''' (Höhe = 0&amp;nbsp;Bogengrad, ekliptikale Länge = 0&amp;nbsp;Bogengrad und Azimut = 270&amp;nbsp;Bogengrad) von Malta aus gesehen im Jahr 2500&amp;nbsp;vor Christus. Die winkeltreue Abbildung basiert auf einer Blickrichtung zum Azimut 300&amp;nbsp;Bogengrad auf dem Horizont. Der '''Meridian''' (ebenfalls grün) ist der Großkreis, der die drei Nordpole und die drei Südpole der drei sphärischen Koordinatensysteme sowie den '''Zenit''' und den '''Nadir''' miteinander verbindet. Er kreuzt die Ekliptiklinie bei den beiden ekliptikalen Längen 90&amp;nbsp;Bogengrad und 270&amp;nbsp;Bogengrad.]]

Die Ekliptik kreuzt auf der geographischen Breite von Malta (zirka 36&amp;nbsp;Bogengrad) den Horizont '''in westlicher Richtung''' je nach Epoche, Tages- und Jahreszeit zwischen den Azimuten 240&amp;nbsp;Bogengrad und 300&amp;nbsp;Bogengrad, also in einem Bereich zwischen 30&amp;nbsp;Bogengrad südlich (links) und 30&amp;nbsp;Bogengrad nördlich (rechts) um den Westpunkt (Azimut = 270&amp;nbsp;Bogengrad). Die Schwankungen der azimutalen Lage der Ekliptik auf dem Horizont im Laufe der letzten Jahrtausende waren von Malta aus gesehen moderat:

* Zur Tag-und-Nacht-Gleiche im Frühling
** bei Sonnenaufgang relativ flach genau im Westen (Azimut = 270&amp;nbsp;Bogengrad)
** mittags südlicher (Azimut = 240&amp;nbsp;Bogengrad)
** bei Sonnenuntergang mit der Sonne '''fast senkrecht genau im Westen''', im Frühlingspunkt und im Goldenen Tor der Ekliptik (Azimut = 270&amp;nbsp;Bogengrad)
** um Mitternacht nördlicher (Azimut = 300&amp;nbsp;Bogengrad)
* Zur Sommersonnenwende
** bei Sonnenaufgang südlicher (Azimut = 240&amp;nbsp;Bogengrad)
** mittags '''fast senkrecht genau im Westen''', im Frühlingspunkt und im Goldenen Tor der Ekliptik (Azimut = 270&amp;nbsp;Bogengrad)
** bei Sonnenuntergang nördlicher (Azimut = 300&amp;nbsp;Bogengrad)
** um Mitternacht relativ flach genau im Westen (Azimut = 270&amp;nbsp;Bogengrad)
* Zur Tag-und-Nacht-Gleiche im Herbst
** bei Sonnenaufgang '''fast senkrecht genau im Westen''', im Frühlingspunkt und im Goldenen Tor der Ekliptik (Azimut = 270&amp;nbsp;Bogengrad)
** mittags nördlicher (Azimut = 300&amp;nbsp;Bogengrad)
** bei Sonnenuntergang mit der Sonne relativ flach genau im Westen (Azimut = 270&amp;nbsp;Bogengrad)
** um Mitternacht südlicher (Azimut = 240&amp;nbsp;Bogengrad)
* Zur Wintersonnenwende
** bei Sonnenaufgang nördlicher (Azimut = 300&amp;nbsp;Bogengrad)
** mittags relativ flach genau im Westen (Azimut = 270&amp;nbsp;Bogengrad)
** bei Sonnenuntergang mit der Sonne südlicher (Azimut = 240&amp;nbsp;Bogengrad)
** um Mitternacht '''fast senkrecht genau im Westen''', im Frühlingspunkt und im Goldenen Tor der Ekliptik (Azimut = 270&amp;nbsp;Bogengrad)

In Malta erreicht der Vollmond zur Sommersonnenwende um Mitternacht heute je nach ekliptikaler Breite nur eine Horizonthöhe von rund 25&amp;nbsp;bis 35&amp;nbsp;Bogengrad, die Sonne steht dann mittags allerdings mit einer Horizonthöhe von 77,5&amp;nbsp;Bogengrad (vor 4500&amp;nbsp;Jahren ungefähr 78&amp;nbsp;Bogengrad) fast im Zenit (Horizonthöhe = 90&amp;nbsp;Bogengrad), und es resultiert der längste Tag des Jahres. Zur Wintersonnenwende ist es umgekehrt, und es ergibt sich bei rund 30&amp;nbsp;Bogengrad der niedrigste Sonnenstand und damit der kürzeste Tag des Jahres. Bei der Tag-und-Nacht-Gleiche zum Herbstanfang erreicht die Ekliptik zum Sonnenaufgang ihre maximale Höhe und maximal über dem Horizont sichtbare Bogenlänge und zum Sonnenuntergang das jeweilige Minimum, bei der Tag-und-Nacht-Gleiche zum Frühlingsanfang ist es wiederum umgekehrt.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

===Verschiedene Lagen der eingepassten Himmelstafel===
In diesem Abschnitt sind die fünf winkeltreuen Lagen der in den Himmelsstier eingepassten Himmelstafel von Tal-Qadi in den fünf verschiedenen Himmelsrichtungen Osten, Südosten, Süden, Südwesten und Westen um 2500&amp;nbsp;vor Christus von Malta aus gesehen dargestellt.

Die Verbindungslinie zwischen Plejaden und Hyaden im Goldenen Tor der Ekliptik kreuzte damals den Frühlingspunkt auf der Ekliptik (ekliptikale Länge 0&amp;nbsp;Bogengrad). Der Horizont mit den dazugehörigen Himmelsrichtungen ist jeweils als grüne durchgezogene horizontale Linie und dargestellt; ebenfalls grün sind der Meridian mit Zenit und Nadir. Die Ekliptiklinie und die entsprechenden ekliptikalen Längen sind rot dargestellt, ebenso wie der ekliptikale Großkreis, der die Ekliptik im Frühlingspunkt senkrecht schneidet, sowie der Nordpol und der Südpol der Ekliptik. Die Ekliptik hatte eine Neigung von zirka 24&amp;nbsp;Bogengrad zum Äquator.

Die blauen Linien zeigen den senkrecht zum Himmelsäquator durch den Frühlingspunkt laufenden Großkreis des äquatorialen Koordinatensystems mit Himmelsnordpol und Himmelssüdpol. Der Himmelsnordpol hat von Malta aus gesehen eine Höhe von rund 36&amp;nbsp;Bogengrad über dem Horizont. Liegen Frühlingspunkt und Herbstpunkt genau in Richtung Osten und Richtung Westen schneiden sich dort alle Großkreise auf dem Horizont.

Die roten gepunkteten Linien zeigen die verlängerten Richtungen der langen gerade Kante der Himmelstafel zu den Ekliptikpolen an. Die blauen gepunkteten Linien zeigen die verlängerten Richtungen der um 24&amp;nbsp;Bogengrad zur langen Kante der Himmelstafel geneigten Trennline zwischen den beiden rechten Winkelsegmenten der Himmelstafel zu den Polen der Himmelskugel an.

{| class=&quot;wikitable&quot;
|+ Die Lage der Himmelstafel von Tal-Qadi in verschiedenen Himmelsrichtungen
!title=&quot;Richtung des Frühlingspunkts&quot;| Richtung des Frühlingspunkts
!title=&quot;Osten&quot;| Osten
!title=&quot;Südosten&quot;| Südosten
!title=&quot;Süden&quot;| Süden
!title=&quot;Südwesten&quot;| Südwesten
!title=&quot;Westen&quot;| Westen
|-
| '''Darstellung der eingepassten&lt;br/&gt;Himmelstafel von Tal-Qadi mit den&lt;br/&gt;&lt;span style=&quot;color:#00BF00&quot;&gt;horizontalen (grün)&lt;/span&gt;,&lt;br/&gt;&lt;span style=&quot;color:#0000FF&quot;&gt;äquatorialen (blau)&lt;/span&gt; und&lt;br/&gt;&lt;span style=&quot;color:#FF0000&quot;&gt;ekliptikalen (rot)&lt;/span&gt;&lt;br/&gt;Koordinatensystemen''' || [[Datei:Himmelstafel.Tal-Qadi.O.png|240px]] || [[Datei:Himmelstafel.Tal-Qadi.SO.png|240px]] || [[Datei:Himmelstafel.Tal-Qadi.S.png|240px]] || [[Datei:Himmelstafel.Tal-Qadi.SW.png|240px]] || [[Datei:Himmelstafel.Tal-Qadi.W.png|240px]]
|-
| '''Sichtbarkeit zur&lt;br/&gt;Tag-und-Nacht-Gleiche im Frühling''' || – || – || – || – || abends
|-
| '''Sichtbarkeit zur&lt;br/&gt;Sommersonnenwende''' || frühmorgens || – || – || – || –
|-
| '''Sichtbarkeit zur&lt;br/&gt;Tag-und-Nacht-Gleiche im Herbst''' || spätabends || mitternachts || frühmorgens || morgens || –
|-
| '''Sichtbarkeit zur&lt;br/&gt;Wintersonnenwende''' || – || spätnachmittags || abends || spätabends || mitternachts
|}

===Auf- und Untergänge===
[[Datei:Himmelstafel.Tal-Qadi-Aufgang.Plejaden.png|mini|rechts|hochkant=2|Die eingepasste Himmelstafel beim Aufgang der Plejaden am östlichen Horizont von Malta.]]

Beim '''Aufgang''' stehen die Plejaden im Osten fast senkrecht über den Hyaden, und die Ekliptik verläuft dann nicht aufrecht, sondern relativ flach zum Horizont nach Süden hin ansteigend.

Der '''Aufgang''' der Plejaden wurde bereits vier Stunden im Voraus durch die oben im rechten Winkelsegment genannten Sterne angekündigt. Kassiopeia ging auf Malta damals genau im Nordosten auf, zwei Stunden später etwas weiter östlich gefolgt von Mirfak (α&amp;nbsp;Persei) und Alamak (γ&amp;nbsp;Andromedae). Ungefähr eine Stunde danach erschienen Algol (β&amp;nbsp;Persei) und Hamal (α&amp;nbsp;Arietis), eine weitere Stunde später genau im Osten die Plejaden sowie noch eine Stunde später dann dort die Hyaden und der Rote Riese Aldebaran (α&amp;nbsp;Tauri, arabisch ''al-dabaran'' für ''der (Nach-)folgende''). Noch zwei Stunden später - insgesamt also sieben Stunden nach Kassiopeia - ging schließlich der Rote Überriese Beteigeuze (α&amp;nbsp;Orionis) im Osten auf. Alle genannten Sterne kreuzten den östlichen Horizont beim Aufgang unter einem Winkel von ungefähr 45&amp;nbsp;Bogengrad.

Eventuell könnte die dicke Querfurche in den beiden rechten Segmenten der Himmelstafel den Verlauf des östlichen Horizonts vor dem '''Aufgang''' der Plejaden andeuten, die damals fast exakt im Osten aufgegangen waren. Von Tal-Qadi aus gesehen wird der Horizont in Richtung Osten durch einen flachen Hügel bestimmt. Wenn die Furche während des Aufgangs der Plejaden mit der Kontur dieses Hügels in Übereinstimmung gebracht wurde, waren '''Mirfak''' (α&amp;nbsp;Persei), '''Algol''' (β&amp;nbsp;Persei) und '''Hamal''' (α&amp;nbsp;Arietis) bereits gut eine Stunde zu sehen, und '''Bharani''' (41&amp;nbsp;Arietis oder auch '''Nair al Butain''') war knapp eine Stunde vorher sowie '''Atik''' (ο&amp;nbsp;Persei) nur knapp eine halbe Stunde zuvor aufgegangen. Da die beiden Sterne Atik und Bharani zur Einpassung der Himmelstafel verwendet werden können, ist auf diese Weise über die Darstellungen auf der Himmelstafel eine Lagebestimmung der Plejaden und von Aldebaran möglich, obwohl sich diese noch unter dem Horizont befinden und somit gar nicht sichtbar sind.

Die untere Spitze der eingepassten Himmelstafel steht bei der schwierigen letzten, nur kurzzeitigen Möglichkeit zur Beobachtung der Plejaden am westlichen Abendhimmel ungefähr auf dem Horizont. Nach diesem akronychischen '''Untergang''' beziehungsweise Abendletzt (heute um den 1.&amp;nbsp;Mai) sind sie in den nördlichen subtropischen Breiten mit bloßem Auge für vierzig Tage nicht mehr als Siebengestirn zu sehen. Stehen die Plejaden an diesem Abend noch höher, werden die dunkleren Sterne des Sternhaufens vom Tageslicht überstrahlt, stehen sie bereits niedriger, wird deren schwaches Licht auf dem langen Weg durch die Atmosphäre durch die Lichtstreuung und die vermehrte Extinktion verschleiert.

Am westlichen Himmel von Malta befinden sich Aldebaran und die Hyaden zum Frühlingsbeginn etwas südlich (links unterhalb) und die Plejaden etwas nördlich (rechts oberhalb) der Ekliptik. Die Verbindungslinie zwischen den Sternhaufen ist beim '''Untergang''' dieser Sterne dann also in etwa parallel zum Horizont.

Beim '''Untergang''' verschwand von diesen Sternen damals zuerst Hamal (α&amp;nbsp;Arietis) genau im Westen, eine Stunde danach gefolgt von Alamak (γ&amp;nbsp;Andromedae) etwas weiter nördlich und vom heutigen Sternbild Kassiopeia zuerst Caph (β&amp;nbsp;Cassiopeiae) im Nordwesten. Ungefähr eine weitere Stunde später folgten das Goldene Tor der Ekliptik im Westen und Algol (β&amp;nbsp;Persei) sowie Mirfak (α&amp;nbsp;Persei) etwas weiter nördlich. Die Sterne Algol (β&amp;nbsp;Persei) und Ruchbah (δ&amp;nbsp;Cassiopeiae) gingen hierbei erst gleichzeitig mit den Plejaden unter und danach ebenfalls gleichzeitig Aldebaran (α&amp;nbsp;Tauri) und Mirfak (α&amp;nbsp;Persei) sowie übrigens auch zusammen mit dem hellen Stern Rigel (β&amp;nbsp;Orionis). Den Abschluss machte weitere anderthalb Stunden später Beteigeuze (α&amp;nbsp;Orionis) gleichzeitig mit den beiden Hornspitzen des Sternbilds Stier (Taurus) Tien Kuan (ζ&amp;nbsp;Tauri) und Elnath (β&amp;nbsp;Tauri). Alle genannten Sterne kreuzten den westlichen Horizont beim Untergang fast senkrecht.

Die Himmelstafel kann in Verbindung mit den '''Plejaden-Schaltregeln''' unterstützend eingesetzt werden, um anhand der ekliptikalen Länge des Mondes den Beginn des Sonnenjahres beziehungsweise das Erfordernis zum Einsetzen eines Schaltmonats in einem Lunarkalender zu ermitteln.

→ Siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|Kapitel '''Die Plejaden''', Abschnitt '''Schaltregeln''']].
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Praktische Anwendung==
===Übersicht===
Die folgende Galerie zeigt eine Astrophotographie der relevanten Himmelsregion, mit verschiedenen Elementen und schließlich auch der eingepassten Himmelstafel von Tal-Qadi zur besseren Orientierung:

&lt;gallery caption=&quot;Astrophotographie der Himmelsregion am westlichen Nachthimmel im November&quot; widths=&quot;800&quot; heights=&quot;450&quot; perrow=&quot;1&quot;&gt;
Tal-Qadi.Sterne.P1024796.jpg|Photographische Aufnahme mit einem horizontalen Bildwinkel von 100 Bogengrad.
Tal-Qadi.Sternbilder.Sterne.beschriftet.P1024796.jpg|Mit Darstellung und Benennung der heutigen Sternbilder sowie der dazugehörigen Sterne mit Eigennamen
Tal-Qadi.Himmelstafel.P1024796.jpg|Mit eingepasster Himmelstafel
Tal-Qadi.Himmelstafel.Animation.webm|Animation der photographischen Aufnahme mit Einblendung der heutigen Sternbilder, deren Bezeichnungen, deren Sternen mit Eigennamen und der eingepassten Himmelstafel von Tal-Qadi.
&lt;/gallery&gt;

===Vollmond===
Das folgende Bild zeigt, wie mit der Himmelstafel von Tal-Qadi die ekliptikalen Breite des Vollmonds gemessen werden kann, indem sie zwischen vier markanten Sternen eingepasst wird, die in Bezug auf die Plejaden in der Mitte der Anordnung in vier senkrecht zueinanderstehenden Richtungen liegen. Wird die Himmelstafel zwischen dem Hauptstern des Sternbilds Stier (Taurus) '''Aldebaran''' links in der Kerbe des halblinken Segments, dem Sternenpaar '''ζ&amp;nbsp;Persei''' und '''Atik''' im Sternbild Perseus an der Oberkante des halbrechten Segments und '''ο&amp;nbsp;Tauri''' im radialen Zentrum unten eingepasst, schneidet die Ekliptik die gerade Kante am äußersten rechten Segment sowohl mittig als auch senkrecht dazu. Der Stern '''Bharani''' im Widder (Aries) befindet sich dann direkt an der rechten oberen Ecke der langen, geraden Kante.

&lt;gallery caption=&quot;Astrophotographie der Himmelsregion mit Vollmond in der Nacht vom 28. auf den 29. November 2020&quot; widths=&quot;1024&quot; heights=&quot;768&quot; perrow=&quot;1&quot;&gt;
Tal-Qadi.Vollmond.Himmelstafel.P1079912.jpg|Mit eingepasster Himmelstafel (Ekliptik rot gepunktete Linie). Unterhalb vom Mond der rötliche Stern '''Menkar''' ('''α&amp;nbsp;Ceti''') im Sternbild Walfisch (Cetus).
Haende.der.Thuraya.Vollmond.Sterne.P1079912.jpg|Mit dem beduinischen Sternbild '''Hände der Thuraya''' (grüne durchgezogene Linien, die Ekliptik ist als rot gepunktete Linie dargestellt). Die anatomischen Bestandteile von unten Mitte über die Plejaden (Thuraya) nach rechts oben: die amputierte Hand (al-'''kaf al-jadhma''''), Thuraya (die kleine Reichliche, ath-'''thuraya'''), das Schulterblatt (al-''''atiq'''), die Schulter (al-'''mankib'''), der Oberarm (al-'adud), die Ellenbogenspitze (ibrat al-'''mirfaq'''), der Ellenbogen (al-'''mirfaq'''), die Ellenbogengrube (al-ma'bid), der Unterarm von Thuraya (dhira’ ath-thuraya), die Tätowierung de Handgelenks (washm al-mi'sam), die Henna-gefärbte Hand (al-'''kaf''' al-khadib).&lt;br/&gt;Thuraya wird von den Beduinen auch als der fette Schwanz des Asterismus ''Lamm'' (al-hamal) interpretiert. Dies entspricht dem griechischen Sternbild Widder (Aries). Der Stern Hamal steht für die kleinen Hörner des Lammes.&lt;ref&gt;Danielle Adams: [http://onesky.arizona.edu/arab-star-names/the-lamb/ The Lamb - A folkloric celestial complex], Two Deserts, one sky - Arab Star Calendars, 2017&lt;/ref&gt; Der Arm der Thuraya mit der amputierten Hand und der Asterismus Lamm bilden zusammen einen Trichter, durch den alle Wandelgestirne auf der Ekliptik in das Goldene Tor der Ekliptik eintreten. 
&lt;/gallery&gt;

Der Mond hatte während der Aufnahme eine (südliche) ekliptikale Breite von -3,0&amp;nbsp;Bogengrad und stand im zweiten Mondhaus beim Stern Bharani im Sternbild Widder (Aries).

=== Merkur ===
Der Merkur war aber auch auf Malta mit bloßem Auge nur selten zu beobachten und eignete sich nicht, um kontinuierlich mit der Himmelstafel von Tal-Qadi vermessen zu werden. Zudem konnte sie in Ermangelung sichtbarer Fixpunkte dann auch nicht immer zuverlässig in den Sternenhimmel eingepasst werden.

===Venus===
[[Datei:Venus.Plejaden.P1023015.jpg|rechts|mini|hochkant=2|Die Venus am 2. April 2020 kurz vor Beginn der astronomischen Dämmerung bei großer nördlicher ekliptikaler Breite und großer östlicher Elongation kurz vor der Annäherung an die Plejaden.]]

Aufgrund der Eigenbewegung der Plejaden konnte die Venus bei maximaler nördlicher ekliptikaler Breite den südlichsten Stern dieses Sternhaufens, Atlas, vor 4800 Jahren noch bedecken. Danach konnte dann nur noch die Annäherung der Venus an den Sternhaufen beobachtet werden. Heute ist der minimal mögliche Abstand zwischen Atlas und Venus auf über ein halbes Bogengrad angewachsen.

Die folgenden Bilder zeigen ein Anwendungsbeispiel mit der eingepassten Himmelstafel von Tal-Qadi mit der Messung der ekliptikalen Breite der Venus, die im Moment der Aufnahme Ende März 2020 über dem westlichen Horizont des Abendhimmels eine nördliche ekliptikale Breite von 3,0&amp;nbsp;Bogengrad hatte:

&lt;gallery caption=&quot;Anwendungsbeispiel der Himmelstafel bei der Messung der ekliptikalen Breite der Venus&quot; widths=&quot;480&quot; heights=&quot;360&quot; perrow=&quot;2&quot;&gt;
Goldenes.Tor.der.Ekliptik.Venus.Daemmerung.P1022936.jpg|Die helle Venus am 23.&amp;nbsp;März 2020 in der Abenddämmerung mit den hellsten Sternen (bis 4&lt;sup&gt;m&lt;/sup&gt;) elf Tage vor dem Erreichen des Goldenen Tors der Ekliptik bei den Plejaden (Bildmitte).
Goldenes.Tor.der.Ekliptik.Venus.P1022936.jpg|Die Venus bei vollständiger Dunkelheit im Kegel des Zodiakallichts 8&amp;nbsp;Grad über dem westlichen Horizont mit allen Sternen bis zur achten Größenklasse (8&lt;sup&gt;m&lt;/sup&gt;). 
Goldenes.Tor.der.Ekliptik.Venus.Ekliptik.P1022936.jpg|Die nördliche ekliptikale Breite der Venus (dünne rote gestrichelte Linien), also ihr Abstand von der Ekliptik (dicke rote gestrichelte Linie), betrug 3&amp;nbsp;Bogengrad.
Goldenes.Tor.der.Ekliptik.Venus.Ekliptik.Himmelstafel.1.7x.P1022936.jpg|Lage der in 0,6&amp;nbsp;Meter Entfernung vom Beobachter zwischen ο&amp;nbsp;Tauri (Omikron Tauri, unten), Aldebaran (an der Kerbe links oben) und dem hinteren Fuß von Perseus (ζ&amp;nbsp;Persei und Atik rechts oben)) in den Sternenhimmel eingepassten Himmelstafel mit den Ekliptiklinien und den heutigen Sternbildern.
&lt;/gallery&gt;

===Mars===
Hier ein Anwendungsbeispiel mit der zwischen den Sternen Aldebaran (α&amp;nbsp;Tauri) im Sternbild Stier (Taurus), Atik (ζ&amp;nbsp;Persei) im Sternbild Perseus, Bharani (41&amp;nbsp;Arietis) im Sternbild Widder (Aries) und ο&amp;nbsp;Tauri (omikron&amp;nbsp;Tauri) eingepassten Himmelstafel von Tal-Qadi bei der Messung der ekliptikalen Breite vom Planeten Mars am 12.&amp;nbsp;Februar 2021, 24&amp;nbsp;Tage vor dessen Erreichen des Goldenen Tors der Ekliptik. Der Mars hatte während der Aufnahme eine (nördliche) ekliptikale Breite von 1,35&amp;nbsp;Bogengrad, und somit nur etwas weniger als der Stern Botein (δ&amp;nbsp;Arietis) direkt links neben Mars in der Abbildung bereits innerhalb der Himmelstafel.

&lt;gallery caption=&quot;Anwendungsbeispiel der Himmelstafel bei der Messung der ekliptikalen Breite des Mars&quot; widths=&quot;960&quot; heights=&quot;720&quot; perrow=&quot;1&quot;&gt;
Goldenes.Tor.Mars.P1090880.png|Messung der ekliptikalen Breite vom Planeten Mars, die Ekliptiklinie ist rot punktiert dargestellt. Das Sternbild Orion befindet sich vollständig am linken Bildrand. Die beiden Sterne Menkar (α&amp;nbsp;Ceti) und Kaffaljidhma (γ&amp;nbsp;Ceti) im Sternbild Walfisch (Cetus) befinden sich in der rechten unteren Ecke. Der Stern Bharani (41&amp;nbsp;Arietis) im Sternbild Widder (Aries) liegt direkt am Bildrand rechts neben der rechten Ecke der Himmelstafel. Links oben direkt südlich der Ekliptik die beiden Sterne Tejat Posterior (μ&amp;nbsp;Gemini oder Calx) und Tejat Prior (η&amp;nbsp;Gemini oder Propus) im Sternbild Zwillinge (Gemini). Oben links der Mitte der Stern Elnath (β&amp;nbsp;Tauri) im Sternbild Stier (Taurus).
&lt;/gallery&gt;

=== Jupiter ===
[[Datei:Jupiter.mit.Io.Ganymed.Europa.Calisto.Vollmond.10.4.2017.jpg|mini|hochkant=2|Die Jupiterscheibe (rechts unten) mit den vier (nur bei voller Bildauflösung und in der Natur nicht mit bloßem Auge erkennbaren) Galileischen Monden Io, Ganymed, Europa und Kallisto (bei maximaler Elongation rechts oberhalb von Jupiter) im Verhältnis zum Vollmond bei der Begegnung am 10.&amp;nbsp;April 2017 im Sternbild Jungfrau (Virgo). Der Winkeldurchmesser der Jupiterscheibe betrug gut 44&amp;nbsp;Bogensekunden, und lag somit unterhalb der Winkelauflösung des menschlichen Auges von einer Bogenminute, so dass Jupiter nicht als flächenhaftes Objekt wahrgenommen werden kann.]]

Anfang des Jahres 2024 wird sich der Planet Jupiter mit einer südlichen ekliptikalen Breite von zirka 0,75&amp;nbsp;Bogengrad nach knapp zwölf Jahren (zuletzt im Juli 2012 prograd (rechtläufig) und Ende Januar 2013 retrograd (rückläufig)) erneut dem Goldenen Tor der Ekliptik nähern. Mitte April erscheint er beim Untergang im Westen an der langen Kante der am abendlichen Himmel ausgerichteten Himmelstafel. Am 18.&amp;nbsp;Mai 2024 steht er dann unsichtbar mit der Sonne in Konjunktion, und eine Woche später hat er die ekliptikale Länge der Plejaden erreicht. Mitte Juni steht er im Goldenen Tor der Ekliptik und kann dann am östlichen Morgenhimmel beim Aufgang beobachtet werden.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

=== Saturn ===
[[Datei:Saturn.P1174966.png|rechts|mini|hochkant=2|Der Planet Saturn am 2. September 2023 von Berlin aus mit einem Teleobjektiv aufgenommen. Der scheinbare Durchmesser der Planetenkugel betrug in Erdnähe nur 19&amp;nbsp;Bogenminuten und der des Ringes nur 44&amp;nbsp;Bogenminuten, so dass beide mit bloßem Auge nicht als Fläche erkennbar waren.]]

Der Saturn hat eine siderische Umlaufzeit von fast dreißig Jahren. Das nächste Mal erreicht er das Goldene Tor der Ekliptik in Bezug auf den Fixsternhimmel rechtläufig (prograd) erst im Sommer 2030. Nach einer Kehrtwende beim Stern Ain im September und Oktober 2030 passiert er das Goldene Tor der Ekliptik im November und Dezember 2030 noch einmal rückläufig (retrograd). Nach einer erneuten Kehrtwende Anfang Februar 2031 wird er dann wieder rechtläufig (prograd) und passiert von Ende März bis Anfang April 2031 schließlich zum dritten Mal das Goldene Tor der Ekliptik. Am 24.&amp;nbsp;April 2031 kommt es in nördlichen Breiten am Nachmittag in wenigen Bogengrad Entfernung von den beiden Sternen Ain und Aldebaran zu einer Bedeckung des Saturns durch den nicht einmal drei Tage alten Mond, die wegen des Tageslichts in Europa allerdings mit bloßem Auge nicht zu beobachten sein wird.

Im September 2059 wird er dann bereits kurz vor dem Erreichen des Goldenen Tors der Ekliptik rückläufig (retrograd) und Ende Januar 2060 wieder rechtläufig (prograd), so dass er dann nur einmal im Mai 2060 in Konjunktion mit der Sonne hindurchtritt.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Schlussbetrachtung==
Jeder Astronom weiß, wie schwierig es ist, in der Dunkelheit der Nacht Geräte zu bedienen sowie Dokumente zu lesen oder zu schreiben. Eine gut ertastbare und gegebenenfalls vom Dämmerlicht oder von roter Glut in moderater und für eine gleichzeitige Himmelsbeobachtung hinreichend beleuchtete Tafel ist in diesem Kontext gewiss ein brauchbares Hilfsmittel.

[[Datei:Himmelstafel.Tal-Qadi.Himmelsstierregion.png|mini|zentriert|hochkant=4|Die in den Asterismus Himmelsstier (gelbe Linien) eingepasste Himmelstafel von Tal-Qadi mit roten Orientierungslinien für die Ekliptik (dicke gepunktete Linie), für den Schwankungsbereich der ekliptikalen Breites des Mondes (dünne gepunktete Linien 5,5&amp;nbsp;Bogengrad südlich und nördlich der Ekliptiklinie) sowie für die Nordrichtung (grün).&lt;br/&gt;
In der Mitte der Himmelsstier, der neben dem Sternbild Stier (Taurus) unten in der Mitte auch den hellen Stern Menkar (α&amp;nbsp;Ceti) im Sternbild Walfisch (Cetus) und das Sternbild Widder (Aries, rechts vom Vollmond) umfasst.&lt;br/&gt;
Der helle Rote Riese Aldebaran befindet sich an der linken Kerbe der Himmelstafel, der hintere Fuß des Perseus (ς&amp;nbsp;Persei und Atik) am oberen kleinen Bogen der Himmelstafel, ο&amp;nbsp;Tauri unten an der Ecke der Himmelstafel und Bharani (41 Arietis oder auch Nair al Butain) an der rechten Ecke der Himmelstafel.&lt;br/&gt;
Die Ekliptik kreuzt die Mitte der langen Kante der Himmelstafel senkrecht, das halbkreisförmige Symbol in der Mitte der Himmelstafel und die Spitze der Himmelstafel (links oben im Bild). Die Plejaden befinden sich in der Mitte des vierten Winkelsegments der Himmelstafel von links. Die Pole des ekliptikalen Koordinatensystems liegen in Verlängerung der langen Kante der Himmelstafel (dünne rote gepunktete Linie). Die Himmelspole des äquatorialen Koordinatensystems liegen um 24° versetzt in Richtung der Linie zwischen den beiden rechten Winkelsegmenten der Himmelstafel. Die ekliptikale Breite der Wandelgestirne kann an der langen Kante der Himmelstafel (dünne rote gepunktete Linie) senkrecht zur Ekliptiklinie abgelesen werden. Der Vollmond befand sich während der Aufnahme südlich der Ekliptik (ekliptikale Breite = -3&amp;nbsp;Bogengrad).&lt;br/&gt;
Links unten das Sternbild Orion, rechts oberhalb der Himmelstafel das Sternbild Perseus, links oberhalb der Himmeltafel das Sternbild Fuhrmann (Auriga), rechts oben das Sternbild Kassiopeia (Himmels-W), links oben das Sternbild Zwillinge (Gemini), rechts neben der Himmelstafel das kleine Sternbild Dreieck (Triangulum) und rechts außen das Sternbild Andromeda.&lt;br/&gt;
Bemerkenswert ist die Ähnlichkeit dieser Geometrie mit der jungsteinzeitlichen Darstellung der [[Die_Höhlenmalerei_in_der_Magura-Höhle#Zweite_Station|'''zweiten Station in der Höhle von Magura''']]:
&lt;gallery caption=&quot;Der Himmelsstier&quot; widths=300 heights=300 perrow=3&gt;
Vollmond.Trichter.Thuraya.P1079912.jpg|Astronomische Aufnahme mit dem Vollmond in der Himmelsregion der heutigen Sternbilder Stier (links oben), Walfisch (unten) und Widder (rechts). Die Ekliptik verläuft vom '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Trichter_der_Thuraya|Trichter der Thuraya]]''' rechts unten durch das Goldene Tor der Ekliptik in der Bildmitte nach links oben durch die Mitte zwischen den Spitzen der Stierhörner.
Vollmond.Stiersymbol.P1079912.png|Astronomische Aufnahme des Vollmonds im Sternbild Stier (Taurus) mit eingeblendetem Himmelsstier-Asterismus. Die Ekliptiklinie kreuzt in etwa die Mittelpunkte der drei gedachten Verbindungslinien Menkar-Sheratan, Aldebaran-Plejaden und Tien Kuan-Elnath.
Stiersymbol.Magura.png|Stiersymbol mit Fußabdruck auf der zweiten Abbildung in der Höhle von Magura.&lt;ref&gt;[http://www.rupestre.net/tracce/wp-content/gallery/magura/16maguracave.jpg Magura cave photogallery number 16], TRACCE, Online Rock Art Bulletin, Nummer 33, 19. November 2014&lt;/ref&gt;
&lt;/gallery&gt;]]

Mit den hier dargelegten und naheliegenden Annahmen wäre die Himmelstafel von Tal-Qadi nicht nur ein historisch bedeutendes Abbild des maltesischen Abendhimmels vor rund 4500&amp;nbsp;Jahren, sondern hätte bereits zu diesem Zeitpunkt für die Bestimmung von kalendarischen Daten und zur Vorhersage von Sternbedeckungen gedient. Dies wäre ein Beleg für die frühen und keineswegs trivialen astronomischen Kenntnisse der damaligen Bewohner der Insel.

Abschließend kann zur Himmelstafel von Tal-Qadi das Folgende festgehalten werden:

* Sie dürfte ein gebrauchstaugliches und nutzwertiges Werkzeug für die Astronomen der Jungsteinzeit gewesen sein.
* Sie kann im Goldenen Tor der Ekliptik zur Bestimmung der ekliptikalen Breiten der Wandelgestirne eingesetzt werden.
* Mit ihr kann im zeitlichen Abstand siderischer Monate das Auf- und Absteigen unseres Mondes verfolgt werden.
* Anhand solcher Beobachtungen des Mondes ergeben sich langfristig der 19-jährige Meton-Zyklus sowie der 18,6-jährige drakonitische Zyklus.
* Mit der Kenntnis solcher Zyklen können Finsternisse und Sternbedeckungen untersucht und vorhergesagt werden.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Widmung==
[[Datei:Goldenes.Tor.der.Ekliptik.Venus.toter.Baum.jpg|mini|rechts|hochkant=2|Das Goldene Tor der Ekliptik als Photomontage mit der Kontur einer abgestorbenen Fichte, die zufälligerweise die Form des Stierkopfs darstellt. Unten in der Mitte die helle Venus, in der Bildmitte die Plejaden und rechts oben das Sternbild Perseus.]]

Diese Zusammenstellung ist dem deutschen Wissenschaftler {{w|Friedrich Wilhelm Bessel}} (*&amp;nbsp;1784; †&amp;nbsp;1846) gewidmet, der völlig zu Unrecht unbeachtet im Schatten der prominenten Persönlichkeiten seiner Zeit und seines Umfelds steht:

[[Datei:Friedrich.Wilhelm.Bessel.Bronzebueste.P1185775.jpg|mini|zentriert|hochkant=1.5|Bronzebüste von Friedrich Wilhelm Bessel im Treppenhaus des Helmert-Hauses auf dem Telegrafenberg in Potsdam]]

Der Hauptautor dankt besonders seinem Hochschullehrer {{w|Fritz Hinderer}} (*&amp;nbsp;1912; †&amp;nbsp;1991). Er hat ihn mit seiner stets freundlichen, interessierten und zugewandten Art sowie seinem profunden Wissen nicht nur die Astrophysik gelehrt, sondern ihm mit seinem sehr umfangreichen astronomischen Handwerkszeug auch die zahlreichen Facetten der astronomischen Beobachtung nahegebracht.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Literatur==
* Markus Bautsch: ''Betrachtungen zur Himmelstafel von Tal-Qadi'', in: ''Journal für Astronomie'', Nummer 80, Seiten 109 bis 113, Vereinigung der Sternfreunde, Heppenheim, Januar 2022, ISSN 1615-0880
* Peter Kurzmann: ''[https://www.archaeologie-online.de/artikel/2016/weitere-untersuchungen-zur-neolithischen-sternkarte-von-tal-qadi-malta/ Weitere Untersuchungen zur neolithischen Sternkarte von Tal-Qadi auf Malta]'', Archäologie Online, archaeomedia, Freiburg, 10. Juli 2016
* Peter Kurzmann: ''[https://www.archaeologie-online.de/artikel/2014/die-neolithische-sternkarte-von-tal-qadi-auf-malta/ Die neolithische Sternkarte von Tal-Qadi auf Malta]'', Archäologie Online, archaeomedia, Freiburg, 25. Juli 2014
* Chris Micallef: ''[https://www.um.edu.mt/library/oar/bitstream/123456789/19785/1/Issue%202%202001%20-%20The%20Tal-Qadi%20Stone%20A%20Moon%20Calendar%20or%20Star%20Map.pdf The Tal-Qadi Stone: a moon calendar or star map]'', in: ''The Oracle'', Ausgabe 2, Seiten 36 bis 44, Grupp Arkeologiku Malti, Malta, January 2001
* Vincent Zammit: ''It-tempju preistoriku tal-Qadi'', in: ''Mument'', Seite 9, Media.Link Communications, 12. Januar 1997

==Einzelnachweise==
&lt;references&gt;&lt;/references&gt;

&lt;noinclude&gt;
{{:Die Himmelstafel von Tal-Qadi/ Navigation}}

[[Kategorie:Buch]]
[[Kategorie:Studium]]
[[Kategorie:Astronomische Kuriositäten‎]]
[[Kategorie:Geometrische Kuriositäten‎]]
&lt;/noinclude&gt;</text>
      <sha1>sqnmajh1j69tic81cieoquzjy90bsxl</sha1>
    </revision>
  </page>
  <page>
    <title>Astronomie von der Frühgeschichte bis zur Neuzeit/ Bedeutung in anderen Disziplinen</title>
    <ns>0</ns>
    <id>121622</id>
    <revision>
      <id>1088598</id>
      <parentid>1088565</parentid>
      <timestamp>2026-07-04T09:26:03Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <comment>Himmelspforte</comment>
      <origin>1088598</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="87899" sha1="4q5aqrlx996t7f2o5v3ekw4bpxzwmvn" xml:space="preserve">Viele Bezeichnungen für verschiedene Lehren werden mit der aus dem Altgriechischen stammenden Endung &quot;-logie&quot; (altgriechisch λόγος (&quot;logos&quot;), zu Deutsch „Lehre“) gebildet. Die folgenden Disziplinen sind in diesem Kontext hervorzuheben, da sie insbesondere für die '''{{w|Archäoastronomie}}''' wertvolle wissenschaftliche Ergänzungen zur '''{{w|Astronomie}}''' (aus den altgriechischen Wörtern ἄστρον (&quot;ástron&quot;, zu Deutsch „Stern“) und νόμος (&quot;nómos, zu Deutsch „Gesetz“) zusammengesetzt also „Sterngesetz“) liefern:

* Die '''{{w|Archäologie}}''' (zusammengesetzt mit dem altgriechischen Wort ἀρχαῖος (&quot;archaios&quot;), zu Deutsch „Altertumslehre“) beschäftigt sich mit der kulturellen Entwicklung der Menschheit.
* Die '''{{w|Etymologie}}''' (zusammengesetzt mit dem altgriechischen Wort ἔτυμος (&quot;etymos&quot;), zu Deutsch „Wortherkunftslehre“) untersucht die geschichtliche Herkunft von Wörtern.
* Die '''{{w|Mythologie}}''' (zusammengesetzt mit dem altgriechischen Wort μῦθος (&quot;mythos&quot;), zu Deutsch „Erzählungslehre“), die sich wissenschaftlich mit der Sagenwelt beschäftigt.
* Die '''{{w|Theologie}}''' (zusammengesetzt mit dem altgriechischen Wort θεός (&quot;theós&quot;), zu Deutsch „Gotteslehre“) mit ihren Lehren zum religiösen Glauben und dessen Glaubensdokumenten.
* Die '''{{w|Kosmologie}}''' (zusammengesetzt mit dem altgriechischen Wort κόσμος (&quot;kósmos&quot;), zu Deutsch „Weltenlehre“) ist hingegen eine Lehre, die sich im Laufe der Jahrtausende deutlich verändert hat und sich auch heute noch erheblich weiterentwickelt, da es in der modernen Astronomie und Astrophysik mit zunehmend hohem technischem Aufwand immer wieder zu neuen Erkenntnissen kommt.
* Die '''{{w|Numerologie}}''' (zusammengesetzt mit dem lateinischen Wort numerus, zu Deutsch „Zahlenlehre“) mit ihren mystischen Lehren über die symbolische Zuweisung von Bedeutungen an Zahlen.

Von der Antike bis ins Mittelalter galt die Beherrschung der '''{{w|sieben freien Künste}}''' als Voraussetzung für das Betreiben von Philosophie. Zu den drei &quot;trivialen&quot; Künsten der {{w|Grammatik}}, der {{w|Rhetorik}} und der {{w|Dialektik}} des '''{{w|Trivium|Triviums}}''' wurden die vier Künste der {{w|Musiktheorie}}, der {{w|Arithmetik}}, der {{w|Geometrie}} und der {{w|Astronomie}} zu den Künsten des '''{{w|Quadrivium|Quadriviums}}''' gezählt → siehe hierzu auch [[Quadriviale_Kuriositäten|'''Wikibook ''Quadriviale Kuriositäten''''']].

== Zur Etymologie ==
Die Genesis aus dem Alten Testament greift die Thematik der Verwirrung der einheitlichen Sprache in ihrem elften Kapitel auf, und beschreibt, wie die bereits sternenkundigen Menschen im Norden Mesopotamiens übermütig geworden waren und in Babel einen Turm mit einer Spitze '''bis in den Himmel''' errichten wollten:&lt;ref&gt;[https://www.bibleserver.com/EU/1.Mose11 Genesis 11], Genesis, Kapitel 11, Einheitsübersetzung&lt;/ref&gt;

&lt;blockquote&gt;
1 Die ganze Erde hatte eine Sprache und ein und dieselben Worte.&lt;br/&gt;
2 Als sie ostwärts aufbrachen, fanden sie eine Ebene im Land Schinar und siedelten sich dort an.&lt;br/&gt;
3 Sie sagten zueinander: Auf, formen wir Lehmziegel und brennen wir sie zu Backsteinen. So dienten ihnen gebrannte Ziegel als Steine und Erdpech als Mörtel.&lt;br/&gt;
4 Dann sagten sie: Auf, bauen wir uns eine Stadt und einen Turm mit einer Spitze '''bis in den Himmel'''! So wollen wir uns einen Namen machen, damit wir uns nicht über die ganze Erde zerstreuen.&lt;br/&gt;
5 Da stieg der HERR herab, um sich Stadt und Turm anzusehen, die die Menschenkinder bauten.&lt;br/&gt;
6 Und der HERR sprach: Siehe, ein Volk sind sie und eine Sprache haben sie alle. Und das ist erst der Anfang ihres Tuns. Jetzt wird ihnen nichts mehr unerreichbar sein, wenn sie es sich zu tun vornehmen.&lt;br/&gt;
7 Auf, steigen wir hinab und verwirren wir dort ihre Sprache, sodass keiner mehr die Sprache des anderen versteht.&lt;br/&gt;
8 Der HERR zerstreute sie von dort aus über die ganze Erde und sie hörten auf, an der Stadt zu bauen.&lt;br/&gt;
9 Darum gab man der Stadt den Namen Babel, Wirrsal, denn dort hat der HERR die Sprache der ganzen Erde verwirrt und von dort aus hat er die Menschen über die ganze Erde zerstreut.
&lt;/blockquote&gt;

Es mag weniger verwunderlich sein, dass Schöpfungsmythen oder Berichte über Katastrophen nicht nur einen astronomischen Hintergrund haben, sondern in völlig verschiedenen Kulturen sehr ähnliche Merkmale zeigen, wenn man sich das Folgende bewusst macht: Einige Indizien deuten auf einen für viele Kulturen gemeinsamen Ursprung hin, der auf eine tiefsinnige Betrachtung und Beobachtung des Himmelsgeschehens hindeutet.

Bei bestimmten Wörtern sind die Ähnlichkeiten in vielen lebenden und toten Sprachen so auffällig, dass sie ein gemeinsames Ursprungswort (Etymon) haben und somit Kognaten sein dürften. 

=== &quot;Stern&quot; ===
Bei den Wörtern „Gestirn“ beziehungsweise „Stern“ sind die Ähnlichkeiten in vielen lebenden und toten Sprachen sehr auffällig, und diese Verwandtschaften mögen durch die Wörter für &quot;Stern&quot; in den folgenden Sprachen belegt werden:

* Akkadisch &quot;istar&quot;
* Indogermanisch &quot;ster&quot;
* Griechisch &quot;astro&quot; / &quot;asteri&quot;
* Lateinisch &quot;astrum&quot; / &quot;stella&quot;
* Althochdeutsch &quot;stern(o)&quot;
* Jiddisch &quot;shtern&quot;
* Katalanisch und Spanisch &quot;estrella&quot;
* Portugiesisch &quot;estrela&quot;
* Englisch &quot;star&quot;
* Niederländisch &quot;ster&quot;
* Westfriesisch &quot;stjer&quot;
* Italienisch und Korsisch &quot;stella&quot;
* Rumänisch &quot;stea&quot;
* Sardisch &quot;istedda&quot;
* Maltesisch &quot;stilla&quot;
* Französisch &quot;étoile&quot; aus Altfranzösisch &quot;estoile&quot;
* Galicisch &quot;estrela&quot;
* Walisisch &quot;seren&quot;
* Dänisch und Norwegisch &quot;stjerne&quot;
* Schwedisch &quot;stjärna&quot;
* Isländisch &quot;stjarna&quot;
* Kurdisch &quot;stêrk&quot;
* Gujarati &quot;Tārō&quot;
* Hindi &quot;तारा&quot; (taara)
* Marathi &quot;तारा&quot; (Tārā)
* Nepalesisch &quot;तारा&quot; (Tārā)
* Punjabi &quot;ਤਾਰਾ&quot; (Tārā)
* Singhalesisch &quot;තරුව&quot; (taruva)
* Khmer &quot;តារា&quot; (tara)
* Armenisch &quot;աստղ&quot; (astgh)
* Tadschikisch &quot;ситора&quot; (sitora)
* Hausa &quot;tauraro&quot;
* Krio &quot;sta&quot;

=== &quot;Stier&quot; ===
Eine starke Ähnlichkeit gibt es in vielen Sprachen auch zwischen den Wörtern „Stern“ und „Stier“. Der Stier bezeichnet zudem auch ein bedeutendes und eines der ältesten Sternbilder überhaupt:

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|'''Himmelsstier''']].

* Akkadisch und Assyrisch &quot;šūru&quot;
* Aramäisch &quot;tōra&quot;
* Hebräisch &quot;šǒr&quot;
* Ugaritisch &quot;twr&quot;
* Arabisch &quot;ثور&quot; (&quot;thawr&quot;)
* Griechisch &quot;ταύρος&quot; (&quot;tauros&quot;)
* Lateinisch &quot;taurus&quot;
* Althochdeutsch &quot;stior&quot;
* Italienisch, Katalanisch und Spanisch &quot;toro&quot;
* Galicisch &quot;touro&quot;
* Gallisch &quot;tarvos&quot;
* Französisch &quot;taureau&quot;
* Schwedisch &quot;tjur&quot;
* Dänisch &quot;tyr&quot;
* Irisch und Gälisch &quot;tarbh&quot;
* Wallisisch &quot;tarw&quot;

=== &quot;Horn&quot; ===
Auch die Hörner des Stieres betreffend setzen sich die vielen Ähnlichkeiten fort:

* Akkadisch &quot;carnu&quot;
* Aramäisch &quot;qeren&quot;
* Griechisch &quot;κόρνο&quot; (&quot;korno&quot;)
* Lateinisch &quot;cornu&quot;
* Maltesisch &quot;qrun&quot;*
* Arabisch &quot;قرون&quot; (&quot;qurun&quot;)
* Französisch &quot;corne&quot;
* Italienisch &quot;corne&quot;
* Rumänisch &quot;corn&quot;
* Haitianisch &quot;kòn&quot;

=== &quot;Sieben&quot; ===
Die in vielen Kulturen als heilig angesehene Zahl Sieben taucht im Zusammenhang mit der Astronomie als Anzahl der mit bloßem Auge sichtbaren Wandelgestirne und als Zahl der Hauptsterne in vielen Asterismen auf:

* Sieben Wandelgestirne: Sonne Mond, Merkur, Venus, Mars, Jupiter, Saturn
* Siebengestirn im Himmelsstier: Alkione, Atlas, Electra, Maia, Merope, Taygeta, Pleione
* Sternbild Orion: Beteigeuze, Rigel, Bellatrix, Alnilam, Alnitak, Saiph, Mintaka
* Asterismus Großer Wagen: Alioth, Dubhe, Alkaid, Mizar, Merak, Phekda, Megrez

→ Siehe auch:

* [[Quadriviale_Kuriositäten/_Zahlen#Zur_Sieben|'''Zur Sieben''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Der_Fixsternhimmel#Die_sieben_hellsten_Objekte_der_Ekliptik|'''Die sieben hellsten Objekte der Ekliptik''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Kalenderführung#Die_Siebentagewoche|'''Die Siebentagewoche''']].

Wegen der hohen kulturellen, rituellen oder mythischen Bedeutung gibt es in vielen Kulturen und Sprachen etymologische Übereinstimmungen:

* Akkadisch &quot;sebe&quot;
* Proto-Indoeuropäisch &quot;septḿ̥&quot;
* Hetitisch &quot;sipta&quot;
* Proto-Germanisch &quot;*sebun&quot;
* Althochdeutsch &quot;sibun&quot;
* Hebräisch &quot;sajin&quot; (Buchstabe) oder &quot;scheva&quot; (Wort)
* Etruskisch &quot;semph&quot;
* Maltesisch &quot;sebgħa&quot;
* Arabisch &quot;sabʿa&quot;
* Griechisch &quot;επτά&quot; (&quot;(h)epta&quot;)
* Lateinisch &quot;septem&quot;
* Ungarisch &quot;het&quot;
* Proto-Balto-slawisch &quot;septin&quot;
* Proto-Indo-Iranisch &quot;saptá&quot;
* Katalanisch &quot;set&quot;
* Spanisch &quot;siete&quot;
* Galicisch &quot;sete&quot;
* Lettisch &quot;septiņi&quot;
* Italienisch &quot;sette&quot;
* Französisch &quot;sept&quot;
* Englisch &quot;seven&quot;
* Wallisisch &quot;saith&quot;
* Bosnisch / Kroatisch &quot;sedam&quot;
* Rumänisch &quot;șapte&quot;
* Irisch &quot;seacht&quot;
* Swahili &quot;saba&quot;
* Haitianisch &quot;sèt&quot;

== Zur Mythologie ==
Seit Jahrtausenden blicken Menschen in den Nachthimmel und versuchen, die unzähligen Lichter am Firmament zu deuten. Schon früh begannen sie, die von ihnen erfundenen Sternbilder und die unablässig durch den Himmel ziehenden Wandelgestirne durch Geschichten über Götter, Helden oder andere Wesen zu interpretieren, zu erzählen und zum Teil über Jahrhunderte hinweg zu tradieren. Die '''Mythologie''' spielte dabei eine zentrale Rolle: Sie half nicht nur, eine symbolische Ordnung in den geheimnisvollen Kosmos zu bringen, sondern prägte auch viele der Bezeichnungen und Vorstellungen, die bis heute in der beschreibenden Astronomie überlebt haben.

Die Verbindung zwischen Mythologie und Astronomie ist tief verwurzelt und zeugt vom menschlichen Bedürfnis, das wahrgenommene, aber dennoch unfassbare Universum durch räumliche und zeitliche Vorstellungen sowie durch Erzählungen begreifbar zu machen. Das Geschehen am Himmel musste auf die Menschen vor der Erfindung der Bewegtbilder und des Films in der späten Neuzeit sowohl attraktiv als auch spektakulär gewirkt haben. So konnten verschiedene mythische Gestalten am Himmel durch ihre scheinbaren Handlungen wahrgenommen werden. Durch die Wiederholung solcher Deutungen konnten sich besonders beliebte Mythen im kulturellen Kontext über die Zeit verfestigen, und entsprechende Riten konnten sich etablieren.

Damit war auch eine wesentliche Voraussetzung für den Glauben der Menschen an eine höhere Macht oder mehrere höhere Mächte gegeben. Der Begriff '''Religion''' stammt vom lateinischen Inifiniv &quot;relegere&quot; ab. Dieses Verb bedeutet wörtlich übersetzt &quot;wieder lesen&quot; und meint im Sinne von &quot;überdenken&quot; das bewusste Wahrnehmen von Prophezeiungen oder Omen sowie das nachhaltige Beachten tradierter Vorschriften.

'''→ Siehe:'''

* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Der Urozean''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Sagenwelt|'''Die Plejaden / Sagenwelt''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Mythologie|'''Der Himmelsstier''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Babylonische_Himmelswege|'''Babylonische Himmelswege''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Mithraskult|'''Mithraskult und Tauroktonie''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Höhlenmalerei_in_der_Magura-Höhle|'''Die Höhlenmalerei in der Magura-Höhle''']].

== Zur Theologie ==
Die '''Theologie''' (vom Altgriechischen θεός = theós = Gott und λόγος = lógos = Lehre) ist die Lehre von einem Gott oder von mehreren Göttern. Sie lehrt einen ausgeprägten religiösen Glauben, begründet rituelle Traditionen und deutet die vorhandenen Glaubensdokumente.

[[Datei:Aristoteles.Theologie.png|mini|rechts|Wahrnehmbarkeit und Vergänglichkeit nach Aristoteles]]

Die Theologie des '''{{w|Aristoteles}}''' (384–322) postuliert drei mögliche Substanzen:&lt;ref&gt;Aristoteles: ''Metaphysik'', Kapitel XII (Λ), Philosophische Theologie, Seiten 1069a –1076a&lt;/ref&gt;

{| class=&quot;wikitable&quot;
|+ Mögliche Substanzen nach Aristoteles
! Nummer !! Substanz !! Erläuterung !! Interpretationsbeispiel
|-
| 1. || Die sinnlich wahrnehmbare und vergängliche Substanz || Konkrete Dinge, die nur eine begrenzte Teilhabe an der Ewigkeit haben. || Lebewesen
|-
| 2. || Die sinnlich wahrnehmbare und unvergängliche Substanz || Konkrete Dinge, die eine unbegrenzte Teilhabe an der Ewigkeit haben. || Die sieben Wandelgestirne und die Fixsterne
|-
| 3. || Die sinnlich nicht wahrnehmbare und unvergängliche Substanz || Lebendiger, unbewegter Beweger, der der Ursprung aller anderen Dinge ist. || Gott
|}

Dieses theologische Prinzip wurde später auch von '''{{w|Thomas van Aquin}}''' (1225-1274) in seinen ''Quinque viae ad Deum'' (&quot;Fünf Wege zu Gott&quot;) aufgegriffen:

{| class=&quot;wikitable&quot;
|+ Nach dem ''Quinque viae ad Deum'' (&quot;Fünf Wege zu Gott&quot;) von Thomas von Aquin
! Weg !! Bezeichnung !! Voraussetzung !! Feststellung !! Folgerung
|-
| Via&amp;nbsp;I || Bewegungsbeweis || In der Welt ist überall Bewegung. || Alles Bewegte muss von einem anderen in Bewegung gebracht worden sein. || Der Erstbeweger ist Gott.
|-
| Via&amp;nbsp;II || Kausalitätsbeweis || In der Welt gibt es überall Ursachen und Wirkungen. || Jede Wirkung muss eine Ursache haben. || Die erste Ursache der Welt ist Gott.
|-
| Via&amp;nbsp;III || Kontingenzbeweis || Alles Empirische in der Welt entsteht und vergeht wieder. || Jedes empirische Wesen muss das Sein von einem absoluten Wesen empfangen haben. || Das absolute Wesen ist Gott.
|-
| Via&amp;nbsp;IV || Stufenbeweis || In der Welt gibt es abgestuft gute, wahre und schöne Dinge. || Das absolute Wesen muss die höchste Güte, Wahrheit und Schönheit haben. || Das höchste Gute, Wahre und Schöne ist Gott.
|-
| Via&amp;nbsp;V || Finalitätsbeweis || In der Welt gibt es Ordnung und Gesetzmäßigkeit. || Ordnung und Gesetzmäßigkeit müssen auf einen denkenden Geist zurückgehen. || Dieser Geist kommt von Gott.
|}

Auch '''{{w|Gottfried Wilhelm Leibniz}}''' (1646-1717) lehnt sich in seiner Hypothese von „Gott als letztem und zureichendem Grund der Welt“ daran an.

Auch im 90. Psalm wird dieser Ansatz thematisiert:

&lt;blockquote&gt;
Das vierte Buch&lt;br/&gt;
Der '''ewige''' Gott – der '''vergängliche''' Mensch&lt;br/&gt;&lt;br/&gt;
1 Ein Bittgebet des Mose, des Mannes Gottes. O Herr, du warst uns Wohnung '''von Geschlecht zu Geschlecht'''.&lt;br/&gt;
2 '''Ehe geboren wurden die Berge, ehe du unter Wehen hervorbrachtest Erde und Erdkreis''', bist du '''Gott von Ewigkeit zu Ewigkeit'''.&lt;br/&gt;
3 '''Zum Staub zurückkehren lässt du den Menschen''', du sprichst: Ihr Menschenkinder, kehrt zurück!&lt;br/&gt;
4 Denn tausend Jahre sind in deinen Augen wie der Tag, der gestern vergangen ist, wie eine Wache in der Nacht.
&lt;/blockquote&gt;

Darüber hinaus gibt der vierte Vers einen deutlichen Hinweis auf das Verhältnis zwischen der Länge des viele Jahrtausende dauernden Präzessionszyklus und der Länge eines siderischen Monats: der Mond wandert entlang der Ekliptiklinie an einem Tag genauso weit wie der Frühlingspunkt in tausend Jahren.

→ Siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Präzession|'''Präzession''']].

Der griechische Dichter '''{{w|Aratos von Soloi}}''' in Kilikien (≈310–245) hatte seine astronomischen Kenntnisse vom Astronomen und Mathematiker '''{{w|Eudoxos von Knidos}}''' (geboren nach 390, gestorben nach 338) erhalten. In dem in der Antike verbreiteten Lehrgedicht Φαινόμενα (Phainomena = „Himmelserscheinungen“) von Aratos wird der Sternenhimmel in zahlreichen Hexametern beschrieben. Sein monumentales sechseckiges Grab aus der antiken Stadt Pompeiopolis wurde 2020 in der türkischen Provinz Mersin wiederentdeckt.&lt;ref&gt;Patricia Claus: [https://greekreporter.com/2021/07/11/memorial-tomb-of-ancient-greek-astronomer-aratus-unearthed-in-turkey/ Memorial Tomb of Ancient Greek Astronomer Aratus Unearthed in Turkey], The Greek Reporter, 11. Juli 2021&lt;/ref&gt;

Hier der Beginn des Prologs des Lehrgedichts:

&lt;blockquote&gt;
Εκ Διὸς ἀρχώμεσθα , τὸν οὐδέποτ᾽ ἄνδρες ἐῶμεν&lt;br/&gt;
῎Αῤῥητον . Μεσταὶ δὲ Διὸς πᾶσαι μὲν ἀγυιαὶ ,&lt;br/&gt;
Πᾶσαι δ᾽ ἀνθρώπων ἀγοραί · μεστὴ δὲ θάλασσα ,&lt;br/&gt;
Καὶ λιμένες. πάντη δὲ Διὸς κεχρήμεθα πάντες .&lt;br/&gt;
'''Τοῦ γὰρ καὶ γένος εἰμέν''' · ὁ δ᾽ ἤπιος ἀνθρώποισι&lt;br/&gt;
Δεξιὰ σημαίνει · λαοὺς δ᾽ ἐπὶ ἔργον ἐγείρει ,&lt;br/&gt;
Μιμνήσκων βιότοιο . λέγει δ᾽ , ὅτε βῶλος ἀρίστη&lt;br/&gt;
Βουσί τε καὶ μακέλῃσι · λέγει δ᾽ , ὅτε δεξιαὶ ὧραι ,&lt;br/&gt;
Καὶ φυτὰ γύρῶσαι , καὶ σπέρματα πάντα βαλέσθαι .&lt;br/&gt;
Αὐτὸς γὰρ τάγε σήματ᾽ ἐν '''οὐρανῷ''' ἐστήριξεν ,&lt;br/&gt;
'''Αστρα''' διακρίνας · ἐσκέψατο δ᾽ εἰς ἐνιαυτὸν&lt;br/&gt;
'''᾿Αστέρας''' , οἵ κε μάλιστα τετυγμένα σημαίνοιεν&lt;br/&gt;
᾿Ανδράσιν ὡράων , ὄφρ᾽ ἔμπεδα πάντα φύωνται .&lt;br/&gt;
Τῷ μιν ἀεὶ πρῶτόν τε καὶ ὕστατον ἱλάσκονται .&lt;br/&gt;
Χαῖρε , πάτερ , μέγα θαῦμα , μέγ᾽ ἀνθρώποισιν ὄνειαρ ,&lt;br/&gt;
Αὐτὸς καὶ προτέρη γενεή ! χαίροιτε δὲ , Μοῦσαι&lt;br/&gt;
Μειλίχιαι , μάλα πᾶσαι ! ἐμοί γε μὲν '''ἀστέρας''' εἰπεῖν ,&lt;br/&gt;
Ηἱ θέμις εὐχομένῳ , τεκμήρατε πᾶσαν ἀοιδήν .&lt;br/&gt;
Οἱ μὲν ὁμῶς πολέες τε , καὶ ἄλλυδις ἄλλοι ἐόντες ,&lt;br/&gt;
'''Οὐρανῷ''' ἕλκονται πάντ᾽ ἤματα συνεχὲς αἰεί.&lt;br/&gt;
Αὐτὰρ ὅγ᾽ οὐδ᾽ ὀλίγον μετανίσσεται · ἀλλὰ μάλ' αὕτως&lt;br/&gt;
'''῎Αξων''' οἱ ἐνάρηρεν · ἔχει δ᾽ ἀτάλαντον ἁπάντη&lt;br/&gt;
'''Μεσσηγὺς γαῖαν''' , περὶ δ᾽ '''οὐρανὸν''' αὐτὸν ἀγινεῖ.&lt;br/&gt;
Καί μιν πειραίνουσι δύω '''πόλοι''' ἀμφοτέρωθεν ·&lt;br/&gt;
᾿Αλλ᾽ ὁ μὲν οὐκ ἐπίοπτος · ὁ δ᾽ ἀντίος ἐκ '''Βορέαο''' ,&lt;br/&gt;
Ὑψόθεν Ὠκεανοῖο . Δύω δὲ μιν ἀμφὶς ἔχουσαι&lt;br/&gt;
'''Ἄρκτοι''' ἅμα τροχόωσι · τὸ δὴ καλέονται '''῞Αμαξαι''' .
&lt;/blockquote&gt;

Übersetzung unter Beibehaltung der Hexameter nach dem deutschen Dichter, Übersetzer und Hochschullehrer Johann Heinrich Voss (1751–1826) von 1824:&lt;ref&gt;АРАТОΥ ΦΑΙΝΟΜΕΝΑ ΚΑΙ ΔΙΟΣΗΜΕΙΑ. Des Aratos Sternerscheinungen und Wetterzeichen. Übersetzt und erklärt von Johann Heinrich Voss. Heidelberg bei Christian Friedrich Winter. 1824.&lt;/ref&gt;

&lt;blockquote&gt;
Zeus sei unser Beginn , und niemals bleib' er uns Männern&lt;br/&gt;
Ungelobt. Voll wahrlich des Zeus sind alle des Wandels&lt;br/&gt;
Weg' , und alle Versammlung der Welt ; voll jegliche Meerflut ,&lt;br/&gt;
Jeglicher Port ; ringsum ja des Zeus bedürfen wir alle .&lt;br/&gt;
'''Seines Geschlechts auch sind wir''' ; und Er , mildherzig den Menschen,&lt;br/&gt;
Zeichnet, was frommt, rechtsher ; und zu Tätigkeit weckt er die Völker,&lt;br/&gt;
Mahnend an Lebensbedarf : Er sagt , wann besser dem Pflugstier&lt;br/&gt;
Fuge die Scholl' , und dem Karst ; er sagt , wann schickliche Jahrszeit,&lt;br/&gt;
Dass man die Pflanze behäuf&quot; , und einsenk' allerlei Anwachs .&lt;br/&gt;
Denn selbst hat er die Zeichen am oberen '''Himmel''' befestigt ,&lt;br/&gt;
Und '''Sternbilder''' verteilt ; er hat fürsehend dem Jahrlauf&lt;br/&gt;
'''Sterne''' bestimmt , die den Menschen zumeist annahende Wechsel&lt;br/&gt;
Deuteten jeglicher Zeit , dass in Völligkeit alles erwachse .&lt;br/&gt;
Drum ihn immer zuerst , und zulezt ihn , sühnen sie feiernd.&lt;br/&gt;
Heil , anstaunlicher Vater , den Sterblichen mächtiges Labsal ,&lt;br/&gt;
Du auch , selbst des Geschlechts Ursprung ! Heil , freundliche Musen,&lt;br/&gt;
Heil euch allen gesamt ! doch mir , der , die '''Sterne''' zu melden ,&lt;br/&gt;
Euch , wie geziemt , anfleht , bringt allen Gesang zur Vollendung.&lt;br/&gt;
Jene zugleich , so viele zerstreuete , andere anders ,&lt;br/&gt;
Ziehn mit dem '''Himmel''' einher in ewigem Zuge beständig .&lt;br/&gt;
Doch nie schwanket er selbst um ein weniges; sondern durchaus so&lt;br/&gt;
Bleibt ihm die '''Axe''' geheftet ; die hält gleichschwebend vom Umfang&lt;br/&gt;
Hier '''in der Mitte die Erd'''' , und umher dort dreht sie den '''Himmel''' .&lt;br/&gt;
Sie dann hat zween '''Pol'''' an jeglichem Ende gerichtet :&lt;br/&gt;
Unsichtbar ist jener; doch hier um den '''Boreas''' ragt er&lt;br/&gt;
Ob dem Okeanos hoch. Zwo dem zu den Seiten gestellte&lt;br/&gt;
'''Bärinnen''' rollen umher: drum auch '''Rollwagen''' benamet.
&lt;/blockquote&gt;

'''''Hinweise:'''''
* Die &quot;Axe&quot; beschreibt die Erdachse.
* ''Mit dem &quot;Boreas&quot; ist der Himmelsnordpol gemeint.''
* ''Bei den beiden Bärinnen handelt es sich um die Sternbilder des Großen Bären (Ursa Maior) und des Kleinen Bären (Ursa Minor).''
* ''Die beiden Rollwagen sind bei uns heute die Asterismen Großer Wagen und Kleiner Wagen.''

Der Apostel '''{{w|Paulus von Tarsus}}''' (geboren vor 10, gestorben nach 60) war der bedeutendste Missionar des Urchristentums und kannte diesen Text offensichtlich. Im 17.&amp;nbsp;Kapitel der Apostelgeschichte des Lukas wird ihm ein Zitat aus dem Prolog des Lehrgedichts über die Abstammung der Menschen von Gott in den Mund gelegt.&lt;ref&gt;[https://www.die-bibel.de/bibel/NA28,EUE/ACT.17.28 Apostelgeschichte 17,28], Abschnitt: ''Paulus in Athen'', Novum Testamentum Graece und Einheitsübersetzung&lt;/ref&gt;

&lt;blockquote&gt;
Apostelgeschichte 17,28: '''Τοῦ γὰρ καὶ γένος ἐσμέν.'''
&lt;/blockquote&gt;

&lt;blockquote&gt;
Apostelgeschichte 17,28: '''Wir sind von seinem Geschlecht.'''
&lt;/blockquote&gt;

=== Zahlen in Religionen ===
Die '''Zwei''' steht oft für Gegensätze, wie zum Beispiel Tag und Nacht, Aufgang und Untergang, Sommerhalbjahr und Winterhalbjahr, zunehmender und abnehmender Mond oder obere und untere Kulmination. Eine solche Zweiteilung findet sich oft auch in gegensätzliche Kategorien wieder, die in vielen Disziplinen, insbesondere auch in der Ethik und in Religionen verwendet werden, wie beispielsweise gut und böse, oben und unten, Leben und Tod, Licht und Schatten, Wärme und Kälte oder Himmel und Hölle.

Interessant ist auch die frühgeschichtliche astronomische Auffassung von '''zwei''' mächtigen Gegenspielern, die sich im Sternenhimmel an zwei gegenüberliegenden Seiten befinden, der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|der Himmelsstier]] und der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsskorpion|der Himmelsskorpion]].

→ Siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwei|'''Zur Zwei''']].

Die astronomischen Zahlen '''Sieben''' und '''Zwölf''' werden als heilige Zahlen angesehen. Sie werden in vielfältigen Kontexten in religiösen Texten erwähnt und für viele religiöse Symbole verwendet. Ferner spielt auch die astronomische Zahl '''Vier''' in Religionen eine bedeutende Rolle, wo sie deswegen manchmal ebenfalls als heilige Zahlen angesehen wird:

* '''Vier''' Hauptsterne respektive Hauptsternbilder mit den '''vier''' Himmelsrichtungen und den '''vier''' Jahreszeiten: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Vier_in_Religionen|'''Bedeutung der Vier in Religionen''']].
* '''Sieben''' Wandelgestirne mit den die '''sieben''' Tagen einer Woche beziehungsweise eines Mondviertels: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Sieben_in_Religionen|'''Bedeutung der Sieben in Religionen''']].
* '''Zwölf''' Ekliptiksternbilder, '''zwölf''' Monate pro Jahr, '''zwölf''' Jahre Umlaufzeit des Planeten Jupiter, jeweils '''zwölf''' Stunden Tag und Nacht: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Zwölf_in_Religionen|'''Bedeutung der Zwölf in Religionen''']].

=== Altes Testament ===
In der Bibel wird in der Regel nicht zwischen Fixsternen und Planeten unterschieden. Eine Ausnahme gibt es im 2.&amp;nbsp;Buch der Könige, Kapitel&amp;nbsp;23, Vers&amp;nbsp;5 aus dem siebenten vorchristlichen Jahrhundert, wo in der deutschsprachigen Einheitsübersetzung von &quot;den Wandelsternen&quot; und in der Luther-Bibel von &quot;den Planeten&quot; die Rede ist. Die Vulgata schreibt hier allerdings von den &quot;duodecim signis&quot;, womit sicherlich die zwölf Sternzeichen der Ekliptik gemeint sind, durch die die sieben Wandelgestirne ziehen. Die Septuaginta spricht noch allgemeiner von den &quot;μαζουρωθ&quot; nach dem Hebräischen Wort &quot;מַזָּלָה&quot; (&quot;mazzaroth&quot;), womit vermutlich Sternkonstellationen und im engeren Sinne ebenfalls die zwölf Sternzeichen des Zodiaks gemeint sind:

&lt;blockquote&gt;
'''Septuaginta '''&lt;br/&gt;
5 καὶ κατέπαυσεν τοὺς χωμαριμ, οὓς ἔδωκαν βασιλεῖς Ιουδα καὶ ἐθυμίων ἐν τοῖς ὑψηλοῖς καὶ ἐν ταῖς πόλεσιν Ιουδα καὶ τοῖς περικύκλῳ Ιερουσαλημ, καὶ τοὺς θυμιῶντας τῷ Βααλ καὶ τῷ ἡλίῳ καὶ τῇ σελήνῃ καὶ τοῖς '''μαζουρωθ''' καὶ πάσῃ τῇ δυνάμει τοῦ οὐρανοῦ.&lt;br/&gt;
&lt;br/&gt;
'''Vulgata'''&lt;br/&gt;
5 Et delevit aedituos, quos posuerant reges Iudae ad sacrificandum in excelsis per civitates Iudae et in circuitu Ierusalem, et eos, qui adolebant Baal et soli et lunae et '''duodecim signis''' et omni militiae caeli.&lt;br/&gt;
&lt;br/&gt;
'''Einheitsübersetzung (2016)'''&lt;br/&gt;
5 Auch setzte er die Götzenpriester ab, die von den Königen von Juda bestellt worden waren und die auf den Kulthöhen, in den Städten Judas und in der Umgebung Jerusalems Opfer verbrannt sowie dem Baal, der Sonne, dem Mond, den '''Wandelsternen''' und dem ganzen Heer des Himmels geopfert hatten.&lt;br/&gt;
&lt;br/&gt;
'''Luther-Bibel (2017)'''&lt;br/&gt;
5 Und er setzte die Götzenpriester ab, die die Könige von Juda eingesetzt hatten, um auf den Höhen zu opfern in den Städten Judas und um Jerusalem her; auch die dem Baal geräuchert hatten, der Sonne und dem Mond und den '''Planeten''' und allem Heer am Himmel.&lt;br/&gt;
&lt;/blockquote&gt;

Der Prophet Habakuk erwähnt in seinem Psalm in Kapitel&amp;nbsp;3 aus dem siebenten vorchristlichen Jahrhundert das Konzept der Aufteilung der Ekliptik in Mondstationen respektive in Mondhäuser:

&lt;blockquote&gt;
10 Wenn sie dich sehen, erbeben die Berge,&lt;br/&gt;
das Tosen der Wasser rauscht vorüber; es erhebt die Urflut ihre Stimme,&lt;br/&gt;
hoch oben vergisst die Sonne ihre Strahlen.&lt;br/&gt;
11 '''Der Mond bleibt in der Behausung;'''&lt;br/&gt;
als Beleuchtung schwirren deine Pfeile,&lt;br/&gt;
als heller Schein das Blitzen deiner Lanze.
&lt;/blockquote&gt;

In den folgenden Bibelstellen aus dem Alten Testament spiegeln sich astronomische Vorstellungen in Bezug auf Gott wider:

'''Genesis 1:'''
&lt;blockquote&gt;
1 Im Anfang erschuf Gott '''Himmel''' und Erde.&lt;br/&gt;
2 Die '''Erde''' war wüst und wirr und '''Finsternis''' lag über der '''Urflut''' und Gottes Geist schwebte über dem '''Wasser'''.&lt;br/&gt;
3 Gott sprach: Es werde '''Licht'''. Und es wurde '''Licht'''.
...&lt;br/&gt;
5 Und Gott nannte das Licht '''Tag''' und die Finsternis nannte er '''Nacht'''. Es wurde '''Abend''' und es wurde '''Morgen''': erster Tag.&lt;br/&gt;
...&lt;br/&gt;
14 Dann sprach Gott: Lichter sollen am '''Himmelsgewölbe''' sein, um '''Tag''' und '''Nacht''' zu scheiden. Sie sollen als Zeichen für '''Festzeiten''', für '''Tage''' und '''Jahre''' dienen.&lt;br/&gt;
15 Sie sollen Lichter am Himmelsgewölbe sein, um über die Erde hin zu leuchten. Und so geschah es.&lt;br/&gt;
16 Gott machte '''die beiden großen Lichter''', das große zur Herrschaft über den '''Tag''', das kleine zur Herrschaft über die '''Nacht''', und die '''Sterne'''.
&lt;/blockquote&gt;

'''Psalm 8:'''
&lt;blockquote&gt;
4 Seh ich deine '''Himmel''', die Werke deiner Finger, '''Mond '''und '''Sterne''', die du befestigt.
&lt;/blockquote&gt;

[[Datei:Johannes.Kepler.Coeli.enarrant.gloriam.Dei.png|mini|rechts|Portrait des jungen Johannes Keplers mit dem Motto &quot;Coeli enarrant gloriam Dei.&quot; nach Psalm 19: &quot;Die Himmel erzählen die Herrlichkeit Gottes.&quot;]]

'''Psalm 19:'''
&lt;blockquote&gt;
2 Die '''Himmel''' erzählen die Herrlichkeit Gottes und das '''Firmament''' kündet das Werk seiner Hände.
&lt;/blockquote&gt;

'''Psalm 90:'''
&lt;blockquote&gt;
2 Ehe geboren wurden die Berge, ehe du unter Wehen hervorbrachtest '''Erde''' und '''Erdkreis''', bist du Gott von Ewigkeit zu Ewigkeit.
&lt;/blockquote&gt;

'''Psalm 102:'''
&lt;blockquote&gt;
26 Vorzeiten hast du der Erde Grund gelegt, die '''Himmel''' sind das Werk deiner Hände.
&lt;/blockquote&gt;

'''Psalm 103:'''
&lt;blockquote&gt;
19 Der HERR hat seinen Thron errichtet im '''Himmel''', seine königliche Macht beherrscht '''das All'''.
&lt;/blockquote&gt;

'''Psalm 104:'''
&lt;blockquote&gt;
19 Du machst den '''Mond''' zum Maß für die Zeiten, die '''Sonne''' weiß, wann sie untergeht.
&lt;/blockquote&gt;

'''Psalm 113:'''
&lt;blockquote&gt;
3 Vom '''Aufgang der Sonne''' bis zu ihrem '''Untergang''' sei gelobt der Name des HERRN.&lt;br/&gt;
4 Erhaben ist der HERR über alle Völker, über den '''Himmeln''' ist seine Herrlichkeit.
&lt;/blockquote&gt;

'''Psalm 136:'''
&lt;blockquote&gt;
3 Dankt dem Herrn der Herren, denn seine Huld währt ewig!&lt;br/&gt;
4 Ihm, der allein große Wunder tut, denn seine Huld währt ewig,&lt;br/&gt;
5 der den '''Himmel''' gemacht hat in Weisheit, denn seine Huld währt ewig,&lt;br/&gt;
6 der die Erde gefestigt hat über den Wassern, denn seine Huld währt ewig,&lt;br/&gt;
7 der '''die großen Leuchten''' gemacht hat, denn seine Huld währt ewig,&lt;br/&gt;
8 die '''Sonne''' zur Herrschaft über den '''Tag''', denn seine Huld währt ewig,&lt;br/&gt;
9 den '''Mond''' und die '''Sterne''' zur Herrschaft über die '''Nacht''', denn seine Huld währt ewig.
&lt;/blockquote&gt;

'''Psalm 147:'''
&lt;blockquote&gt;
4 Er bestimmt die Zahl der '''Sterne''' und ruft sie alle mit Namen.
&lt;/blockquote&gt;

'''Psalm 148:'''
&lt;blockquote&gt;
'''Lobpreis auf den Herrn, den König des Kosmos'''&lt;br/&gt;
1 Halleluja! Lobt den HERRN vom '''Himmel''' her, lobt ihn in den Höhen:&lt;br/&gt;
2 Lobt ihn, all seine Engel, lobt ihn, all seine Heerscharen,&lt;br/&gt;
3 lobt ihn, '''Sonne''' und '''Mond''', lobt ihn, all ihr leuchtenden '''Sterne''',&lt;br/&gt;
4 lobt ihn, ihr '''Himmel der Himmel''', ihr Wasser über dem '''Himmel'''!
&lt;/blockquote&gt;

Mit den &quot;Wassern über dem Himmel&quot; können nicht die Wolken unterhalb der Sternensphäre gemeint sein. Vielmehr dürfte es sich um eine Anspielung auf den Urozean beziehungsweise die Urflut handeln (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Urozean''']]). Diese Urflut existierte bereits vor der Erschaffung des Lichts und der Gestirne. Man erinnere sich an den Beginn der Schöpfungsgeschichte in den ersten drei Versen der Bibel (siehe oben).

'''Buch der Weisheit (Weisheit Salomos):'''
&lt;blockquote&gt;
'''Salomos Gebet um Weisheit'''&lt;br/&gt;
9,1 Gott der Väter und Herr des Erbarmens, du hast '''das All''' durch dein Wort gemacht.
&lt;/blockquote&gt;

'''Jesus Sirach 42:'''
&lt;blockquote&gt;
'''Lob Gottes in der Schöpfung'''&lt;br/&gt;
15 Nun will ich der Werke des Herrn gedenken, und was ich gesehen habe, werde ich erzählen: Durch die Worte des Herrn sind seine Werke und durch seinen Segen gab er ihnen ihre Bestimmung.&lt;br/&gt;
16 Die leuchtende '''Sonne''' blickt auf alles hernieder und von der Herrlichkeit des Herrn ist sein Werk erfüllt.&lt;br/&gt;
17 Der Herr gab es selbst den Heiligen nicht, all seine Wunder zu erzählen, der Herr der Herrscher über '''das All''', hat sie gegründet, sodass '''das All''' in seiner Herrlichkeit Bestand hat.&lt;br/&gt;
18 Abgrund und Herz hat er durchforscht und ihre Absichten hat er durchschaut; denn der Höchste kennt alles Wissen und er blickt auf die '''Zeichen der Zeiten'''.&lt;br/&gt;
19 Er tut das Vergangene und das Kommende kund und enthüllt die Spuren des Verborgenen.&lt;br/&gt;
20 Kein Gedanke entgeht ihm und kein einziges Wort bleibt ihm verborgen.&lt;br/&gt;
21 Die Großtaten seiner Weisheit hat er geordnet; wie er ist '''von Ewigkeit und in Ewigkeit'''. Ihm ist weder etwas hinzugefügt noch weggenommen worden und er hat keines Ratgebers bedurft.
&lt;/blockquote&gt;

Auch im nachfolgenden Kapitel lobt Jesus Sirach die Sonne, den Mond und die Sterne in den höchsten Tönen:

'''Jesus Sirach 43:'''
&lt;blockquote&gt;
1 Der Stolz der Höhe ist ein '''Firmament''' von Reinheit, die Gestalt des '''Himmels''' beim Anblick der Herrlichkeit.&lt;br/&gt;
2 Die '''Sonne''' verkündet durch ihr Erscheinen beim Aufgang, ein wunderbares Geschöpf, ein Werk des Höchsten!&lt;br/&gt;
3 Zur '''Mittagszeit''' trocknet sie den Boden aus, wer wird bestehen vor ihrer Glut?&lt;br/&gt;
4 Wer in einen Ofen bläst bei Arbeiten mit Glut - dreimal so stark versengt die '''Sonne''' Berge; sie atmet Feuerdämpfe aus und blendet mit gleißenden Strahlen die Augen.&lt;br/&gt;
5 Groß ist der Herr, der sie gemacht hat, mit seinen Worten beschleunigt er ihren Lauf.&lt;br/&gt;
6 Auch der '''Mond''' hält sich in allem an seinen Zeitpunkt, zur '''Festsetzung der Zeiten''' und als Zeichen auf Dauer.&lt;br/&gt;
7 Vom '''Mond''' geht das Zeichen für einen Festtag aus, ein Gestirn, das abnimmt bis zur Vollendung.&lt;br/&gt;
8 Der Name '''Monat''' kommt vom '''Neumond''', der wunderbar zunimmt beim Wechsel, ein Geschöpf des Heeres in der Höhe, das am '''Himmelsgewölbe''' leuchtet.&lt;br/&gt;
9 Die Schönheit des '''Himmels''' ist der Glanz der '''Sterne''', ein strahlender Schmuck in den Höhen des Herrn.&lt;br/&gt;
10 Durch die Worte des Heiligen stehen sie gemäß ihrer Bestimmung und sie ermüden nie bei ihrer Wache.&lt;br/&gt;
...&lt;br/&gt;
27 Vieles werden wir sagen, aber wir kommen nie an ein Ziel und das Ende der Worte ist: Er ist '''das All'''.
&lt;/blockquote&gt;

'''Jesaja 40:'''
&lt;blockquote&gt;
26 Hebt eure Augen in die Höhe und seht: Wer hat diese '''Gestirne''' erschaffen?&lt;br/&gt;
Der vollzählig herausführt ihr Heer, er ruft sie alle beim Namen.&lt;br/&gt;
Wegen seiner Fülle an Kraft und mächtiger Stärke fehlt kein einziges.
&lt;/blockquote&gt;

Das Buch Baruch gehört zu den späten Schriften des Alten Testaments. Im dritten Kapitel werden das Licht und die Sterne in Bezug auf Gott thematisiert:

'''Baruch 3:'''
&lt;blockquote&gt;
33 Er entsendet das '''Licht''' und es eilt dahin; er ruft es zurück und zitternd gehorcht es ihm.&lt;br/&gt;
34 Froh leuchten die '''Sterne''' auf ihren Posten.&lt;br/&gt;
35 Ruft er sie, so antworten sie: Hier sind wir. Sie leuchten mit Freude für ihren Schöpfer.&lt;br/&gt;
36 Das ist unser Gott; kein anderer gilt neben ihm.
&lt;/blockquote&gt;

Ein Lobpreis auf die Werke, Engel und Mächte Gottes am Gewölbe des Himmels findet sich im '''Buch Daniel''' im dritten Kapitel. Der Text macht inhaltlich eine ähnliche Aussage wie der Lobpreis auf den Herrn, den König des Kosmos in Psalm 148 (siehe oben):

'''Daniel 3:'''
&lt;blockquote&gt;
56 Gepriesen bist du am Gewölbe des '''Himmels''', gerühmt und verherrlicht in Ewigkeit.&lt;br/&gt;
57 Preist den HERRN, all ihr Werke des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
58 Preist den HERRN, ihr '''Himmel'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
59 Preist den HERRN, ihr Engel des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
60 Preist den HERRN, all ihr '''Wasser über dem Himmel'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
61 Preist den HERRN, all ihr Mächte des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
62 Preist den HERRN, '''Sonne und Mond'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
63 Preist den HERRN, ihr '''Sterne am Himmel'''; lobt und rühmt ihn in Ewigkeit!
&lt;/blockquote&gt;

=== Der Himmelsthron ===
Der '''Himmelsthron''' wir in vielen Texten des Alten Testaments als der Sitz Gottes genannt. Hier zunächst einige Erwähnungen in den Psalmen:

&lt;blockquote&gt;
11,4 Der HERR ist in seinem heiligen Tempel, der HERR hat seinen '''Thron im Himmel'''.&lt;br/&gt;
Seine Augen schauen herab, seine Blicke prüfen die Menschen.
&lt;/blockquote&gt;

&lt;blockquote&gt;
33,13 Der HERR blickt herab vom '''Himmel''', er sieht alle Menschen.&lt;br/&gt;
33,14 Von seinem '''Thronsitz''' schaut er nieder auf alle Bewohner der Erde.
&lt;/blockquote&gt;

&lt;blockquote&gt;
89,37 Sein Haus soll bleiben auf ewig, sein '''Thron''' habe Bestand vor mir wie die '''Sonne''';
&lt;/blockquote&gt;

&lt;blockquote&gt;
103,19 Der HERR hat seinen '''Thron''' errichtet im '''Himmel''', seine königliche Macht beherrscht '''das All'''.
&lt;/blockquote&gt;

Im Buch der Weisheit stehen die folgenden beiden Verse:

&lt;blockquote&gt;
9,9 Mit dir ist die Weisheit, die deine Werke kennt und die zugegen war, als du die Welt erschufst. Sie weiß, was wohlgefällig ist in deinen Augen und was recht ist nach deinen Geboten.&lt;br/&gt;
9,10 Sende sie vom heiligen '''Himmel''' und schick sie vom '''Thron''' deiner Herrlichkeit, damit sie bei mir sei und alle Mühe mit mir teile und ich erkenne, was wohlgefällig ist bei dir!
&lt;/blockquote&gt;

Diese Bild von Gottes Thron im Himmel wir auch im Neuen Testament aufgegriffen, wie beispielsweise beim Evangelisten Matthäus (Kapitel 5, Vers 34) oder in der Offenbarung des Johannes, wo im vierten Kapitel die eröffnende Himmelsvision mit dem Abschnitt über &quot;Die Huldigung vor dem Thron Gottes&quot; beginnt:

&lt;blockquote&gt;
1 Danach sah ich und siehe, eine Tür war geöffnet am '''Himmel'''; und die erste Stimme, die ich gleich einer Posaune mit mir reden gehört hatte, sagte: Komm herauf und ich werde dir zeigen, was dann geschehen muss.&lt;br/&gt;
2 Sogleich wurde ich vom Geist ergriffen. Und siehe, '''ein Thron stand im Himmel'''; auf dem Thron saß einer,&lt;br/&gt;
3 der wie ein Jaspis und ein Karneol aussah. Und über dem '''Thron''' wölbte sich ein Regenbogen, der wie ein Smaragd aussah.&lt;br/&gt;
4 Und rings um den '''Thron standen vierundzwanzig Throne''' und auf den Thronen saßen vierundzwanzig Älteste, in weiße Gewänder gekleidet und mit goldenen Kränzen auf dem Haupt.&lt;br/&gt;
5 Von dem Thron gingen Blitze, Stimmen und Donner aus. Und '''sieben lodernde Fackeln brannten vor dem Thron; das sind die sieben Geister Gottes'''.&lt;br/&gt;
6 Und vor dem Thron war etwas wie ein gläsernes Meer, gleich Kristall. Und in der Mitte des Thrones und rings um den Thron waren '''vier Lebewesen''' voller Augen, vorn und hinten.&lt;br/&gt;
7 Das erste Lebewesen glich einem '''Löwen''', das zweite einem '''Stier''', das dritte sah aus wie ein '''Mensch''', das vierte glich einem '''fliegenden Adler'''.&lt;br/&gt;
&lt;/blockquote&gt;

Der achtstrophige Adventshymnus ''Veni redemptor gentium'' (die deutschsprachige Kontrafaktur heißt &quot;Nun komm, der Heiden Heiland&quot;) wird dem Kirchenvater Ambrosius von Mailand (339–397) zugeschrieben. In der fünften Strophe wird mit Bezug auf die Himmelfahrt des Messias der Sitz Gottes erwähnt:

&lt;blockquote&gt;
5,1 Egressus eius a Patre,&lt;br/&gt;
5,2 Regressus eius ad Patrem;&lt;br/&gt;
5,3 Excursus usque ad inferos,&lt;br/&gt;
5,4 Recursus ad '''sedem Dei'''.
&lt;/blockquote&gt;

&lt;blockquote&gt;
5,1 Sein Ausgang ist vom Vater,&lt;br/&gt;
5,2 Seine Rückkehr ist beim Vater;&lt;br/&gt;
5,3 Hinausgelaufen bis zu den Toten,&lt;br/&gt;
5,4 Zurückgelaufen bis zum '''Sitz Gottes'''.
&lt;/blockquote&gt;

Es ist nicht viel Phantasie erforderlich, um den Thron Gottes im '''Himmelsstier''' wiederzuerkennen. Die vierundzwanzig Throne, die sich entlang der '''Ekliptik''' um diesen Thron herum aufreihen, stehen für die vierundzwanzig Stunden eines Tages, und sie sind je zwei für jedes der zwölf Lebewesenkreiszeichen des '''Zodiaks'''. Die als sieben lodernde Fackeln vor dem Thron sind die sieben '''Wandelgestirne''', die als die '''sieben Geister Gottes''' immer wieder durch das '''Goldene Tor der Ekliptik''' in der Sitzfläche des Thrones ziehen. Die '''vier besonderen Lebewesen''' sind die vier Evangelistensymbole bei den vier zoroastrischen '''Königssternen'''.

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|'''Himmelsstier''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Die_Ekliptik|'''Ekliptik''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|'''Zodiak''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|'''Goldenes Tor der Ekliptik''']].

→ Siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Vier_in_Religionen|'''Bedeutung der Vier in Religionen''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Königssterne|'''Königssterne''']].

&lt;gallery caption=&quot;Throne&quot; widths=640 heights=480 perrow=2&gt;
Aachen_Cathedral_Karlsthron_02.jpg|Thron Karls des Großen aus den 790er Jahren im Aachener Dom.
Himmelsthron.Taurus.Aries.png|Himmelsthron in den Sternbildern Stier (Taurus) und Widder (Aries) vor dem Untergang in Richtung Westen.
&lt;/gallery&gt;

=== Das Lamm ===
Im ersten Kapitel des Evangeliums nach Johannes wird Jesus von Nazareth explizit als &quot;Lamm Gottes&quot; bezeichnet:&lt;ref&gt;[https://www.bibleserver.com/EU/Johannes1%2C29 Johannes 1,29], bibleserver.com, Einheitsübersetzung (2016)&lt;/ref&gt;

&lt;blockquote&gt;
29b Seht, das '''Lamm Gottes''', das die Sünde der Welt hinwegnimmt!&lt;br/&gt;
...&lt;br/&gt;
36b Seht, das '''Lamm Gottes'''!
&lt;/blockquote&gt;

Es handelt sich beim „Lamm Gottes“ (Kirchenlatein: „Agnus Dei“) um ein seit ältester Zeit verbreitetes Symbol für Jesus Christus. Es wird auch als das Osterlamm bezeichnet, das am Ostertag, also kurz nach der Tag-und-Nacht-Gleiche im Frühjahr auferstanden ist. Nach dem Evangelisten Markus wurde die Auferstehung „... am ersten Tag der Woche, früh am Morgen, als eben die Sonne aufging“, also am Ostersonntag während der Morgenröte im Osten entdeckt.&lt;ref&gt;[https://www.bibleserver.com/LUT/Markus16%2C2 Markus 16,2], Einheitsübersetzung, 2016&lt;/ref&gt; Am 40.&amp;nbsp;Tag ist Jesus Christus nach dem Zeugnis der Evangelisten Markus und Lukas in den Himmel aufgefahren. Zu Beginn der Apostelgeschichte wird dieses Ereignis folgendermaßen beschrieben:&lt;ref&gt;[https://www.bibleserver.com/EU/Apostelgeschichte1 Apostelgeschichte 1], Einheitsübersetzung, 2016&lt;/ref&gt;

&lt;blockquote&gt;
7 Er sagte zu ihnen: Euch steht es nicht zu, Zeiten und Fristen zu erfahren, die der Vater in seiner Macht festgesetzt hat.&lt;br/&gt;
8 Aber ihr werdet Kraft empfangen, wenn der Heilige Geist auf euch herabkommen wird; und ihr werdet meine Zeugen sein in Jerusalem und in ganz Judäa und Samarien und bis an die Grenzen der Erde.&lt;br/&gt;
9 Als er das gesagt hatte, wurde er vor ihren Augen emporgehoben und eine Wolke nahm ihn auf und entzog ihn ihren Blicken.&lt;br/&gt;
&lt;/blockquote&gt;

Im altrömischen Glaubensbekenntnis gibt es die Textstelle:

&lt;blockquote&gt;
„ascendit in caelis, sedet ad dexteram Patris“
&lt;/blockquote&gt;

Zu Deutsch:

&lt;blockquote&gt;
„aufgefahren in den Himmel, er sitzt zur Rechten des Vaters“
&lt;/blockquote&gt;

Das '''Lamm''' (astronomisch Widder) befindet sich am nördlichen Sternenhimmel '''zur Rechten''' des Stieres (Taurus). Sowohl der mesopotamische Himmelsstier als auch das altarabische Sternbild Thuraya verbinden diese beiden neuzeitlichen Sternbilder zu einer Einheit. Der Hauptstern im Sternbild Widder (Aries) heißt Hamal, und das arabische Wort &quot;hamal&quot; steht für ein einjähriges Lamm.&lt;ref name=&quot;Adams&quot;&gt;Danielle Adams: [http://onesky.arizona.edu/arab-star-names/the-lamb/ The Lamb – A folkloric celestial complex], Two Deserts, one Sky – Arab Star Calendars&lt;/ref&gt; Der fette Schwanz des Lammes wird durch die '''Plejaden (Siebengestirn)''' markiert.&lt;ref name=&quot;Adams&quot; /&gt; Die Augen des Stieres sind die Sterne '''Aldebaran''' und '''Ain'''. Zwischen dem Kopf des Stieres und den '''Plejaden''' befindet sich das '''Goldene Tor der Ekliptik''', durch das alle Wandelgestirne regelmäßig hindurchziehen.

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Bibelstellen|'''Bibelstellen zum Siebengestirn''']].

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|'''Goldenes Tor der Ekliptik''']].

Der Frühlingspunkt der Sonne, also deren Ort auf der Ekliptiklinie zur Tag-und-Nacht-Gleiche im Frühjahr, ist von der monotheistischen Schöpfung bis zur Geburt des christlichen Gottessohns vom Kopf des Stiers (bei den Sternen '''Aldebaran''' und '''Ain''' im Goldenen Tor der Ekliptik) im heutigen Sternbild Stier (Taurus) bis zum Kopf des Lammes (beim Stern '''Hamal''') im heutigen Sternbild Widder (Aries) nach Westen gewandert. Heute befindet sich der Frühlingspunkt bereits am westlichen Ende des Sternbilds Fische (Pisces), das sich westlich an das Sternbild Widder anschließt.

==== Offenbarung des Johannes ====
In der Offenbarung des Johannes heißt es im 7.&amp;nbsp;Kapitel:

&lt;blockquote&gt;
10b Die Rettung kommt von unserem '''Gott''', der auf dem '''Thron''' sitzt, und von dem '''Lamm'''.&lt;br/&gt;
17a Denn das Lamm in der Mitte vor dem Thron wird sie weiden und zu den Quellen führen, aus denen das '''Wasser des Lebens''' strömt.
&lt;/blockquote&gt;

Wird der '''Thron Gottes''' mit dem Himmelsstier identifiziert (siehe oben), dann sitzt das '''Lamm''' (Aries, Sternbild Widder) westlich und somit rechts vor diesem Thron. Im weiteren Verlauf der Ekliptik nach Westen befinden sich die zusammenhängenden '''Wassersternbilder''' des Urozeans, dem Urquell des Lebens. Es handelt ich um die heutigen Sternbilder Fluss Eridanus, Walfisch (Cetus), Fische (Pisces), Wassermann (Aquarius), Südlicher Fisch (Piscis Austrinus) und Delphin (Delphinus) sowie Steinbock (Capricornus, früher Ziegenfisch).

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Urozean''']].

&lt;gallery caption=&quot;Das Lamm zur Rechten des Stieres&quot; mode=packed widths=800 heights=600&gt;
Himmelsstier.P1117152.jpg|Astrophotographie vom Asterismus Himmelsstier
Himmelsstier.Sternbilder.P1117152.png|Beschriftete Astrophotographie vom Himmelsstier am winterlichen Abendhimmel in Richtung südlicher Meridian. Die Ekliptiklinie verläuft horizontal etwas unterhalb der Bildmitte.
Haende.der.Thuraya.Vollmond.Sterne.P1079912.jpg|Astrophotographie der Himmelsregion mit dem beduinischen Sternbild &quot;Hände der Thuraya&quot; (grüne durchgezogene Linien, Ekliptik rot gepunktete Linie) mit arabisch bezeichneten Sternen. Der Vollmond befindet sich zwischen den Sternbildern Taurus, Aries und Cetus.
Urozean.Wassersternbilder.png|Die zusammenhängenden Wassersternbilder des Urozeans am Sternenhimmel: Fluss Eridanus, Walfisch (Cetus), Fische (Pisces), Wassermann (Aquarius), Südlicher Fisch (Piscis Austrinus), Delphin (Delphinus) sowie Ziegenfisch (Steinbock, Capricornus).
&lt;/gallery&gt;

Interpretiert man das Sternbild &quot;Lamm&quot; (Widder / Aries) als Mittler auf dem ekliptischen Weg vom finsteren kosmischen Urozean im Westen (rechts) zum strahlenden majestätischen Sternbild Stier (Taurus) im Osten (links), ergeben auch andere Bibelstellen in Bezug auf den Sternenhimmel einen tiefen symbolischen Sinn, die in den folgenden Abschnitten aufgeführt sind.

==== Evangelium nach Johannes ====
Die Rede von Jesus an den Jünger Thomas aus dem 14.&amp;nbsp;Kapitel des Evangeliums nach Johannes ist in diesem Zusammenhang interessant:

&lt;blockquote&gt;
6 Jesus sagte zu ihm: Ich bin der Weg und die Wahrheit und das Leben; niemand kommt zum Vater außer durch mich.&lt;br/&gt;
7 Wenn ihr mich erkannt habt, werdet ihr auch meinen Vater erkennen. Schon jetzt kennt ihr ihn und habt ihn gesehen.
&lt;/blockquote&gt;

Alle Wandelgestirne bewegen sich entlang der Ekliptiklinie (Weg) durch das heutige Sternbild Widder (das altarabische Sternbild &quot;Lamm&quot;) im Westen zum [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der-Ekliptik|Goldenen Tor der Ekliptik]] nach Osten im großen Himmelsstier (Vater / Thron).

==== Evangelium nach Markus ====
Im Evangelium nach Markus heißt es:

&lt;blockquote&gt;
14,62 Jesus sagte: Ich bin es. Und ihr werdet den Menschensohn '''zur Rechten der Macht''' sitzen und mit den Wolken des '''Himmels''' kommen sehen.
&lt;/blockquote&gt;

&lt;blockquote&gt;
16,19 Nachdem Jesus, der Herr, dies zu ihnen gesagt hatte, wurde er in den '''Himmel''' aufgenommen und setzte sich '''zur Rechten Gottes'''.
&lt;/blockquote&gt;

==== Evangelium nach Lukas ====
Im Evangelium nach Lukas ist es folgendermaßen formuliert:

&lt;blockquote&gt;
22,69 Von nun an wird der Menschensohn '''zur Rechten der Macht Gottes''' sitzen.
&lt;/blockquote&gt;

==== Evangelium nach Matthäus ====
Auch im Evangelium nach Matthäus findet sich eine entsprechende Stelle:

&lt;blockquote&gt;
26,64 Jesus antwortete: Du hast es gesagt. Doch ich erkläre euch: Von nun an werdet ihr den Menschensohn '''zur Rechten der Macht''' sitzen und auf den Wolken des '''Himmels''' kommen sehen.
&lt;/blockquote&gt;

==== Brief an die Hebräer ====
Im Brief an die Hebräer, dessen Autor unbekannt ist, gibt es etliche entsprechende Stellen:

&lt;blockquote&gt;
'''Gottes Rede in seinem Sohn'''&lt;br/&gt;
1,3 er ist der Abglanz seiner Herrlichkeit und das Abbild seines Wesens; er trägt '''das All''' durch sein machtvolles Wort, hat die Reinigung von den Sünden bewirkt und sich dann '''zur Rechten der Majestät in der Höhe''' gesetzt;&lt;br/&gt;
1,10 Und: Du, Herr, hast vorzeiten der Erde Grund gelegt, die '''Himmel''' sind das Werk deiner Hände.&lt;br/&gt;
1,11 Sie werden vergehen, '''du aber bleibst'''; sie alle veralten wie ein Gewand;&lt;br/&gt;
1,12 du rollst sie zusammen wie einen Mantel und wie ein Gewand werden sie gewechselt. Du aber bleibst, der du bist, und '''deine Jahre enden nie'''.&lt;br/&gt;
1,13 Zu welchem Engel hat er jemals gesagt: Setze dich mir '''zur Rechten''' und ich lege dir deine Feinde als Schemel unter die Füße?
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Die Liturgie des neuen Bundes'''&lt;br/&gt;
8,1 Die Hauptsache bei dem Gesagten aber ist: Wir haben einen solchen Hohepriester, der sich '''zur Rechten des Thrones der Majestät im Himmel''' gesetzt hat,&lt;br/&gt;
8,2 als Diener des Heiligtums und des '''wahren Zeltes''', das der Herr selbst aufgeschlagen hat, nicht ein Mensch.
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Christus als Mittler des neuen Bundes'''&lt;br/&gt;
9,24 Denn Christus ist nicht in ein von Menschenhand gemachtes Heiligtum hineingegangen, in ein Abbild des wirklichen, sondern '''in den Himmel selbst''', um jetzt '''vor Gottes Angesicht''' zu erscheinen für uns;
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Das Opfer Jesu Christi als endgültige Versöhnung mit Gott'''&lt;br/&gt;
10,12 Dieser aber hat nur ein einziges Opfer für die Sünden dargebracht und sich dann '''für immer zur Rechten Gottes''' gesetzt;
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Das Beispiel Jesu Christi'''&lt;br/&gt;
12,2 und dabei auf Jesus blicken, den Urheber und Vollender des Glaubens; er hat angesichts der vor ihm liegenden Freude das Kreuz auf sich genommen, ohne auf die Schande zu achten, und sich '''zur Rechten von Gottes Thron''' gesetzt.
&lt;/blockquote&gt;

==== Erster Brief des Petrus ====
Der erste Brief des Petrus zählt zu den katholischen Briefen des Neuen Testaments. Dort heißt es im letzten Satz über Jesus Christus:

&lt;blockquote&gt;
22 der in den '''Himmel''' gegangen ist; dort ist er '''zur Rechten''' Gottes und Engel, Gewalten und Mächte sind ihm unterworfen.
&lt;/blockquote&gt;

==== Apostelgeschichte ====
Die Apostelgeschichte schließt an das Evangelium nach Lukas an und wird ebenfalls diesem zugeschrieben. Hier kommen der erste bekennende sowie erste berufene Apostel Petrus und der erste christliche Märtyrer Stephanus zu Wort:

&lt;blockquote&gt;
'''Die Pfingstpredigt des Petrus'''&lt;br/&gt;
2,33 '''Zur Rechten Gottes''' erhöht, hat er vom Vater den verheißenen Heiligen Geist empfangen und ihn ausgegossen, wie ihr seht und hört.
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Steinigung des Stephanus'''&lt;br/&gt;
7,55 Er aber, erfüllt vom Heiligen Geist, blickte zum '''Himmel''' empor, sah die Herrlichkeit Gottes und Jesus '''zur Rechten Gottes''' stehen&lt;br/&gt;
7,56 und rief: Siehe, ich sehe den Himmel offen und den Menschensohn '''zur Rechten Gottes''' stehen.
&lt;/blockquote&gt;

=== Himmelspforte ===
Das Sternbild Widder (Aries) repräsentiert als das Lamm Gottes den nördlichen Pfeiler des Goldenen Tors der Ekliptik. Der fette Schwanz des Lammes wird nach altarabischer Tradition durch das Siebengestirn (Plejaden) gebildet, das heute zu Sternbild Stier (Taurus) gezählt wird. Der südliche Pfeiler des Goldenen Tors der Ekliptik wird durch die Hyaden und den Stern Menkar im Sternbild Walfisch (Cetus) gebildet. Das Goldene Tor der Ekliptik stellt mit diesen beiden Pfeilern somit eine '''Himmelspforte''' dar, durch die alle Wandelgestirne regelmäßig von Westen aus dem dunklen Urozean der winterlichen Wassersternbilder sowie der Richtung des Sonnenuntergangs nach Osten in das helle Gebiet des Sternenhimmels mit den Frühlings- und Sommersternbildern sowie die Richtung des Sonnenaufgangs treten.

[[Datei:Mars.im.Goldenen.Tor.der.Ekliptik.P1091607.jpg|mini|hochkant=3|zentriert|Der am nordwestlichen Horizont in der Nähe der Ekliptiklinie und im Goldenen Tor der Ekliptik untergehende Mars (rote Scheibe unten halb rechts) drei Tage vor dem Durchqueren der '''Himmelspforte''' zwischen dem Kopf des Himmelsstieres mit dem Sternhaufen der Hyaden (unten links) und den Plejaden nördlich der Ekliptik (rechts unten).]]

Die Genesis berichtet im 28.&amp;nbsp;Kapitel unter der Überschrift &quot;Jakob in Bet-El&quot; (hebräisch בֵּית אֵל „Haus des El“ oder „Haus Gottes“) über einen Traum von Jakob, in dem er eine Treppe zum Himmel (die Himmelsleiter oder Jakobsleiter) sieht, an dessen oberen Ende sich das Tor des Himmels (die Himmelspforte) befindet:

&lt;blockquote&gt;
10 Jakob zog aus Beerscheba weg und ging nach Haran.&lt;br/&gt;
11 Er kam an einen bestimmten Ort und übernachtete dort, denn die Sonne war untergegangen. Er nahm einen von den Steinen dieses Ortes, legte ihn unter seinen Kopf und schlief dort ein.&lt;br/&gt;
12 Da hatte er einen Traum: Siehe, eine Treppe stand auf der Erde, ihre Spitze reichte bis zum '''Himmel'''. Und siehe: Auf ihr stiegen Engel Gottes auf und nieder.&lt;br/&gt;
13 Und siehe, der HERR stand vor ihm und sprach: Ich bin der HERR, der Gott deines Vaters Abraham und der Gott Isaaks. Das Land, auf dem du liegst, will ich dir und deinen Nachkommen geben.&lt;br/&gt;
14 Deine Nachkommen werden zahlreich sein wie der Staub auf der Erde. Du wirst dich '''nach Westen und Osten, nach Norden und Süden''' ausbreiten und durch dich und deine Nachkommen werden alle Sippen der Erde Segen erlangen.&lt;br/&gt;
15 Siehe, ich bin mit dir, ich behüte dich, wohin du auch gehst, und bringe dich zurück in dieses Land. Denn ich verlasse dich nicht, bis ich vollbringe, was ich dir versprochen habe.&lt;br/&gt;
16 Jakob erwachte aus seinem Schlaf und sagte: Wirklich, der HERR ist an diesem Ort und ich wusste es nicht.&lt;br/&gt;
17 Er fürchtete sich und sagte: Wie Ehrfurcht gebietend ist doch dieser Ort! Er ist nichts anderes als das Haus Gottes und das '''Tor des Himmels'''.&lt;br/&gt;
&lt;/blockquote&gt;

El für die semitischen Ugariter im zweiten vorchristlichen Jahrtausend der Name ihres höchsten Gottes. Jakob war der der erste der drei Erzväter des Volkes Israel und der älteste Sohn des ältesten Sohnes Isaak von Abraham. Abraham war aus dem mesopotamischen Ur über Haran nach Bet-El gezogen, und Jakob ging in dieser Schilderung aus Beerscheba in der Nähe des Ortes Bet-El nach Haran zurück.

Der Apostel Paulus schreibt in seinem zweiten Brief an die Bewohner der griechischen Hafenstadt Korinth zu Beginn des 5.&amp;nbsp;Kapitels mit der Überschrift &quot;Die Hoffnung des Apostels&quot; über das Gebäude hinter der Pforte zum Himmel:

&lt;blockquote&gt;
1 Wir wissen: Wenn unser irdisches Zelt abgebrochen wird, dann haben wir eine Wohnung von Gott, ein nicht von Menschenhand errichtetes '''ewiges Haus im Himmel'''.
&lt;/blockquote&gt;

=== Gedanken zur wundersamen Brotvermehrung ===
==== Evangelien ====
[[Datei:Face de chapiteau figurant la Multiplication des pains, choeur de l'église de Saint-Nectaire, Puy-de-Dôme.jpg|mini|rechts|hochkant=2|Jesus mit vier seiner Jünger mit fünf Broten und zwei Fischen an einem Säulenkapitell in der romanischen Wallfahrtskirche Saint Nectaire auf dem Mont Cornadore in Saint-Nectaire in Frankreich (Département Puy-de-Dôme in der Region Auvergne-Rhône-Alpes).]]

Die wundersame Speisung der mehreren Tausend mit wenigen Broten und Fischen wird in aller vier Evangelien der Bibel erwähnt. Das Ereignis fand auf einem Berg am Ufer des Sees von Galiläa (auch als &quot;See von Tiberias&quot;, &quot;See Genezareth&quot; oder &quot;Galiläisches Meer&quot; bekannt) statt. In der abgelegenen Gegend gab es damals sehr wenig künstliche Lichtquellen, so dass ein ungestörter Anblick des Sternenhimmels möglich war.

===== Evangelium nach Johannes =====
Im sechsten Kapitel des Evangeliums nach '''Johannes''' tauchen bei der Beschreibung der Brotvermehrung durch Jesus zum jüdischen Pessachfest neben einigen weiteren Symbolen mit astronomischer Deutungsmöglichkeit auch die expliziten Zahlen Zwei, Fünf und Zwölf auf:

&lt;blockquote&gt;
9 Hier ist ein kleiner Junge, der hat '''fünf Gerstenbrote''' und '''zwei Fische'''; doch was ist das für so viele?&lt;br/&gt;
10 Jesus sagte: Lasst die Leute sich setzen! Es gab dort nämlich viel Gras. Da setzten sie sich; es waren etwa '''fünftausend''' Männer.&lt;br/&gt;
11 Dann nahm Jesus die '''Brote''', sprach das Dankgebet und teilte an die Leute aus, so viel sie wollten; ebenso machte er es mit den '''Fischen'''.&lt;br/&gt;
12 Als die Menge satt geworden war, sagte er zu seinen Jüngern: Sammelt die übrig gebliebenen Brocken, damit nichts verdirbt!&lt;br/&gt;
13 Sie sammelten und füllten '''zwölf Körbe''' mit den Brocken, die von den '''fünf Gerstenbroten''' nach dem Essen übrig waren.&lt;br/&gt;
...&lt;br/&gt;
31 Unsere Väter haben das '''Manna''' in der Wüste gegessen, wie es in der Schrift heißt: '''Brot vom Himmel''' gab er ihnen zu essen.&lt;br/&gt;
32 Jesus sagte zu ihnen: Amen, amen, ich sage euch: Nicht Mose hat euch das '''Brot vom Himmel''' gegeben, sondern mein Vater gibt euch das wahre '''Brot vom Himmel'''.&lt;br/&gt;
33 Denn das '''Brot''', das Gott gibt, kommt vom '''Himmel''' herab und gibt der Welt das Leben.&lt;br/&gt;
34 Da baten sie ihn: Herr, gib uns immer dieses '''Brot'''!&lt;br/&gt;
35 Jesus antwortete ihnen: Ich bin das '''Brot des Lebens'''; wer zu mir kommt, wird nie mehr hungern, und wer an mich glaubt, wird nie mehr Durst haben.&lt;br/&gt;
...&lt;br/&gt;
48 Ich bin das '''Brot des Lebens'''.&lt;br/&gt;
49 Eure Väter haben in der Wüste das '''Manna''' gegessen und sind gestorben.&lt;br/&gt;
50 So aber ist es mit dem '''Brot''', das vom '''Himmel''' herabkommt: Wenn jemand davon isst, wird er nicht sterben.&lt;br/&gt;
51 Ich bin das '''lebendige Brot''', das vom '''Himmel''' herabgekommen ist. Wer von diesem '''Brot''' isst, wird in Ewigkeit leben. Das '''Brot''', das ich geben werde, ist mein Fleisch für das Leben der Welt.
&lt;/blockquote&gt;

===== Evangelium nach Markus =====
Eine ähnliche Schilderung befindet sich im sechsten Kapitel des Evangeliums nach '''Markus''', wo das Ereignis an einem abgelegenen und einsamen Ort stattgefunden hat:

&lt;blockquote&gt;
38 Er sagte zu ihnen: Wie viele '''Brote''' habt ihr? Geht und seht nach! Sie sahen nach und berichteten: '''Fünf Brote''' und außerdem '''zwei Fische'''.&lt;br/&gt;
39 Dann befahl er ihnen, sie sollten sich in Mahlgemeinschaften im grünen Gras lagern.&lt;br/&gt;
40 Und sie ließen sich in Gruppen zu hundert und zu fünfzig nieder.&lt;br/&gt;
41 Darauf nahm er die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis, brach die '''Brote''' und gab sie den Jüngern, damit sie diese an die Leute austeilten. Auch die '''zwei Fische''' ließ er unter allen verteilen.&lt;br/&gt;
42 Und alle aßen und wurden satt.&lt;br/&gt;
43 Und sie hoben Brocken auf, '''zwölf Körbe''' voll, und Reste von den '''Fischen'''.&lt;br/&gt;
44 Es waren '''fünftausend''' Männer, die von den '''Broten''' gegessen hatten.
&lt;/blockquote&gt;

Die Brotvermehrung auch ein weiteres Mal im achten Kapitel des Evangeliums nach '''Markus''' erwähnt:

&lt;blockquote&gt;
5 Er fragte sie: Wie viele '''Brote''' habt ihr? Sie antworteten: '''Sieben'''.&lt;br/&gt;
6 Da forderte er die Leute auf, sich auf den Boden zu setzen. Dann nahm er die sieben '''Brote''', sprach das Dankgebet, brach die '''Brote''' und gab sie seinen Jüngern zum Verteilen; und die Jünger teilten sie an die Leute aus.&lt;br/&gt;
7 Sie hatten auch noch ein paar '''Fische''' bei sich. Jesus segnete sie und ließ auch sie austeilen.&lt;br/&gt;
8 Die Leute aßen und wurden satt. Und sie hoben die Überreste der '''Brotstücke''' auf, '''sieben Körbe''' voll.&lt;br/&gt;
9 Es waren etwa '''viertausend''' Menschen beisammen. Danach schickte er sie nach Hause.&lt;br/&gt;
...&lt;br/&gt;
19 Als ich die '''fünf Brote''' für die '''Fünftausend''' brach, wie viele '''Körbe voll Brotstücke''' habt ihr da aufgehoben? Sie antworteten ihm: '''Zwölf'''.&lt;br/&gt;
20 Und als ich die '''sieben Brote''' für die '''Viertausend''' brach, wie viele '''Körbe''' voll habt ihr da aufgehoben? Sie antworteten: '''Sieben'''.&lt;br/&gt;
21 Da sagte er zu ihnen: Versteht ihr immer noch nicht?
&lt;/blockquote&gt;

===== Evangelium nach Lukas =====
Ebenso verhält es sich im neunten Kapitel des Evangeliums nach '''Lukas''', wo das Ereignis dem Ort Betsaida (zu Deutsch: „Haus des Fisches“) am See Genezareth zugeordnet ist:

&lt;blockquote&gt;
12 Als der Tag zur Neige ging, kamen '''die Zwölf''' und sagten zu ihm: Schick die Leute weg, damit sie in die umliegenden Dörfer und Gehöfte gehen, dort Unterkunft finden und etwas zu essen bekommen; denn wir sind hier an einem abgelegenen Ort.&lt;br/&gt;
13 Er antwortete ihnen: Gebt ihr ihnen zu essen! Sie sagten: Wir haben nicht mehr als '''fünf Brote''' und '''zwei Fische'''; wir müssten erst weggehen und für dieses ganze Volk etwas zu essen kaufen.&lt;br/&gt;
14 Es waren nämlich etwa '''fünftausend''' Männer. Er aber sagte zu seinen Jüngern: Lasst sie sich in Gruppen zu ungefähr fünfzig lagern!&lt;br/&gt;
15 Die Jünger taten so und veranlassten, dass sich alle lagerten.&lt;br/&gt;
16 Jesus aber nahm die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis und brach sie; dann gab er sie den Jüngern, damit sie diese an die Leute austeilten.&lt;br/&gt;
17 Und alle aßen und wurden satt. Als man die übrig gebliebenen Brotstücke einsammelte, waren es '''zwölf Körbe''' voll.
&lt;/blockquote&gt;

===== Evangelium nach Matthäus =====
Auch im vierzehnten Kapitel des Evangeliums nach '''Matthäus''' ist von einem abgelegenen Ort in einer einsamen Gegend die Rede:

&lt;blockquote&gt;
17 Sie sagten zu ihm: Wir haben nur '''fünf Brote''' und '''zwei Fische''' hier.&lt;br/&gt;
18 Er antwortete: Bringt sie mir her!&lt;br/&gt;
19 Dann ordnete er an, die Leute sollten sich ins Gras setzen. Und er nahm die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis, brach die Brote und gab sie den Jüngern; die Jünger aber gaben sie den Leuten&lt;br/&gt;
20 und alle aßen und wurden satt. Und sie sammelten die übrig gebliebenen Brotstücke ein, '''zwölf Körbe''' voll.&lt;br/&gt;
21 Es waren etwa '''fünftausend''' Männer, die gegessen hatten, dazu noch Frauen und Kinder.
&lt;/blockquote&gt;

Etwas abgewandelt taucht die Brotvermehrung mit '''sieben Körben''' auch im fünfzehnten Kapitel des Evangeliums nach '''Matthäus''' auf:

&lt;blockquote&gt;
34 Jesus sagte zu ihnen: Wie viele '''Brote''' habt ihr? Sie antworteten: '''Sieben''' - und ein paar '''Fische'''.&lt;br/&gt;
35 Da forderte er die Leute auf, sich auf den Boden zu setzen.&lt;br/&gt;
36 Und er nahm die '''sieben Brote''' und die '''Fische''', sprach das Dankgebet, brach sie und gab sie den Jüngern und die Jünger gaben sie den Menschen.&lt;br/&gt;
37 Und alle aßen und wurden satt. Und sie sammelten die übrig gebliebenen Stücke ein, '''sieben Körbe''' voll.&lt;br/&gt;
38 Es waren '''viertausend''' Männer, die gegessen hatten, dazu noch Frauen und Kinder.&lt;br/&gt;
39 Danach schickte er die Menge nach Hause, stieg ins Boot und fuhr in die Gegend von Magadan.
&lt;/blockquote&gt;

Der Ort Magadan ist möglicherweise mit dem heutigen Ort Migdal (aramäisch: Magdala) am westlichen Ufer des Sees Genezareth gleichzusetzen.

==== Astronomische Bezüge ====
[[Datei:Sternenhimmel.Pessach.25.3.23.png|mini|rechts|hochkant=2|Sternenhimmel am jüdischen Pessachfest im Jahr 25 nach Christus. Der Vollmond stand hoch über dem Horizont im Süden im Herbstpunkt beim Stern Spica (= &quot;Kornähre&quot;) im Sternbild Jungfrau (Virgo). Gleichzeitig befand sich die Sonne tief unter dem Horizont im Norden in der Nähe des Frühlingspunktes im Sternbild Fische (Pisces).]]
[[Datei:Dendera.09.Jungfrau.Loewe.jpg|mini|rechts|hochkant=2|Das Sternbild Jungfrau (links) mit der Kornähre in der Hand und das Sternbild Löwe (rechts) im ägyptischen Zodiak von Dendera aus der Zeit kurz vor Christi Geburt.]]
[[Datei:Dendera.03.Fische.Wassermann.jpg|mini|rechts|hochkant=2|Das Sternbild Fische (links) und das Sternbild Wassermann (rechts unten) im ägyptischen Zodiak von Dendera aus der Zeit kurz vor Christi Geburt.]]

Zu diesen Bibelstellen sind im Folgenden einige Hinweise mit astronomischen Bezügen aufgeführt. Die [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|Bezugspunkte]] liegen hierbei in der Nähe der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Die_Ekliptik|Ekliptik]]:

* In den Versen im Evangelium nach Johannes ist mehrfach vom '''Brot, das vom Himmel herabkommt''' die Rede.
* Das zur Herstellung von Brot erforderliche Getreide kann durch eine '''Kornähre''' symbolisiert werden. Am Sternenhimmel wird die Kornähre durch den hellen, ekliptiknahen Stern '''Spica''' (α Virginis) im Sternbild '''Jungfrau''' (Virgo) repräsentiert. Der Vollmond stand zum jüdischen Pessachfest beim Stern Spica.
* Alle Pflanzen benötigen für das Gedeihen '''Wasser'''. Das '''Wasser''' wird am Himmel durch die drei Wassersternbilder der Ekliptik '''Fische''' (Pisces), '''Wassermann''' (Aquarius), und '''Ziegenfisch''' (Steinbock, Capricornus) westlich des [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Frühlingspunkt|Frühlingspunktes]] repräsentiert. Diese Sternbilder bilden mit einigen weiteren angrenzenden Wassersternbildern den [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|Urozean am Himmel]] (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Trichter_der_Thuraya|Der Trichter der Thuraya]]). Die Wassersternbilder waren zum Pessachfest in den drei Monaten unmittelbar zuvor von der Sonne durchlaufen worden und befanden sich beim Sonnenuntergang deshalb bereits unterhalb des westlichen Horizonts.
* Das Sternbild '''Fische''' (Pisces) besteht seit der Antike aus '''zwei Fischen'''.
* Zu Lebzeiten von Jesus von Nazareth war der '''Frühlingspunkt''' vom Sternbild Widder (Aries, ursprünglich das Hinterteil des großen Sternbilds [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|Himmelsstier (Taurus caeli)]]) in das Sternbild '''Fische''' (Pisces) gewandert. Inzwischen ist er innerhalb dieses Sternbilds noch weiter nach Westen gewandert. Die Sonne und der Neumond standen zu Beginn des jüdischen Monats Nisan, also dem Monat des jüdischen Pessachfestes, im Sternbild '''Fische'''. Der erste Monat des Jahres Nisan hieß bereits in der mesopotamischen Tradition, als sich der Frühlingspunkt noch im Sternbild Widder (Aries) befand, auf Akkadisch &quot;nisannu&quot; (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|Plejaden-Schaltregeln]]). In der alten jüdischen Tradition war der Nisan deswegen mit dem Sternbild Widder verbunden. Ferner wurde der Widder dem israelitischen Stamm Juda zugeordnet.
* Zu Lebzeiten von Jesus von Nazareth war der '''Herbstpunkt''' vom Sternbild Waage (Libra, ursprünglich die Scheren des großen Sternbilds [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsskorpion|Himmelsskorpion (Scorpio caeli)]]) in das Sternbild Jungfrau (Virgo) gewandert. Inzwischen ist er innerhalb dieses Sternbilds noch weiter nach Westen gewandert. Um 285 nach Christi erreichte der '''Herbstpunkt''' dann die ekliptikale Länge des Sterns '''Spica''' (α Virginis).
* Der '''Frühlingspunkt''' –&amp;nbsp;damals im Sternbild Fische&amp;nbsp;– und der '''Herbstpunkt''' –&amp;nbsp;damals im Sternbild Jungfrau (Virgo) beim Stern Spica&amp;nbsp;– befinden sich immer in genau gegenüber liegenden Punkten auf der Ekliptik. Auf diese Weise umfassen diese beiden ausgezeichneten Punkte den Lebewesenkreis (Zodiak) mit seinen '''zwölf''' Sternbildern sowie die Bahnen aller '''sieben''' Wandelgestirne. Diese beiden Punkte teilten die Ekliptik in '''zwei''' gleichgroße Teile, das Sommerhalbjahr und das Winterhalbjahr. Siehe hierzu auch &quot;[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|Beobachtungen in der Nähe der Ekliptik]]&quot;.
** Die '''fünf Brote''' können also mit den fünf mit bloßem Auge sichtbaren Wandelgestirnen (Planeten) '''Merkur''', '''Venus''', '''Mars''', '''Jupiter '''und '''Saturn''' gleichgesetzt werden.&lt;br/&gt;'''''Anmerkung''': In der Bibel wird in der Regel nicht zwischen Fixsternen und Planeten unterschieden. Für eine Ausnahme siehe 2.&amp;nbsp;Buch der Könige, Kapitel 23, Vers 5 aus dem siebenten vorchristlichen Jahrhundert, wo in der Einheitsübersetzung explizit von &quot;den Wandelsternen&quot; und in der Luther-Bibel von &quot;den Planeten&quot; die Rede ist.&lt;ref&gt;[https://www.bibleserver.com/EU/2.K%C3%B6nige23%2C5 2.&amp;nbsp;Buch der Könige, Kapitel 23, Vers 5], bibleserver.com, Einheitsübersetzung 2016&lt;/ref&gt; Die Vulgata schreibt hier allerdings von den &quot;duodecim signis&quot; (zu Deutsch: &quot;'''zwölf''' Zeichen&quot;), womit die '''zwölf''' Sternzeichen der Ekliptik gemeint sind, durch die die '''sieben''' Wandelgestirne ziehen. Die Septuaginta spricht noch allgemeiner von den &quot;μαζουρωθ&quot; (&quot;mazuroth&quot;) nach dem Hebräischen Wort &quot;מַזָּלָה&quot; (&quot;mazzaroth&quot;), womit allgemein eher Sternkonstellationen und nur im engeren Sinne die Sternzeichen des Zodiaks gemeint sind.''
** Die '''zwei Fische''' können also mit den beiden flächenhaft wahrnehmbaren Wandelgestirnen '''Sonne''' und '''Mond '''gleichgesetzt werden.
** Die Summe der '''fünf Brote''' und der '''zwei Fische''' respektive die '''sieben Brote''' (oder die '''sieben Körbe''') entsprechen der Anzahl der freiäugig sichtbaren '''sieben Wandelgestirne''', die sich entlang der Ekliptiklinie stetig gegenüber dem Fixsternhimmel bewegen. Siehe hierzu auch &quot;[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Zusammenhang_mit_dem_Stier|Zu den Etyma und den Kognaten von &quot;Sieben&quot;, &quot;Stier&quot;, &quot;Gestirn&quot; und &quot;Stern&quot;]]&quot;.
** Die ausgeteilten '''Brote''' und '''Fische''' durchmaßen die gesamte versammelte Menschenmenge, die durch den vollständigen [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|Lebewesenkreis (Zodiak)]] mit den '''zwölf Lebewesenkreiszeichen''' beziehungsweise durch die '''zwölf Körbe''' symbolisiert wird. Der Planet Jupiter, der den Zodiak in zwölf Jahren einmal durchläuft, wurde in Babylonien mit dem babylonischen Hauptgott Marduk gleichgesetzt.
* Insgesamt gibt es am Fixsternhimmel gut 2800&amp;nbsp;Sterne bis zur scheinbaren Helligkeit 5,5&lt;sup&gt;m&lt;/sup&gt; und knapp 8800&amp;nbsp;Sterne bis zur scheinbaren Helligkeit&amp;nbsp;6,5&lt;sup&gt;m&lt;/sup&gt;, die ohne Lichtverschmutzung mit bloßem Auge als einzelne Lichtpunkte gesehen werden können. Diese verteilen sich allerdings in der gesamten Himmelssphäre, so dass von einem Punkt auf der Erdoberfläche aus zu jedem Zeitpunkt immer nur ungefähr die Hälfte davon über dem Horizont steht. An den beiden Polen sind stets nur die Sterne der jeweiligen nördlichen oder südlichen Hemisphäre zu sehen, und am Äquator können im Laufe eines Jahres alle Sterne gesehen werden. Je nach Breitengrad und Zeitpunkt können bei Neumond (kein Streulicht) innerhalb einer wolkenlosen Nacht viertausend bis zu fast siebentausend Sterne beobachtet werden.&lt;ref&gt;Bob King: [https://skyandtelescope.org/astronomy-blogs/how-many-stars-night-sky-09172014/ 9,096 Stars in the Sky—Is that all? How many stars in the sky can you see?], skyandtelescope.org - The essential Guide to Astronomy, 17. September 2014&lt;/ref&gt; Diese Spanne entspricht der Angabe der bei der Brotvermehrung versammelten Menschen, deren Anzahl in den Evangelien mit '''viertausend''' beziehungsweise '''fünftausend''' angegeben ist.
** Im ersten Buch des Alten Testaments ('''Genesis''') wird Abram aus Ur in Mesopotamien bereits das Folgende prophezeit:
&lt;blockquote&gt;
15,5 ''Sieh doch zum Himmel hinauf und zähl die Sterne, wenn du sie zählen kannst! Und er sprach zu ihm: So zahlreich werden deine Nachkommen sein''&lt;br/&gt;
...&lt;br/&gt;
17,5 ''Man wird dich nicht mehr Abram nennen. Abraham, Vater der Menge, wird dein Name sein; denn zum Stammvater einer Menge von Völkern habe ich dich bestimmt.''
&lt;/blockquote&gt;
* Die Gruppen von (ungefähr) '''fünfzig''' oder '''hundert Männern''' entsprechen den Sternbildern, die über den gesamten Himmel verteilt sind. Nach der Festlegung der Internationalen Astronomischen Union (IAU) von 1930 gibt es heute 88&amp;nbsp;Sternbilder, die den Himmel vollständig abdecken. Mit den maximal fast 8800&amp;nbsp;freiäugig sichtbaren Sternen entspricht dies im Mittel also 100&amp;nbsp;Sternen pro Sternbild. Bei 4400&amp;nbsp;freiäugig sichtbaren Sternen wären es 50&amp;nbsp;Sterne pro Sternbild. Dies entspricht genau der Spanne der Gruppenstärke, die im Neuen Testament angegeben sind.
* Das '''Brot''' und der '''Wein''' werden nach der christlichen Lehre bei der Transsubstantiation in den Leib und das Blut des vom '''Himmel''' herabgekommenen &quot;Brot des Lebens&quot; (vergleiche die Rede über das Himmelsbrot von Jesus in der Synagoge von Kafarnaum in Evangelium nach Johannes 6,48–58) gewandelt, das die kosmische Ewigkeit verheißt.

Die Zahlen '''Zwei''', '''Fünf''', '''Sieben''' und '''Zwölf''' stehen in einem einfachen arithmetischen Zusammenhang, bei dem die beiden jeweils vorhergehenden Zahlen der Folge addiert werden:

{| class=&quot;wikitable&quot;
|+
|'''Zahl'''
|'''Summe'''
|'''Anmerkung'''
|-
|'''2'''
|
|Anzahl der freiäugig als '''flächenhaft wahrnehmbaren Wandelgestirne''' ('''Sonne''' und '''Mond'''), siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwei|Zur Zwei]]
|-
|'''5'''
|
|Anzahl der freiäugig als '''punktförmig wahrnehmbaren Wandelgestirne''' '''Merkur''', '''Venus''', '''Mars''', '''Jupiter''', '''Saturn'''
|-
|'''7'''
|= 2 + 5
|Anzahl der freiäugig wahrnehmbaren '''Wandelgestirne''' sowie der '''Tage in der Woche''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Sieben|Zur Sieben]]
|-
|'''12'''
|= 5 + 7
|Anzahl der '''Monate im Jahr''', der '''Lebewesenkreiszeichen des Zodiaks''' sowie der '''Erdenjahre pro Jupiterjahr''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwölf|Zur Zwölf]], vergleiche hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|Der Zodiak]]
|-
|'''19'''
|= 7 + 12
|Anzahl der '''Jahre''' mit '''zwölf Monaten''' und '''sieben Schaltmonaten''' einer '''Meton-Periode''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Neunzehn|Zur Neunzehn]], vergleiche hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|Die Plejaden-Schaltregeln]] und [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Mondzyklen#Der_Meton-Zyklus|Der Meton-Zyklus]]
|}

=== Weitere Bezüge ===
Weitere Bezüge von der Astronomie zur Theologie ergeben sich bei den folgenden Sachverhalten:

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Biblische_Erwähnungen|'''biblische Erwähnungen von Konstellationen''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Der_Stern_von_Bethlehem|'''Der Stern von Bethlehem''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Ochs_und_Esel|'''Ochs und Esel / Krippe / „Ich bin das Alpha und das Omega“''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Biblische_Bezüge|'''Biblische Bezüge zu den Mondhäusern / Mondstationen''']].

== Zur Kosmologie ==
[[Datei:Kosmologisches.Modell.Schwarze.Schale.Rotverschiebung.png|mini|rechts|hochkant=2.5|Ein kosmologisches Modell unseres im Zentrum isotropen und inhomogenen Universums, das von einer undurchsichtigen und massereichen schwarzen Kugelschale umgeben ist. Von der äußeren Region aus betrachtet, ist unser Universum ein gigantisches Schwarzes Loch. Zwischen dem inneren und dem äußeren Bereich der schwarzen Kugelschale ist kein Informationsaustausch möglich. Jegliche Materie, die von innen oder außen in die schwarze Kugelschale gelangt, ist von innen und von außen nicht mehr sichtbar. Sowohl die innere als auch die äußere Grenze der schwarzen Kugelschale stellen demzufolge einen Ereignishorizont dar.]]

Die '''Kosmologie''' beschäftigt sich mit der Struktur, dem Ursprung und der Entwicklung des Universums. Dadurch ergeben sich zahlreiche Bezüge zur beobachtenden '''Astronomie''' und zur '''Astrophysik''', aber auch zur '''Quantenphysik'''.

In der Antike gingen die Menschen noch davon aus, dass sich die Erde im Mittelpunkt der Welt und somit auch in der Mitte des sichtbaren Universums befindet. Dieses geozentrische Weltbild wurde seit dem 16.&amp;nbsp;Jahrhundert, ausgelöst durch die kopernikanische Wende, zunehmend verworfen und durch ein heliozentrisches Weltbild ersetzt. Durch die Erfindung und Verwendung von Fernrohren konnten seit dem Beginn des 17.&amp;nbsp;Jahrhunderts immer mehr Details im Sternenhimmel entdeckt werden. Durch astronomische Beobachtungen ergaben sich immer mehr Indizien für die Tatsache, dass die Erde einmal pro Jahr auf einer Ellipsenbahn die Sonne umrundet und nicht die Sonne die Erde umkreist. Der Philosoph Immanuel Kant (1724–1804) erkannte bereits 1755 in seiner Allgemeinen Naturgeschichte und Theorie des Himmels das innere Wesen unserer Milchstraße. Mit der ersten zuverlässigen Messung der Parallaxe von unserer Erde zum benachbarten Fixstern 61&amp;nbsp;Cygni (&quot;Bessel's Stern&quot;) durch Friedrich Wilhelm Bessel (1784–1846) in Königsberg und der daraus folgenden Berechnung von dessen Entfernung von gut zehn Lichtjahren im Jahr 1838 war die Tatsache, dass die Erde um die Sonne läuft, endgültig bewiesen.

Die Auswertung der astronomischen Beobachtungen hat zu der heute allgemein geteilten Auffassung geführt, dass unser Universum bei einem Urknall entstanden ist und seitdem expandiert. Die Berücksichtigung des Äquivalenzprinzips zwischen schwerer und träger Masse, das zu der von '''Albert Einstein''' (1879–1955) formulierten Allgemeinen Relativitätstheorie führt, brachte '''Alexander Friedmann''' (1888–1925) 1922 zu der theoretischen Vorhersage eines dynamischen Universums. Fünf Jahre später schlussfolgerte der belgische Astronom '''Georges Lemaître''' (1894–1966) aus den von '''Vesto Slipher''' (1875–1969) beobachteten Rotverschiebungen von fernen Galaxien und den von '''Edwin Hubble''' (1889–1953) ermittelten Entfernungen dieser Galaxien, dass das Universum expandiert. Aufgrund dieser Erkenntnis ergibt sich, dass das Universum einen Ursprung mit sehr kleinem Radius gehabt haben muss. Diesen Zustand nannte er &quot;primordiales Atom&quot; beziehungsweise &quot;Uratom&quot;. In der Folgezeit etablierte sich für diesen initialen Vorgang der Begriff &quot;'''Urknall'''&quot; (im Englischen: &quot;'''Big Bang'''&quot;).&lt;ref&gt;Markus Bautsch: ''[https://en.wikibooks.org/wiki/Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell/Brief_historical_review Moving objects in retarded gravitational potentials of an expanding spherical shell / Brief historical review], Wikibook (englisch), 2024, abgerufen am 28. Februar 2026&lt;/ref&gt;

Viele Astrophysiker versuchen heute mit dem sogenannten '''Standardmodell der Kosmologie''' (auch '''ΛCDM-Modell''' beziehungsweise Lambda-CDM-Modell, wobei &quot;CDM&quot; für &quot;cold dark matter&quot; steht, also für &quot;kalte, dunkle Materie&quot;) die Entwicklung des Universums nachzubilden. Hierfür wenden sie das kosmologische Prinzip an, das von zwei grundlegenden Annahmen ausgeht:&lt;ref&gt;Markus Bautsch: ''[https://en.wikibooks.org/wiki/Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell/Preface Moving objects in retarded gravitational potentials of an expanding spherical shell / Preface], Wikibook (englisch), 2024, abgerufen am 28. Februar 2026&lt;/ref&gt;

# Das Weltall sei '''homogen''', was bedeutet, dass es in groben Zügen von jedem Punkt aus gleich aussieht.
# Das Weltall sei '''isotrop''', was besagt, dass es in groben Zügen in jede Richtung gleich aussieht.

Mit diesen Annahmen kann das Modell berechnet werden, und mit diversen zusätzlichen Annahmen stimmt es in vielerlei Hinsicht mit den astronomischen Beobachtungen überein. Zu den zusätzlichen Annahmen gehören die folgenden beiden hypothetischen Größen:

* '''Kalte, dunkle Materie''', die zwar der Gravitation unterläge, aber keine Wechselwirkung mit elektromagnetischer Strahlung zeigt.
* Eine '''kosmologische Konstante''' Λ, die eine '''dunkle Energie''' beschreibt und für die beschleunigte Expansion des Universums verantwortlich sei.

Weder für die Homogenität noch für die Isotropie des Kosmos konnten bislang Belege gefunden werden, und auch für die kalte dunkle Materie und die dunkle Energie konnte bislang keine physikalische Interpretation geliefert werden.

Ferner ist auch die Annahme, dass die Naturkonstanten unveränderliche Werte haben, nicht begründbar. Auf kosmischen Zeitskalen kann es durchaus Änderungen geben, die wir derzeit nicht messen können. Die gilt insbesondere für die Hubble-Konstante, die die Expansionsrate des Universums beschreibt, für die Gravitationskonstante, die die Anziehung zweier Massen beschreibt, oder für die kosmologische Konstante, die die beschleunigte Expansion des Universums beschreibt. In diesem Kontext sei darauf hingewiesen, dass unser Universum genauso groß ist wie ein Schwarzes Loch mit der Masse unseres Universums. Deshalb gehen einige Kosmologen davon aus, dass wir innerhalb eines Schwarzen Loches der Größe und Masse unseres Universums leben könnten.

Siehe hierzu auch: [[:en:Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell|'''Moving objects in retarded gravitational potentials of an expanding spherical shell''']].

Darüber hinaus mehren sich Anzeichen und Hinweise, die gegen die Ergebnisse des Standardmodells der Kosmologie sprechen, beziehungsweise durch weitere Hypothesen, die physikalisch nicht begründet werden können, im Standardmodell berücksichtigt werden müssen. Die folgende unvollständige Liste soll hierzu einige Anhaltspunkte liefern:

* Präzise astronomische Beobachtungen zeigen, dass das Weltall auch auf großen Längenskalen '''nicht homogen''' ist, sondern Strukturen zeigt.
* Präzise astronomische Beobachtungen zeigen, dass das Weltall auch auf großen Längenskalen '''nicht isotrop''' ist (Asymmetrie der kosmischen Hintergrundstrahlung).
* Die Hubble-Konstante hat heute einen anderen Wert als früher (&quot;'''Hubble tension'''&quot;), was mit dem Standardmodell nicht im Einklang steht.
* Das beobachtete Vorkommen des dritten Elements im Periodensystem, also des Alkalimetalls '''Lithium''', ist mindestens dreimal geringer als vom Standardmodell vorhergesagt.
* Die '''Rotverschiebung von fernen Galaxien''' ist deutlich größer als es nach dem Standardmodell möglich wäre.
* Die beobachteten '''Rotationskurven von Spiralgalaxien''' stehen im Widerspruch zu den Ergebnissen des Standardmodells.
* Das Standardmodell ist nicht in der Lage, die Abwesenheit von '''Antimaterie''' im sichtbaren Teil des Universums zu erklären.
* Die im frühen Universum beobachteten '''primordialen Schwarzen Löcher und Galaxien''' mit explodierende '''Supernovae''' sowie dem Vorkommen von '''Sauerstoff''' stehen im Widerspruch zu den Ergebnissen des Standardmodells.

== Zur Astrologie ==
Eine Sonderstellung nimmt die '''{{w|Astrologie}}''' (zusammengesetzt mit dem altgriechischen ἄστρον (&quot;astron&quot;), zu Deutsch „Sternenlehre“) ein. Sie ist ein weiteres Beispiel für eine Disziplin, bei der grundlegende Kenntnisse über die Astronomie eine Voraussetzung sind. Sie versucht, Zusammenhänge zwischen den Konstellationen der Wandelgestirne oder astronomischen Ereignissen am Sternenhimmel mit irdischen Geschehnissen oder Veränderungen herzustellen, insbesondere was bestimmte Konjunktionen und daraus abgeleitete Prophezeiungen betrifft. Sie wurde bereits in Mesopotamien und in anderen alten Kulturkreisen von Astronomen ausgeübt. Noch der Astronom '''{{w|Johannes Kepler}}''' (1571–1630) hat als einer der letzten Astronomen einen wesentlichen Teil seiner Einkünfte durch die Erstellung von Horoskopen bestritten. Aber schon Aristoteles hatte festgestellt und beschrieben, dass die bei bestimmten Konstellationen am Himmel vorhergesagten Ereignisse nicht eingetreten waren.

Vor der Aufklärung haben astrologische Prophezeiungen noch eine große und weitreichende gesellschaftliche Bedeutung gehabt. Als Beispiel seien die Behauptungen des ersten im Kurfürstentum Brandenburg tätigen Astrologen '''{{w|Johannes Carion}}''' (1499–1537) genannt, der für 1524 eine Sintflut vorhersagte, die nicht eingetroffen ist.&lt;ref&gt;{{Literatur |Autor=Markus Bautsch, Friedhelm Pedde |Titel=Vor 500 Jahren: Die Sintflut von 1524 die nicht stattfand |Online=https://wfs.berlin/wp-content/uploads/2024/05/A19-BROplanetA4_40s-feb2024ff_www-rz.pdf |Sammelwerk=Dem Himmel nahe. |WerkErg=Mitteilungen der Wilhelm-Foerster-Sternwarte e.V.|Nummer=19 |Hrsg=Wilhelm-Foerster-Sternwarte e.V. / Zeiss-Planetarium am Insulaner |Ort=Berlin |Datum=2024-02 |Seiten=16–19 |Sprache=de |Abruf=2025-08-03|ISSN=2940-9330}}&lt;/ref&gt; Der Wiener Hofastronom '''{{w|Georg Tannstetter}}''' (1482–1535) sah sich 1523 bemüßigt, die schon lange im Voraus erhitzten und besorgten Gemüter zu beruhigen:&lt;ref&gt;Georg Tannstetter: ''Libellus consolatorius contra opiniones de diluvio et aliis horrendis periculis anni 1523''&lt;/ref&gt;

&lt;blockquote&gt;
Nun hat sich überall, in allen Köpfen, in allen Seelen das Gerücht eingeschlichen:&lt;br/&gt;
die Gelehrten und Weisen sind in ständigem Streitgespräch, andere hingegen sind derart verstört, dass sie ihren Geschäften nicht mehr nachgehen können; sie verkaufen ihre Anwesen, ihre Felder und Besitztümer oder lassen davon ab, Güter zu kaufen, in der Hoffnung, ihr Geld leichter in die sicheren Berge transportieren zu können. Andere wiederum verschieben ihr Heiratsversprechen, kündigen ohne scheinbaren Grund Verträge auf, entziehen sich ihren christlichen Gelübden, arbeiten faul und missmutig auf dem Land und fragen sich, was es denn nütze, Geld und Gut anzuhäufen, wenn doch in kürzester Zeit niemand mehr davon Nutzen ziehen könne.
&lt;/blockquote&gt;

'''→ Siehe auch:'''

* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Definition|'''Konjunktionen''', Abschnitt '''Definition''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Historische_Konjunktionen|'''Historische Konjunktionen''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|'''Beobachtungen in der Nähe der Ekliptik''']].
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

== Einzelnachweise ==
&lt;references&gt;&lt;/references&gt;</text>
      <sha1>4q5aqrlx996t7f2o5v3ekw4bpxzwmvn</sha1>
    </revision>
    <revision>
      <id>1088599</id>
      <parentid>1088598</parentid>
      <timestamp>2026-07-04T09:27:26Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <minor />
      <comment>/* Himmelspforte */ war</comment>
      <origin>1088599</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="87903" sha1="5pd0s2yjl8rjli7d53jgsz3mjkniseo" xml:space="preserve">Viele Bezeichnungen für verschiedene Lehren werden mit der aus dem Altgriechischen stammenden Endung &quot;-logie&quot; (altgriechisch λόγος (&quot;logos&quot;), zu Deutsch „Lehre“) gebildet. Die folgenden Disziplinen sind in diesem Kontext hervorzuheben, da sie insbesondere für die '''{{w|Archäoastronomie}}''' wertvolle wissenschaftliche Ergänzungen zur '''{{w|Astronomie}}''' (aus den altgriechischen Wörtern ἄστρον (&quot;ástron&quot;, zu Deutsch „Stern“) und νόμος (&quot;nómos, zu Deutsch „Gesetz“) zusammengesetzt also „Sterngesetz“) liefern:

* Die '''{{w|Archäologie}}''' (zusammengesetzt mit dem altgriechischen Wort ἀρχαῖος (&quot;archaios&quot;), zu Deutsch „Altertumslehre“) beschäftigt sich mit der kulturellen Entwicklung der Menschheit.
* Die '''{{w|Etymologie}}''' (zusammengesetzt mit dem altgriechischen Wort ἔτυμος (&quot;etymos&quot;), zu Deutsch „Wortherkunftslehre“) untersucht die geschichtliche Herkunft von Wörtern.
* Die '''{{w|Mythologie}}''' (zusammengesetzt mit dem altgriechischen Wort μῦθος (&quot;mythos&quot;), zu Deutsch „Erzählungslehre“), die sich wissenschaftlich mit der Sagenwelt beschäftigt.
* Die '''{{w|Theologie}}''' (zusammengesetzt mit dem altgriechischen Wort θεός (&quot;theós&quot;), zu Deutsch „Gotteslehre“) mit ihren Lehren zum religiösen Glauben und dessen Glaubensdokumenten.
* Die '''{{w|Kosmologie}}''' (zusammengesetzt mit dem altgriechischen Wort κόσμος (&quot;kósmos&quot;), zu Deutsch „Weltenlehre“) ist hingegen eine Lehre, die sich im Laufe der Jahrtausende deutlich verändert hat und sich auch heute noch erheblich weiterentwickelt, da es in der modernen Astronomie und Astrophysik mit zunehmend hohem technischem Aufwand immer wieder zu neuen Erkenntnissen kommt.
* Die '''{{w|Numerologie}}''' (zusammengesetzt mit dem lateinischen Wort numerus, zu Deutsch „Zahlenlehre“) mit ihren mystischen Lehren über die symbolische Zuweisung von Bedeutungen an Zahlen.

Von der Antike bis ins Mittelalter galt die Beherrschung der '''{{w|sieben freien Künste}}''' als Voraussetzung für das Betreiben von Philosophie. Zu den drei &quot;trivialen&quot; Künsten der {{w|Grammatik}}, der {{w|Rhetorik}} und der {{w|Dialektik}} des '''{{w|Trivium|Triviums}}''' wurden die vier Künste der {{w|Musiktheorie}}, der {{w|Arithmetik}}, der {{w|Geometrie}} und der {{w|Astronomie}} zu den Künsten des '''{{w|Quadrivium|Quadriviums}}''' gezählt → siehe hierzu auch [[Quadriviale_Kuriositäten|'''Wikibook ''Quadriviale Kuriositäten''''']].

== Zur Etymologie ==
Die Genesis aus dem Alten Testament greift die Thematik der Verwirrung der einheitlichen Sprache in ihrem elften Kapitel auf, und beschreibt, wie die bereits sternenkundigen Menschen im Norden Mesopotamiens übermütig geworden waren und in Babel einen Turm mit einer Spitze '''bis in den Himmel''' errichten wollten:&lt;ref&gt;[https://www.bibleserver.com/EU/1.Mose11 Genesis 11], Genesis, Kapitel 11, Einheitsübersetzung&lt;/ref&gt;

&lt;blockquote&gt;
1 Die ganze Erde hatte eine Sprache und ein und dieselben Worte.&lt;br/&gt;
2 Als sie ostwärts aufbrachen, fanden sie eine Ebene im Land Schinar und siedelten sich dort an.&lt;br/&gt;
3 Sie sagten zueinander: Auf, formen wir Lehmziegel und brennen wir sie zu Backsteinen. So dienten ihnen gebrannte Ziegel als Steine und Erdpech als Mörtel.&lt;br/&gt;
4 Dann sagten sie: Auf, bauen wir uns eine Stadt und einen Turm mit einer Spitze '''bis in den Himmel'''! So wollen wir uns einen Namen machen, damit wir uns nicht über die ganze Erde zerstreuen.&lt;br/&gt;
5 Da stieg der HERR herab, um sich Stadt und Turm anzusehen, die die Menschenkinder bauten.&lt;br/&gt;
6 Und der HERR sprach: Siehe, ein Volk sind sie und eine Sprache haben sie alle. Und das ist erst der Anfang ihres Tuns. Jetzt wird ihnen nichts mehr unerreichbar sein, wenn sie es sich zu tun vornehmen.&lt;br/&gt;
7 Auf, steigen wir hinab und verwirren wir dort ihre Sprache, sodass keiner mehr die Sprache des anderen versteht.&lt;br/&gt;
8 Der HERR zerstreute sie von dort aus über die ganze Erde und sie hörten auf, an der Stadt zu bauen.&lt;br/&gt;
9 Darum gab man der Stadt den Namen Babel, Wirrsal, denn dort hat der HERR die Sprache der ganzen Erde verwirrt und von dort aus hat er die Menschen über die ganze Erde zerstreut.
&lt;/blockquote&gt;

Es mag weniger verwunderlich sein, dass Schöpfungsmythen oder Berichte über Katastrophen nicht nur einen astronomischen Hintergrund haben, sondern in völlig verschiedenen Kulturen sehr ähnliche Merkmale zeigen, wenn man sich das Folgende bewusst macht: Einige Indizien deuten auf einen für viele Kulturen gemeinsamen Ursprung hin, der auf eine tiefsinnige Betrachtung und Beobachtung des Himmelsgeschehens hindeutet.

Bei bestimmten Wörtern sind die Ähnlichkeiten in vielen lebenden und toten Sprachen so auffällig, dass sie ein gemeinsames Ursprungswort (Etymon) haben und somit Kognaten sein dürften. 

=== &quot;Stern&quot; ===
Bei den Wörtern „Gestirn“ beziehungsweise „Stern“ sind die Ähnlichkeiten in vielen lebenden und toten Sprachen sehr auffällig, und diese Verwandtschaften mögen durch die Wörter für &quot;Stern&quot; in den folgenden Sprachen belegt werden:

* Akkadisch &quot;istar&quot;
* Indogermanisch &quot;ster&quot;
* Griechisch &quot;astro&quot; / &quot;asteri&quot;
* Lateinisch &quot;astrum&quot; / &quot;stella&quot;
* Althochdeutsch &quot;stern(o)&quot;
* Jiddisch &quot;shtern&quot;
* Katalanisch und Spanisch &quot;estrella&quot;
* Portugiesisch &quot;estrela&quot;
* Englisch &quot;star&quot;
* Niederländisch &quot;ster&quot;
* Westfriesisch &quot;stjer&quot;
* Italienisch und Korsisch &quot;stella&quot;
* Rumänisch &quot;stea&quot;
* Sardisch &quot;istedda&quot;
* Maltesisch &quot;stilla&quot;
* Französisch &quot;étoile&quot; aus Altfranzösisch &quot;estoile&quot;
* Galicisch &quot;estrela&quot;
* Walisisch &quot;seren&quot;
* Dänisch und Norwegisch &quot;stjerne&quot;
* Schwedisch &quot;stjärna&quot;
* Isländisch &quot;stjarna&quot;
* Kurdisch &quot;stêrk&quot;
* Gujarati &quot;Tārō&quot;
* Hindi &quot;तारा&quot; (taara)
* Marathi &quot;तारा&quot; (Tārā)
* Nepalesisch &quot;तारा&quot; (Tārā)
* Punjabi &quot;ਤਾਰਾ&quot; (Tārā)
* Singhalesisch &quot;තරුව&quot; (taruva)
* Khmer &quot;តារា&quot; (tara)
* Armenisch &quot;աստղ&quot; (astgh)
* Tadschikisch &quot;ситора&quot; (sitora)
* Hausa &quot;tauraro&quot;
* Krio &quot;sta&quot;

=== &quot;Stier&quot; ===
Eine starke Ähnlichkeit gibt es in vielen Sprachen auch zwischen den Wörtern „Stern“ und „Stier“. Der Stier bezeichnet zudem auch ein bedeutendes und eines der ältesten Sternbilder überhaupt:

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|'''Himmelsstier''']].

* Akkadisch und Assyrisch &quot;šūru&quot;
* Aramäisch &quot;tōra&quot;
* Hebräisch &quot;šǒr&quot;
* Ugaritisch &quot;twr&quot;
* Arabisch &quot;ثور&quot; (&quot;thawr&quot;)
* Griechisch &quot;ταύρος&quot; (&quot;tauros&quot;)
* Lateinisch &quot;taurus&quot;
* Althochdeutsch &quot;stior&quot;
* Italienisch, Katalanisch und Spanisch &quot;toro&quot;
* Galicisch &quot;touro&quot;
* Gallisch &quot;tarvos&quot;
* Französisch &quot;taureau&quot;
* Schwedisch &quot;tjur&quot;
* Dänisch &quot;tyr&quot;
* Irisch und Gälisch &quot;tarbh&quot;
* Wallisisch &quot;tarw&quot;

=== &quot;Horn&quot; ===
Auch die Hörner des Stieres betreffend setzen sich die vielen Ähnlichkeiten fort:

* Akkadisch &quot;carnu&quot;
* Aramäisch &quot;qeren&quot;
* Griechisch &quot;κόρνο&quot; (&quot;korno&quot;)
* Lateinisch &quot;cornu&quot;
* Maltesisch &quot;qrun&quot;*
* Arabisch &quot;قرون&quot; (&quot;qurun&quot;)
* Französisch &quot;corne&quot;
* Italienisch &quot;corne&quot;
* Rumänisch &quot;corn&quot;
* Haitianisch &quot;kòn&quot;

=== &quot;Sieben&quot; ===
Die in vielen Kulturen als heilig angesehene Zahl Sieben taucht im Zusammenhang mit der Astronomie als Anzahl der mit bloßem Auge sichtbaren Wandelgestirne und als Zahl der Hauptsterne in vielen Asterismen auf:

* Sieben Wandelgestirne: Sonne Mond, Merkur, Venus, Mars, Jupiter, Saturn
* Siebengestirn im Himmelsstier: Alkione, Atlas, Electra, Maia, Merope, Taygeta, Pleione
* Sternbild Orion: Beteigeuze, Rigel, Bellatrix, Alnilam, Alnitak, Saiph, Mintaka
* Asterismus Großer Wagen: Alioth, Dubhe, Alkaid, Mizar, Merak, Phekda, Megrez

→ Siehe auch:

* [[Quadriviale_Kuriositäten/_Zahlen#Zur_Sieben|'''Zur Sieben''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Der_Fixsternhimmel#Die_sieben_hellsten_Objekte_der_Ekliptik|'''Die sieben hellsten Objekte der Ekliptik''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Kalenderführung#Die_Siebentagewoche|'''Die Siebentagewoche''']].

Wegen der hohen kulturellen, rituellen oder mythischen Bedeutung gibt es in vielen Kulturen und Sprachen etymologische Übereinstimmungen:

* Akkadisch &quot;sebe&quot;
* Proto-Indoeuropäisch &quot;septḿ̥&quot;
* Hetitisch &quot;sipta&quot;
* Proto-Germanisch &quot;*sebun&quot;
* Althochdeutsch &quot;sibun&quot;
* Hebräisch &quot;sajin&quot; (Buchstabe) oder &quot;scheva&quot; (Wort)
* Etruskisch &quot;semph&quot;
* Maltesisch &quot;sebgħa&quot;
* Arabisch &quot;sabʿa&quot;
* Griechisch &quot;επτά&quot; (&quot;(h)epta&quot;)
* Lateinisch &quot;septem&quot;
* Ungarisch &quot;het&quot;
* Proto-Balto-slawisch &quot;septin&quot;
* Proto-Indo-Iranisch &quot;saptá&quot;
* Katalanisch &quot;set&quot;
* Spanisch &quot;siete&quot;
* Galicisch &quot;sete&quot;
* Lettisch &quot;septiņi&quot;
* Italienisch &quot;sette&quot;
* Französisch &quot;sept&quot;
* Englisch &quot;seven&quot;
* Wallisisch &quot;saith&quot;
* Bosnisch / Kroatisch &quot;sedam&quot;
* Rumänisch &quot;șapte&quot;
* Irisch &quot;seacht&quot;
* Swahili &quot;saba&quot;
* Haitianisch &quot;sèt&quot;

== Zur Mythologie ==
Seit Jahrtausenden blicken Menschen in den Nachthimmel und versuchen, die unzähligen Lichter am Firmament zu deuten. Schon früh begannen sie, die von ihnen erfundenen Sternbilder und die unablässig durch den Himmel ziehenden Wandelgestirne durch Geschichten über Götter, Helden oder andere Wesen zu interpretieren, zu erzählen und zum Teil über Jahrhunderte hinweg zu tradieren. Die '''Mythologie''' spielte dabei eine zentrale Rolle: Sie half nicht nur, eine symbolische Ordnung in den geheimnisvollen Kosmos zu bringen, sondern prägte auch viele der Bezeichnungen und Vorstellungen, die bis heute in der beschreibenden Astronomie überlebt haben.

Die Verbindung zwischen Mythologie und Astronomie ist tief verwurzelt und zeugt vom menschlichen Bedürfnis, das wahrgenommene, aber dennoch unfassbare Universum durch räumliche und zeitliche Vorstellungen sowie durch Erzählungen begreifbar zu machen. Das Geschehen am Himmel musste auf die Menschen vor der Erfindung der Bewegtbilder und des Films in der späten Neuzeit sowohl attraktiv als auch spektakulär gewirkt haben. So konnten verschiedene mythische Gestalten am Himmel durch ihre scheinbaren Handlungen wahrgenommen werden. Durch die Wiederholung solcher Deutungen konnten sich besonders beliebte Mythen im kulturellen Kontext über die Zeit verfestigen, und entsprechende Riten konnten sich etablieren.

Damit war auch eine wesentliche Voraussetzung für den Glauben der Menschen an eine höhere Macht oder mehrere höhere Mächte gegeben. Der Begriff '''Religion''' stammt vom lateinischen Inifiniv &quot;relegere&quot; ab. Dieses Verb bedeutet wörtlich übersetzt &quot;wieder lesen&quot; und meint im Sinne von &quot;überdenken&quot; das bewusste Wahrnehmen von Prophezeiungen oder Omen sowie das nachhaltige Beachten tradierter Vorschriften.

'''→ Siehe:'''

* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Der Urozean''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Sagenwelt|'''Die Plejaden / Sagenwelt''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Mythologie|'''Der Himmelsstier''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Babylonische_Himmelswege|'''Babylonische Himmelswege''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Mithraskult|'''Mithraskult und Tauroktonie''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Höhlenmalerei_in_der_Magura-Höhle|'''Die Höhlenmalerei in der Magura-Höhle''']].

== Zur Theologie ==
Die '''Theologie''' (vom Altgriechischen θεός = theós = Gott und λόγος = lógos = Lehre) ist die Lehre von einem Gott oder von mehreren Göttern. Sie lehrt einen ausgeprägten religiösen Glauben, begründet rituelle Traditionen und deutet die vorhandenen Glaubensdokumente.

[[Datei:Aristoteles.Theologie.png|mini|rechts|Wahrnehmbarkeit und Vergänglichkeit nach Aristoteles]]

Die Theologie des '''{{w|Aristoteles}}''' (384–322) postuliert drei mögliche Substanzen:&lt;ref&gt;Aristoteles: ''Metaphysik'', Kapitel XII (Λ), Philosophische Theologie, Seiten 1069a –1076a&lt;/ref&gt;

{| class=&quot;wikitable&quot;
|+ Mögliche Substanzen nach Aristoteles
! Nummer !! Substanz !! Erläuterung !! Interpretationsbeispiel
|-
| 1. || Die sinnlich wahrnehmbare und vergängliche Substanz || Konkrete Dinge, die nur eine begrenzte Teilhabe an der Ewigkeit haben. || Lebewesen
|-
| 2. || Die sinnlich wahrnehmbare und unvergängliche Substanz || Konkrete Dinge, die eine unbegrenzte Teilhabe an der Ewigkeit haben. || Die sieben Wandelgestirne und die Fixsterne
|-
| 3. || Die sinnlich nicht wahrnehmbare und unvergängliche Substanz || Lebendiger, unbewegter Beweger, der der Ursprung aller anderen Dinge ist. || Gott
|}

Dieses theologische Prinzip wurde später auch von '''{{w|Thomas van Aquin}}''' (1225-1274) in seinen ''Quinque viae ad Deum'' (&quot;Fünf Wege zu Gott&quot;) aufgegriffen:

{| class=&quot;wikitable&quot;
|+ Nach dem ''Quinque viae ad Deum'' (&quot;Fünf Wege zu Gott&quot;) von Thomas von Aquin
! Weg !! Bezeichnung !! Voraussetzung !! Feststellung !! Folgerung
|-
| Via&amp;nbsp;I || Bewegungsbeweis || In der Welt ist überall Bewegung. || Alles Bewegte muss von einem anderen in Bewegung gebracht worden sein. || Der Erstbeweger ist Gott.
|-
| Via&amp;nbsp;II || Kausalitätsbeweis || In der Welt gibt es überall Ursachen und Wirkungen. || Jede Wirkung muss eine Ursache haben. || Die erste Ursache der Welt ist Gott.
|-
| Via&amp;nbsp;III || Kontingenzbeweis || Alles Empirische in der Welt entsteht und vergeht wieder. || Jedes empirische Wesen muss das Sein von einem absoluten Wesen empfangen haben. || Das absolute Wesen ist Gott.
|-
| Via&amp;nbsp;IV || Stufenbeweis || In der Welt gibt es abgestuft gute, wahre und schöne Dinge. || Das absolute Wesen muss die höchste Güte, Wahrheit und Schönheit haben. || Das höchste Gute, Wahre und Schöne ist Gott.
|-
| Via&amp;nbsp;V || Finalitätsbeweis || In der Welt gibt es Ordnung und Gesetzmäßigkeit. || Ordnung und Gesetzmäßigkeit müssen auf einen denkenden Geist zurückgehen. || Dieser Geist kommt von Gott.
|}

Auch '''{{w|Gottfried Wilhelm Leibniz}}''' (1646-1717) lehnt sich in seiner Hypothese von „Gott als letztem und zureichendem Grund der Welt“ daran an.

Auch im 90. Psalm wird dieser Ansatz thematisiert:

&lt;blockquote&gt;
Das vierte Buch&lt;br/&gt;
Der '''ewige''' Gott – der '''vergängliche''' Mensch&lt;br/&gt;&lt;br/&gt;
1 Ein Bittgebet des Mose, des Mannes Gottes. O Herr, du warst uns Wohnung '''von Geschlecht zu Geschlecht'''.&lt;br/&gt;
2 '''Ehe geboren wurden die Berge, ehe du unter Wehen hervorbrachtest Erde und Erdkreis''', bist du '''Gott von Ewigkeit zu Ewigkeit'''.&lt;br/&gt;
3 '''Zum Staub zurückkehren lässt du den Menschen''', du sprichst: Ihr Menschenkinder, kehrt zurück!&lt;br/&gt;
4 Denn tausend Jahre sind in deinen Augen wie der Tag, der gestern vergangen ist, wie eine Wache in der Nacht.
&lt;/blockquote&gt;

Darüber hinaus gibt der vierte Vers einen deutlichen Hinweis auf das Verhältnis zwischen der Länge des viele Jahrtausende dauernden Präzessionszyklus und der Länge eines siderischen Monats: der Mond wandert entlang der Ekliptiklinie an einem Tag genauso weit wie der Frühlingspunkt in tausend Jahren.

→ Siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Präzession|'''Präzession''']].

Der griechische Dichter '''{{w|Aratos von Soloi}}''' in Kilikien (≈310–245) hatte seine astronomischen Kenntnisse vom Astronomen und Mathematiker '''{{w|Eudoxos von Knidos}}''' (geboren nach 390, gestorben nach 338) erhalten. In dem in der Antike verbreiteten Lehrgedicht Φαινόμενα (Phainomena = „Himmelserscheinungen“) von Aratos wird der Sternenhimmel in zahlreichen Hexametern beschrieben. Sein monumentales sechseckiges Grab aus der antiken Stadt Pompeiopolis wurde 2020 in der türkischen Provinz Mersin wiederentdeckt.&lt;ref&gt;Patricia Claus: [https://greekreporter.com/2021/07/11/memorial-tomb-of-ancient-greek-astronomer-aratus-unearthed-in-turkey/ Memorial Tomb of Ancient Greek Astronomer Aratus Unearthed in Turkey], The Greek Reporter, 11. Juli 2021&lt;/ref&gt;

Hier der Beginn des Prologs des Lehrgedichts:

&lt;blockquote&gt;
Εκ Διὸς ἀρχώμεσθα , τὸν οὐδέποτ᾽ ἄνδρες ἐῶμεν&lt;br/&gt;
῎Αῤῥητον . Μεσταὶ δὲ Διὸς πᾶσαι μὲν ἀγυιαὶ ,&lt;br/&gt;
Πᾶσαι δ᾽ ἀνθρώπων ἀγοραί · μεστὴ δὲ θάλασσα ,&lt;br/&gt;
Καὶ λιμένες. πάντη δὲ Διὸς κεχρήμεθα πάντες .&lt;br/&gt;
'''Τοῦ γὰρ καὶ γένος εἰμέν''' · ὁ δ᾽ ἤπιος ἀνθρώποισι&lt;br/&gt;
Δεξιὰ σημαίνει · λαοὺς δ᾽ ἐπὶ ἔργον ἐγείρει ,&lt;br/&gt;
Μιμνήσκων βιότοιο . λέγει δ᾽ , ὅτε βῶλος ἀρίστη&lt;br/&gt;
Βουσί τε καὶ μακέλῃσι · λέγει δ᾽ , ὅτε δεξιαὶ ὧραι ,&lt;br/&gt;
Καὶ φυτὰ γύρῶσαι , καὶ σπέρματα πάντα βαλέσθαι .&lt;br/&gt;
Αὐτὸς γὰρ τάγε σήματ᾽ ἐν '''οὐρανῷ''' ἐστήριξεν ,&lt;br/&gt;
'''Αστρα''' διακρίνας · ἐσκέψατο δ᾽ εἰς ἐνιαυτὸν&lt;br/&gt;
'''᾿Αστέρας''' , οἵ κε μάλιστα τετυγμένα σημαίνοιεν&lt;br/&gt;
᾿Ανδράσιν ὡράων , ὄφρ᾽ ἔμπεδα πάντα φύωνται .&lt;br/&gt;
Τῷ μιν ἀεὶ πρῶτόν τε καὶ ὕστατον ἱλάσκονται .&lt;br/&gt;
Χαῖρε , πάτερ , μέγα θαῦμα , μέγ᾽ ἀνθρώποισιν ὄνειαρ ,&lt;br/&gt;
Αὐτὸς καὶ προτέρη γενεή ! χαίροιτε δὲ , Μοῦσαι&lt;br/&gt;
Μειλίχιαι , μάλα πᾶσαι ! ἐμοί γε μὲν '''ἀστέρας''' εἰπεῖν ,&lt;br/&gt;
Ηἱ θέμις εὐχομένῳ , τεκμήρατε πᾶσαν ἀοιδήν .&lt;br/&gt;
Οἱ μὲν ὁμῶς πολέες τε , καὶ ἄλλυδις ἄλλοι ἐόντες ,&lt;br/&gt;
'''Οὐρανῷ''' ἕλκονται πάντ᾽ ἤματα συνεχὲς αἰεί.&lt;br/&gt;
Αὐτὰρ ὅγ᾽ οὐδ᾽ ὀλίγον μετανίσσεται · ἀλλὰ μάλ' αὕτως&lt;br/&gt;
'''῎Αξων''' οἱ ἐνάρηρεν · ἔχει δ᾽ ἀτάλαντον ἁπάντη&lt;br/&gt;
'''Μεσσηγὺς γαῖαν''' , περὶ δ᾽ '''οὐρανὸν''' αὐτὸν ἀγινεῖ.&lt;br/&gt;
Καί μιν πειραίνουσι δύω '''πόλοι''' ἀμφοτέρωθεν ·&lt;br/&gt;
᾿Αλλ᾽ ὁ μὲν οὐκ ἐπίοπτος · ὁ δ᾽ ἀντίος ἐκ '''Βορέαο''' ,&lt;br/&gt;
Ὑψόθεν Ὠκεανοῖο . Δύω δὲ μιν ἀμφὶς ἔχουσαι&lt;br/&gt;
'''Ἄρκτοι''' ἅμα τροχόωσι · τὸ δὴ καλέονται '''῞Αμαξαι''' .
&lt;/blockquote&gt;

Übersetzung unter Beibehaltung der Hexameter nach dem deutschen Dichter, Übersetzer und Hochschullehrer Johann Heinrich Voss (1751–1826) von 1824:&lt;ref&gt;АРАТОΥ ΦΑΙΝΟΜΕΝΑ ΚΑΙ ΔΙΟΣΗΜΕΙΑ. Des Aratos Sternerscheinungen und Wetterzeichen. Übersetzt und erklärt von Johann Heinrich Voss. Heidelberg bei Christian Friedrich Winter. 1824.&lt;/ref&gt;

&lt;blockquote&gt;
Zeus sei unser Beginn , und niemals bleib' er uns Männern&lt;br/&gt;
Ungelobt. Voll wahrlich des Zeus sind alle des Wandels&lt;br/&gt;
Weg' , und alle Versammlung der Welt ; voll jegliche Meerflut ,&lt;br/&gt;
Jeglicher Port ; ringsum ja des Zeus bedürfen wir alle .&lt;br/&gt;
'''Seines Geschlechts auch sind wir''' ; und Er , mildherzig den Menschen,&lt;br/&gt;
Zeichnet, was frommt, rechtsher ; und zu Tätigkeit weckt er die Völker,&lt;br/&gt;
Mahnend an Lebensbedarf : Er sagt , wann besser dem Pflugstier&lt;br/&gt;
Fuge die Scholl' , und dem Karst ; er sagt , wann schickliche Jahrszeit,&lt;br/&gt;
Dass man die Pflanze behäuf&quot; , und einsenk' allerlei Anwachs .&lt;br/&gt;
Denn selbst hat er die Zeichen am oberen '''Himmel''' befestigt ,&lt;br/&gt;
Und '''Sternbilder''' verteilt ; er hat fürsehend dem Jahrlauf&lt;br/&gt;
'''Sterne''' bestimmt , die den Menschen zumeist annahende Wechsel&lt;br/&gt;
Deuteten jeglicher Zeit , dass in Völligkeit alles erwachse .&lt;br/&gt;
Drum ihn immer zuerst , und zulezt ihn , sühnen sie feiernd.&lt;br/&gt;
Heil , anstaunlicher Vater , den Sterblichen mächtiges Labsal ,&lt;br/&gt;
Du auch , selbst des Geschlechts Ursprung ! Heil , freundliche Musen,&lt;br/&gt;
Heil euch allen gesamt ! doch mir , der , die '''Sterne''' zu melden ,&lt;br/&gt;
Euch , wie geziemt , anfleht , bringt allen Gesang zur Vollendung.&lt;br/&gt;
Jene zugleich , so viele zerstreuete , andere anders ,&lt;br/&gt;
Ziehn mit dem '''Himmel''' einher in ewigem Zuge beständig .&lt;br/&gt;
Doch nie schwanket er selbst um ein weniges; sondern durchaus so&lt;br/&gt;
Bleibt ihm die '''Axe''' geheftet ; die hält gleichschwebend vom Umfang&lt;br/&gt;
Hier '''in der Mitte die Erd'''' , und umher dort dreht sie den '''Himmel''' .&lt;br/&gt;
Sie dann hat zween '''Pol'''' an jeglichem Ende gerichtet :&lt;br/&gt;
Unsichtbar ist jener; doch hier um den '''Boreas''' ragt er&lt;br/&gt;
Ob dem Okeanos hoch. Zwo dem zu den Seiten gestellte&lt;br/&gt;
'''Bärinnen''' rollen umher: drum auch '''Rollwagen''' benamet.
&lt;/blockquote&gt;

'''''Hinweise:'''''
* Die &quot;Axe&quot; beschreibt die Erdachse.
* ''Mit dem &quot;Boreas&quot; ist der Himmelsnordpol gemeint.''
* ''Bei den beiden Bärinnen handelt es sich um die Sternbilder des Großen Bären (Ursa Maior) und des Kleinen Bären (Ursa Minor).''
* ''Die beiden Rollwagen sind bei uns heute die Asterismen Großer Wagen und Kleiner Wagen.''

Der Apostel '''{{w|Paulus von Tarsus}}''' (geboren vor 10, gestorben nach 60) war der bedeutendste Missionar des Urchristentums und kannte diesen Text offensichtlich. Im 17.&amp;nbsp;Kapitel der Apostelgeschichte des Lukas wird ihm ein Zitat aus dem Prolog des Lehrgedichts über die Abstammung der Menschen von Gott in den Mund gelegt.&lt;ref&gt;[https://www.die-bibel.de/bibel/NA28,EUE/ACT.17.28 Apostelgeschichte 17,28], Abschnitt: ''Paulus in Athen'', Novum Testamentum Graece und Einheitsübersetzung&lt;/ref&gt;

&lt;blockquote&gt;
Apostelgeschichte 17,28: '''Τοῦ γὰρ καὶ γένος ἐσμέν.'''
&lt;/blockquote&gt;

&lt;blockquote&gt;
Apostelgeschichte 17,28: '''Wir sind von seinem Geschlecht.'''
&lt;/blockquote&gt;

=== Zahlen in Religionen ===
Die '''Zwei''' steht oft für Gegensätze, wie zum Beispiel Tag und Nacht, Aufgang und Untergang, Sommerhalbjahr und Winterhalbjahr, zunehmender und abnehmender Mond oder obere und untere Kulmination. Eine solche Zweiteilung findet sich oft auch in gegensätzliche Kategorien wieder, die in vielen Disziplinen, insbesondere auch in der Ethik und in Religionen verwendet werden, wie beispielsweise gut und böse, oben und unten, Leben und Tod, Licht und Schatten, Wärme und Kälte oder Himmel und Hölle.

Interessant ist auch die frühgeschichtliche astronomische Auffassung von '''zwei''' mächtigen Gegenspielern, die sich im Sternenhimmel an zwei gegenüberliegenden Seiten befinden, der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|der Himmelsstier]] und der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsskorpion|der Himmelsskorpion]].

→ Siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwei|'''Zur Zwei''']].

Die astronomischen Zahlen '''Sieben''' und '''Zwölf''' werden als heilige Zahlen angesehen. Sie werden in vielfältigen Kontexten in religiösen Texten erwähnt und für viele religiöse Symbole verwendet. Ferner spielt auch die astronomische Zahl '''Vier''' in Religionen eine bedeutende Rolle, wo sie deswegen manchmal ebenfalls als heilige Zahlen angesehen wird:

* '''Vier''' Hauptsterne respektive Hauptsternbilder mit den '''vier''' Himmelsrichtungen und den '''vier''' Jahreszeiten: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Vier_in_Religionen|'''Bedeutung der Vier in Religionen''']].
* '''Sieben''' Wandelgestirne mit den die '''sieben''' Tagen einer Woche beziehungsweise eines Mondviertels: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Sieben_in_Religionen|'''Bedeutung der Sieben in Religionen''']].
* '''Zwölf''' Ekliptiksternbilder, '''zwölf''' Monate pro Jahr, '''zwölf''' Jahre Umlaufzeit des Planeten Jupiter, jeweils '''zwölf''' Stunden Tag und Nacht: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Zwölf_in_Religionen|'''Bedeutung der Zwölf in Religionen''']].

=== Altes Testament ===
In der Bibel wird in der Regel nicht zwischen Fixsternen und Planeten unterschieden. Eine Ausnahme gibt es im 2.&amp;nbsp;Buch der Könige, Kapitel&amp;nbsp;23, Vers&amp;nbsp;5 aus dem siebenten vorchristlichen Jahrhundert, wo in der deutschsprachigen Einheitsübersetzung von &quot;den Wandelsternen&quot; und in der Luther-Bibel von &quot;den Planeten&quot; die Rede ist. Die Vulgata schreibt hier allerdings von den &quot;duodecim signis&quot;, womit sicherlich die zwölf Sternzeichen der Ekliptik gemeint sind, durch die die sieben Wandelgestirne ziehen. Die Septuaginta spricht noch allgemeiner von den &quot;μαζουρωθ&quot; nach dem Hebräischen Wort &quot;מַזָּלָה&quot; (&quot;mazzaroth&quot;), womit vermutlich Sternkonstellationen und im engeren Sinne ebenfalls die zwölf Sternzeichen des Zodiaks gemeint sind:

&lt;blockquote&gt;
'''Septuaginta '''&lt;br/&gt;
5 καὶ κατέπαυσεν τοὺς χωμαριμ, οὓς ἔδωκαν βασιλεῖς Ιουδα καὶ ἐθυμίων ἐν τοῖς ὑψηλοῖς καὶ ἐν ταῖς πόλεσιν Ιουδα καὶ τοῖς περικύκλῳ Ιερουσαλημ, καὶ τοὺς θυμιῶντας τῷ Βααλ καὶ τῷ ἡλίῳ καὶ τῇ σελήνῃ καὶ τοῖς '''μαζουρωθ''' καὶ πάσῃ τῇ δυνάμει τοῦ οὐρανοῦ.&lt;br/&gt;
&lt;br/&gt;
'''Vulgata'''&lt;br/&gt;
5 Et delevit aedituos, quos posuerant reges Iudae ad sacrificandum in excelsis per civitates Iudae et in circuitu Ierusalem, et eos, qui adolebant Baal et soli et lunae et '''duodecim signis''' et omni militiae caeli.&lt;br/&gt;
&lt;br/&gt;
'''Einheitsübersetzung (2016)'''&lt;br/&gt;
5 Auch setzte er die Götzenpriester ab, die von den Königen von Juda bestellt worden waren und die auf den Kulthöhen, in den Städten Judas und in der Umgebung Jerusalems Opfer verbrannt sowie dem Baal, der Sonne, dem Mond, den '''Wandelsternen''' und dem ganzen Heer des Himmels geopfert hatten.&lt;br/&gt;
&lt;br/&gt;
'''Luther-Bibel (2017)'''&lt;br/&gt;
5 Und er setzte die Götzenpriester ab, die die Könige von Juda eingesetzt hatten, um auf den Höhen zu opfern in den Städten Judas und um Jerusalem her; auch die dem Baal geräuchert hatten, der Sonne und dem Mond und den '''Planeten''' und allem Heer am Himmel.&lt;br/&gt;
&lt;/blockquote&gt;

Der Prophet Habakuk erwähnt in seinem Psalm in Kapitel&amp;nbsp;3 aus dem siebenten vorchristlichen Jahrhundert das Konzept der Aufteilung der Ekliptik in Mondstationen respektive in Mondhäuser:

&lt;blockquote&gt;
10 Wenn sie dich sehen, erbeben die Berge,&lt;br/&gt;
das Tosen der Wasser rauscht vorüber; es erhebt die Urflut ihre Stimme,&lt;br/&gt;
hoch oben vergisst die Sonne ihre Strahlen.&lt;br/&gt;
11 '''Der Mond bleibt in der Behausung;'''&lt;br/&gt;
als Beleuchtung schwirren deine Pfeile,&lt;br/&gt;
als heller Schein das Blitzen deiner Lanze.
&lt;/blockquote&gt;

In den folgenden Bibelstellen aus dem Alten Testament spiegeln sich astronomische Vorstellungen in Bezug auf Gott wider:

'''Genesis 1:'''
&lt;blockquote&gt;
1 Im Anfang erschuf Gott '''Himmel''' und Erde.&lt;br/&gt;
2 Die '''Erde''' war wüst und wirr und '''Finsternis''' lag über der '''Urflut''' und Gottes Geist schwebte über dem '''Wasser'''.&lt;br/&gt;
3 Gott sprach: Es werde '''Licht'''. Und es wurde '''Licht'''.
...&lt;br/&gt;
5 Und Gott nannte das Licht '''Tag''' und die Finsternis nannte er '''Nacht'''. Es wurde '''Abend''' und es wurde '''Morgen''': erster Tag.&lt;br/&gt;
...&lt;br/&gt;
14 Dann sprach Gott: Lichter sollen am '''Himmelsgewölbe''' sein, um '''Tag''' und '''Nacht''' zu scheiden. Sie sollen als Zeichen für '''Festzeiten''', für '''Tage''' und '''Jahre''' dienen.&lt;br/&gt;
15 Sie sollen Lichter am Himmelsgewölbe sein, um über die Erde hin zu leuchten. Und so geschah es.&lt;br/&gt;
16 Gott machte '''die beiden großen Lichter''', das große zur Herrschaft über den '''Tag''', das kleine zur Herrschaft über die '''Nacht''', und die '''Sterne'''.
&lt;/blockquote&gt;

'''Psalm 8:'''
&lt;blockquote&gt;
4 Seh ich deine '''Himmel''', die Werke deiner Finger, '''Mond '''und '''Sterne''', die du befestigt.
&lt;/blockquote&gt;

[[Datei:Johannes.Kepler.Coeli.enarrant.gloriam.Dei.png|mini|rechts|Portrait des jungen Johannes Keplers mit dem Motto &quot;Coeli enarrant gloriam Dei.&quot; nach Psalm 19: &quot;Die Himmel erzählen die Herrlichkeit Gottes.&quot;]]

'''Psalm 19:'''
&lt;blockquote&gt;
2 Die '''Himmel''' erzählen die Herrlichkeit Gottes und das '''Firmament''' kündet das Werk seiner Hände.
&lt;/blockquote&gt;

'''Psalm 90:'''
&lt;blockquote&gt;
2 Ehe geboren wurden die Berge, ehe du unter Wehen hervorbrachtest '''Erde''' und '''Erdkreis''', bist du Gott von Ewigkeit zu Ewigkeit.
&lt;/blockquote&gt;

'''Psalm 102:'''
&lt;blockquote&gt;
26 Vorzeiten hast du der Erde Grund gelegt, die '''Himmel''' sind das Werk deiner Hände.
&lt;/blockquote&gt;

'''Psalm 103:'''
&lt;blockquote&gt;
19 Der HERR hat seinen Thron errichtet im '''Himmel''', seine königliche Macht beherrscht '''das All'''.
&lt;/blockquote&gt;

'''Psalm 104:'''
&lt;blockquote&gt;
19 Du machst den '''Mond''' zum Maß für die Zeiten, die '''Sonne''' weiß, wann sie untergeht.
&lt;/blockquote&gt;

'''Psalm 113:'''
&lt;blockquote&gt;
3 Vom '''Aufgang der Sonne''' bis zu ihrem '''Untergang''' sei gelobt der Name des HERRN.&lt;br/&gt;
4 Erhaben ist der HERR über alle Völker, über den '''Himmeln''' ist seine Herrlichkeit.
&lt;/blockquote&gt;

'''Psalm 136:'''
&lt;blockquote&gt;
3 Dankt dem Herrn der Herren, denn seine Huld währt ewig!&lt;br/&gt;
4 Ihm, der allein große Wunder tut, denn seine Huld währt ewig,&lt;br/&gt;
5 der den '''Himmel''' gemacht hat in Weisheit, denn seine Huld währt ewig,&lt;br/&gt;
6 der die Erde gefestigt hat über den Wassern, denn seine Huld währt ewig,&lt;br/&gt;
7 der '''die großen Leuchten''' gemacht hat, denn seine Huld währt ewig,&lt;br/&gt;
8 die '''Sonne''' zur Herrschaft über den '''Tag''', denn seine Huld währt ewig,&lt;br/&gt;
9 den '''Mond''' und die '''Sterne''' zur Herrschaft über die '''Nacht''', denn seine Huld währt ewig.
&lt;/blockquote&gt;

'''Psalm 147:'''
&lt;blockquote&gt;
4 Er bestimmt die Zahl der '''Sterne''' und ruft sie alle mit Namen.
&lt;/blockquote&gt;

'''Psalm 148:'''
&lt;blockquote&gt;
'''Lobpreis auf den Herrn, den König des Kosmos'''&lt;br/&gt;
1 Halleluja! Lobt den HERRN vom '''Himmel''' her, lobt ihn in den Höhen:&lt;br/&gt;
2 Lobt ihn, all seine Engel, lobt ihn, all seine Heerscharen,&lt;br/&gt;
3 lobt ihn, '''Sonne''' und '''Mond''', lobt ihn, all ihr leuchtenden '''Sterne''',&lt;br/&gt;
4 lobt ihn, ihr '''Himmel der Himmel''', ihr Wasser über dem '''Himmel'''!
&lt;/blockquote&gt;

Mit den &quot;Wassern über dem Himmel&quot; können nicht die Wolken unterhalb der Sternensphäre gemeint sein. Vielmehr dürfte es sich um eine Anspielung auf den Urozean beziehungsweise die Urflut handeln (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Urozean''']]). Diese Urflut existierte bereits vor der Erschaffung des Lichts und der Gestirne. Man erinnere sich an den Beginn der Schöpfungsgeschichte in den ersten drei Versen der Bibel (siehe oben).

'''Buch der Weisheit (Weisheit Salomos):'''
&lt;blockquote&gt;
'''Salomos Gebet um Weisheit'''&lt;br/&gt;
9,1 Gott der Väter und Herr des Erbarmens, du hast '''das All''' durch dein Wort gemacht.
&lt;/blockquote&gt;

'''Jesus Sirach 42:'''
&lt;blockquote&gt;
'''Lob Gottes in der Schöpfung'''&lt;br/&gt;
15 Nun will ich der Werke des Herrn gedenken, und was ich gesehen habe, werde ich erzählen: Durch die Worte des Herrn sind seine Werke und durch seinen Segen gab er ihnen ihre Bestimmung.&lt;br/&gt;
16 Die leuchtende '''Sonne''' blickt auf alles hernieder und von der Herrlichkeit des Herrn ist sein Werk erfüllt.&lt;br/&gt;
17 Der Herr gab es selbst den Heiligen nicht, all seine Wunder zu erzählen, der Herr der Herrscher über '''das All''', hat sie gegründet, sodass '''das All''' in seiner Herrlichkeit Bestand hat.&lt;br/&gt;
18 Abgrund und Herz hat er durchforscht und ihre Absichten hat er durchschaut; denn der Höchste kennt alles Wissen und er blickt auf die '''Zeichen der Zeiten'''.&lt;br/&gt;
19 Er tut das Vergangene und das Kommende kund und enthüllt die Spuren des Verborgenen.&lt;br/&gt;
20 Kein Gedanke entgeht ihm und kein einziges Wort bleibt ihm verborgen.&lt;br/&gt;
21 Die Großtaten seiner Weisheit hat er geordnet; wie er ist '''von Ewigkeit und in Ewigkeit'''. Ihm ist weder etwas hinzugefügt noch weggenommen worden und er hat keines Ratgebers bedurft.
&lt;/blockquote&gt;

Auch im nachfolgenden Kapitel lobt Jesus Sirach die Sonne, den Mond und die Sterne in den höchsten Tönen:

'''Jesus Sirach 43:'''
&lt;blockquote&gt;
1 Der Stolz der Höhe ist ein '''Firmament''' von Reinheit, die Gestalt des '''Himmels''' beim Anblick der Herrlichkeit.&lt;br/&gt;
2 Die '''Sonne''' verkündet durch ihr Erscheinen beim Aufgang, ein wunderbares Geschöpf, ein Werk des Höchsten!&lt;br/&gt;
3 Zur '''Mittagszeit''' trocknet sie den Boden aus, wer wird bestehen vor ihrer Glut?&lt;br/&gt;
4 Wer in einen Ofen bläst bei Arbeiten mit Glut - dreimal so stark versengt die '''Sonne''' Berge; sie atmet Feuerdämpfe aus und blendet mit gleißenden Strahlen die Augen.&lt;br/&gt;
5 Groß ist der Herr, der sie gemacht hat, mit seinen Worten beschleunigt er ihren Lauf.&lt;br/&gt;
6 Auch der '''Mond''' hält sich in allem an seinen Zeitpunkt, zur '''Festsetzung der Zeiten''' und als Zeichen auf Dauer.&lt;br/&gt;
7 Vom '''Mond''' geht das Zeichen für einen Festtag aus, ein Gestirn, das abnimmt bis zur Vollendung.&lt;br/&gt;
8 Der Name '''Monat''' kommt vom '''Neumond''', der wunderbar zunimmt beim Wechsel, ein Geschöpf des Heeres in der Höhe, das am '''Himmelsgewölbe''' leuchtet.&lt;br/&gt;
9 Die Schönheit des '''Himmels''' ist der Glanz der '''Sterne''', ein strahlender Schmuck in den Höhen des Herrn.&lt;br/&gt;
10 Durch die Worte des Heiligen stehen sie gemäß ihrer Bestimmung und sie ermüden nie bei ihrer Wache.&lt;br/&gt;
...&lt;br/&gt;
27 Vieles werden wir sagen, aber wir kommen nie an ein Ziel und das Ende der Worte ist: Er ist '''das All'''.
&lt;/blockquote&gt;

'''Jesaja 40:'''
&lt;blockquote&gt;
26 Hebt eure Augen in die Höhe und seht: Wer hat diese '''Gestirne''' erschaffen?&lt;br/&gt;
Der vollzählig herausführt ihr Heer, er ruft sie alle beim Namen.&lt;br/&gt;
Wegen seiner Fülle an Kraft und mächtiger Stärke fehlt kein einziges.
&lt;/blockquote&gt;

Das Buch Baruch gehört zu den späten Schriften des Alten Testaments. Im dritten Kapitel werden das Licht und die Sterne in Bezug auf Gott thematisiert:

'''Baruch 3:'''
&lt;blockquote&gt;
33 Er entsendet das '''Licht''' und es eilt dahin; er ruft es zurück und zitternd gehorcht es ihm.&lt;br/&gt;
34 Froh leuchten die '''Sterne''' auf ihren Posten.&lt;br/&gt;
35 Ruft er sie, so antworten sie: Hier sind wir. Sie leuchten mit Freude für ihren Schöpfer.&lt;br/&gt;
36 Das ist unser Gott; kein anderer gilt neben ihm.
&lt;/blockquote&gt;

Ein Lobpreis auf die Werke, Engel und Mächte Gottes am Gewölbe des Himmels findet sich im '''Buch Daniel''' im dritten Kapitel. Der Text macht inhaltlich eine ähnliche Aussage wie der Lobpreis auf den Herrn, den König des Kosmos in Psalm 148 (siehe oben):

'''Daniel 3:'''
&lt;blockquote&gt;
56 Gepriesen bist du am Gewölbe des '''Himmels''', gerühmt und verherrlicht in Ewigkeit.&lt;br/&gt;
57 Preist den HERRN, all ihr Werke des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
58 Preist den HERRN, ihr '''Himmel'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
59 Preist den HERRN, ihr Engel des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
60 Preist den HERRN, all ihr '''Wasser über dem Himmel'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
61 Preist den HERRN, all ihr Mächte des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
62 Preist den HERRN, '''Sonne und Mond'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
63 Preist den HERRN, ihr '''Sterne am Himmel'''; lobt und rühmt ihn in Ewigkeit!
&lt;/blockquote&gt;

=== Der Himmelsthron ===
Der '''Himmelsthron''' wir in vielen Texten des Alten Testaments als der Sitz Gottes genannt. Hier zunächst einige Erwähnungen in den Psalmen:

&lt;blockquote&gt;
11,4 Der HERR ist in seinem heiligen Tempel, der HERR hat seinen '''Thron im Himmel'''.&lt;br/&gt;
Seine Augen schauen herab, seine Blicke prüfen die Menschen.
&lt;/blockquote&gt;

&lt;blockquote&gt;
33,13 Der HERR blickt herab vom '''Himmel''', er sieht alle Menschen.&lt;br/&gt;
33,14 Von seinem '''Thronsitz''' schaut er nieder auf alle Bewohner der Erde.
&lt;/blockquote&gt;

&lt;blockquote&gt;
89,37 Sein Haus soll bleiben auf ewig, sein '''Thron''' habe Bestand vor mir wie die '''Sonne''';
&lt;/blockquote&gt;

&lt;blockquote&gt;
103,19 Der HERR hat seinen '''Thron''' errichtet im '''Himmel''', seine königliche Macht beherrscht '''das All'''.
&lt;/blockquote&gt;

Im Buch der Weisheit stehen die folgenden beiden Verse:

&lt;blockquote&gt;
9,9 Mit dir ist die Weisheit, die deine Werke kennt und die zugegen war, als du die Welt erschufst. Sie weiß, was wohlgefällig ist in deinen Augen und was recht ist nach deinen Geboten.&lt;br/&gt;
9,10 Sende sie vom heiligen '''Himmel''' und schick sie vom '''Thron''' deiner Herrlichkeit, damit sie bei mir sei und alle Mühe mit mir teile und ich erkenne, was wohlgefällig ist bei dir!
&lt;/blockquote&gt;

Diese Bild von Gottes Thron im Himmel wir auch im Neuen Testament aufgegriffen, wie beispielsweise beim Evangelisten Matthäus (Kapitel 5, Vers 34) oder in der Offenbarung des Johannes, wo im vierten Kapitel die eröffnende Himmelsvision mit dem Abschnitt über &quot;Die Huldigung vor dem Thron Gottes&quot; beginnt:

&lt;blockquote&gt;
1 Danach sah ich und siehe, eine Tür war geöffnet am '''Himmel'''; und die erste Stimme, die ich gleich einer Posaune mit mir reden gehört hatte, sagte: Komm herauf und ich werde dir zeigen, was dann geschehen muss.&lt;br/&gt;
2 Sogleich wurde ich vom Geist ergriffen. Und siehe, '''ein Thron stand im Himmel'''; auf dem Thron saß einer,&lt;br/&gt;
3 der wie ein Jaspis und ein Karneol aussah. Und über dem '''Thron''' wölbte sich ein Regenbogen, der wie ein Smaragd aussah.&lt;br/&gt;
4 Und rings um den '''Thron standen vierundzwanzig Throne''' und auf den Thronen saßen vierundzwanzig Älteste, in weiße Gewänder gekleidet und mit goldenen Kränzen auf dem Haupt.&lt;br/&gt;
5 Von dem Thron gingen Blitze, Stimmen und Donner aus. Und '''sieben lodernde Fackeln brannten vor dem Thron; das sind die sieben Geister Gottes'''.&lt;br/&gt;
6 Und vor dem Thron war etwas wie ein gläsernes Meer, gleich Kristall. Und in der Mitte des Thrones und rings um den Thron waren '''vier Lebewesen''' voller Augen, vorn und hinten.&lt;br/&gt;
7 Das erste Lebewesen glich einem '''Löwen''', das zweite einem '''Stier''', das dritte sah aus wie ein '''Mensch''', das vierte glich einem '''fliegenden Adler'''.&lt;br/&gt;
&lt;/blockquote&gt;

Der achtstrophige Adventshymnus ''Veni redemptor gentium'' (die deutschsprachige Kontrafaktur heißt &quot;Nun komm, der Heiden Heiland&quot;) wird dem Kirchenvater Ambrosius von Mailand (339–397) zugeschrieben. In der fünften Strophe wird mit Bezug auf die Himmelfahrt des Messias der Sitz Gottes erwähnt:

&lt;blockquote&gt;
5,1 Egressus eius a Patre,&lt;br/&gt;
5,2 Regressus eius ad Patrem;&lt;br/&gt;
5,3 Excursus usque ad inferos,&lt;br/&gt;
5,4 Recursus ad '''sedem Dei'''.
&lt;/blockquote&gt;

&lt;blockquote&gt;
5,1 Sein Ausgang ist vom Vater,&lt;br/&gt;
5,2 Seine Rückkehr ist beim Vater;&lt;br/&gt;
5,3 Hinausgelaufen bis zu den Toten,&lt;br/&gt;
5,4 Zurückgelaufen bis zum '''Sitz Gottes'''.
&lt;/blockquote&gt;

Es ist nicht viel Phantasie erforderlich, um den Thron Gottes im '''Himmelsstier''' wiederzuerkennen. Die vierundzwanzig Throne, die sich entlang der '''Ekliptik''' um diesen Thron herum aufreihen, stehen für die vierundzwanzig Stunden eines Tages, und sie sind je zwei für jedes der zwölf Lebewesenkreiszeichen des '''Zodiaks'''. Die als sieben lodernde Fackeln vor dem Thron sind die sieben '''Wandelgestirne''', die als die '''sieben Geister Gottes''' immer wieder durch das '''Goldene Tor der Ekliptik''' in der Sitzfläche des Thrones ziehen. Die '''vier besonderen Lebewesen''' sind die vier Evangelistensymbole bei den vier zoroastrischen '''Königssternen'''.

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|'''Himmelsstier''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Die_Ekliptik|'''Ekliptik''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|'''Zodiak''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|'''Goldenes Tor der Ekliptik''']].

→ Siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Vier_in_Religionen|'''Bedeutung der Vier in Religionen''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Königssterne|'''Königssterne''']].

&lt;gallery caption=&quot;Throne&quot; widths=640 heights=480 perrow=2&gt;
Aachen_Cathedral_Karlsthron_02.jpg|Thron Karls des Großen aus den 790er Jahren im Aachener Dom.
Himmelsthron.Taurus.Aries.png|Himmelsthron in den Sternbildern Stier (Taurus) und Widder (Aries) vor dem Untergang in Richtung Westen.
&lt;/gallery&gt;

=== Das Lamm ===
Im ersten Kapitel des Evangeliums nach Johannes wird Jesus von Nazareth explizit als &quot;Lamm Gottes&quot; bezeichnet:&lt;ref&gt;[https://www.bibleserver.com/EU/Johannes1%2C29 Johannes 1,29], bibleserver.com, Einheitsübersetzung (2016)&lt;/ref&gt;

&lt;blockquote&gt;
29b Seht, das '''Lamm Gottes''', das die Sünde der Welt hinwegnimmt!&lt;br/&gt;
...&lt;br/&gt;
36b Seht, das '''Lamm Gottes'''!
&lt;/blockquote&gt;

Es handelt sich beim „Lamm Gottes“ (Kirchenlatein: „Agnus Dei“) um ein seit ältester Zeit verbreitetes Symbol für Jesus Christus. Es wird auch als das Osterlamm bezeichnet, das am Ostertag, also kurz nach der Tag-und-Nacht-Gleiche im Frühjahr auferstanden ist. Nach dem Evangelisten Markus wurde die Auferstehung „... am ersten Tag der Woche, früh am Morgen, als eben die Sonne aufging“, also am Ostersonntag während der Morgenröte im Osten entdeckt.&lt;ref&gt;[https://www.bibleserver.com/LUT/Markus16%2C2 Markus 16,2], Einheitsübersetzung, 2016&lt;/ref&gt; Am 40.&amp;nbsp;Tag ist Jesus Christus nach dem Zeugnis der Evangelisten Markus und Lukas in den Himmel aufgefahren. Zu Beginn der Apostelgeschichte wird dieses Ereignis folgendermaßen beschrieben:&lt;ref&gt;[https://www.bibleserver.com/EU/Apostelgeschichte1 Apostelgeschichte 1], Einheitsübersetzung, 2016&lt;/ref&gt;

&lt;blockquote&gt;
7 Er sagte zu ihnen: Euch steht es nicht zu, Zeiten und Fristen zu erfahren, die der Vater in seiner Macht festgesetzt hat.&lt;br/&gt;
8 Aber ihr werdet Kraft empfangen, wenn der Heilige Geist auf euch herabkommen wird; und ihr werdet meine Zeugen sein in Jerusalem und in ganz Judäa und Samarien und bis an die Grenzen der Erde.&lt;br/&gt;
9 Als er das gesagt hatte, wurde er vor ihren Augen emporgehoben und eine Wolke nahm ihn auf und entzog ihn ihren Blicken.&lt;br/&gt;
&lt;/blockquote&gt;

Im altrömischen Glaubensbekenntnis gibt es die Textstelle:

&lt;blockquote&gt;
„ascendit in caelis, sedet ad dexteram Patris“
&lt;/blockquote&gt;

Zu Deutsch:

&lt;blockquote&gt;
„aufgefahren in den Himmel, er sitzt zur Rechten des Vaters“
&lt;/blockquote&gt;

Das '''Lamm''' (astronomisch Widder) befindet sich am nördlichen Sternenhimmel '''zur Rechten''' des Stieres (Taurus). Sowohl der mesopotamische Himmelsstier als auch das altarabische Sternbild Thuraya verbinden diese beiden neuzeitlichen Sternbilder zu einer Einheit. Der Hauptstern im Sternbild Widder (Aries) heißt Hamal, und das arabische Wort &quot;hamal&quot; steht für ein einjähriges Lamm.&lt;ref name=&quot;Adams&quot;&gt;Danielle Adams: [http://onesky.arizona.edu/arab-star-names/the-lamb/ The Lamb – A folkloric celestial complex], Two Deserts, one Sky – Arab Star Calendars&lt;/ref&gt; Der fette Schwanz des Lammes wird durch die '''Plejaden (Siebengestirn)''' markiert.&lt;ref name=&quot;Adams&quot; /&gt; Die Augen des Stieres sind die Sterne '''Aldebaran''' und '''Ain'''. Zwischen dem Kopf des Stieres und den '''Plejaden''' befindet sich das '''Goldene Tor der Ekliptik''', durch das alle Wandelgestirne regelmäßig hindurchziehen.

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Bibelstellen|'''Bibelstellen zum Siebengestirn''']].

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|'''Goldenes Tor der Ekliptik''']].

Der Frühlingspunkt der Sonne, also deren Ort auf der Ekliptiklinie zur Tag-und-Nacht-Gleiche im Frühjahr, ist von der monotheistischen Schöpfung bis zur Geburt des christlichen Gottessohns vom Kopf des Stiers (bei den Sternen '''Aldebaran''' und '''Ain''' im Goldenen Tor der Ekliptik) im heutigen Sternbild Stier (Taurus) bis zum Kopf des Lammes (beim Stern '''Hamal''') im heutigen Sternbild Widder (Aries) nach Westen gewandert. Heute befindet sich der Frühlingspunkt bereits am westlichen Ende des Sternbilds Fische (Pisces), das sich westlich an das Sternbild Widder anschließt.

==== Offenbarung des Johannes ====
In der Offenbarung des Johannes heißt es im 7.&amp;nbsp;Kapitel:

&lt;blockquote&gt;
10b Die Rettung kommt von unserem '''Gott''', der auf dem '''Thron''' sitzt, und von dem '''Lamm'''.&lt;br/&gt;
17a Denn das Lamm in der Mitte vor dem Thron wird sie weiden und zu den Quellen führen, aus denen das '''Wasser des Lebens''' strömt.
&lt;/blockquote&gt;

Wird der '''Thron Gottes''' mit dem Himmelsstier identifiziert (siehe oben), dann sitzt das '''Lamm''' (Aries, Sternbild Widder) westlich und somit rechts vor diesem Thron. Im weiteren Verlauf der Ekliptik nach Westen befinden sich die zusammenhängenden '''Wassersternbilder''' des Urozeans, dem Urquell des Lebens. Es handelt ich um die heutigen Sternbilder Fluss Eridanus, Walfisch (Cetus), Fische (Pisces), Wassermann (Aquarius), Südlicher Fisch (Piscis Austrinus) und Delphin (Delphinus) sowie Steinbock (Capricornus, früher Ziegenfisch).

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Urozean''']].

&lt;gallery caption=&quot;Das Lamm zur Rechten des Stieres&quot; mode=packed widths=800 heights=600&gt;
Himmelsstier.P1117152.jpg|Astrophotographie vom Asterismus Himmelsstier
Himmelsstier.Sternbilder.P1117152.png|Beschriftete Astrophotographie vom Himmelsstier am winterlichen Abendhimmel in Richtung südlicher Meridian. Die Ekliptiklinie verläuft horizontal etwas unterhalb der Bildmitte.
Haende.der.Thuraya.Vollmond.Sterne.P1079912.jpg|Astrophotographie der Himmelsregion mit dem beduinischen Sternbild &quot;Hände der Thuraya&quot; (grüne durchgezogene Linien, Ekliptik rot gepunktete Linie) mit arabisch bezeichneten Sternen. Der Vollmond befindet sich zwischen den Sternbildern Taurus, Aries und Cetus.
Urozean.Wassersternbilder.png|Die zusammenhängenden Wassersternbilder des Urozeans am Sternenhimmel: Fluss Eridanus, Walfisch (Cetus), Fische (Pisces), Wassermann (Aquarius), Südlicher Fisch (Piscis Austrinus), Delphin (Delphinus) sowie Ziegenfisch (Steinbock, Capricornus).
&lt;/gallery&gt;

Interpretiert man das Sternbild &quot;Lamm&quot; (Widder / Aries) als Mittler auf dem ekliptischen Weg vom finsteren kosmischen Urozean im Westen (rechts) zum strahlenden majestätischen Sternbild Stier (Taurus) im Osten (links), ergeben auch andere Bibelstellen in Bezug auf den Sternenhimmel einen tiefen symbolischen Sinn, die in den folgenden Abschnitten aufgeführt sind.

==== Evangelium nach Johannes ====
Die Rede von Jesus an den Jünger Thomas aus dem 14.&amp;nbsp;Kapitel des Evangeliums nach Johannes ist in diesem Zusammenhang interessant:

&lt;blockquote&gt;
6 Jesus sagte zu ihm: Ich bin der Weg und die Wahrheit und das Leben; niemand kommt zum Vater außer durch mich.&lt;br/&gt;
7 Wenn ihr mich erkannt habt, werdet ihr auch meinen Vater erkennen. Schon jetzt kennt ihr ihn und habt ihn gesehen.
&lt;/blockquote&gt;

Alle Wandelgestirne bewegen sich entlang der Ekliptiklinie (Weg) durch das heutige Sternbild Widder (das altarabische Sternbild &quot;Lamm&quot;) im Westen zum [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der-Ekliptik|Goldenen Tor der Ekliptik]] nach Osten im großen Himmelsstier (Vater / Thron).

==== Evangelium nach Markus ====
Im Evangelium nach Markus heißt es:

&lt;blockquote&gt;
14,62 Jesus sagte: Ich bin es. Und ihr werdet den Menschensohn '''zur Rechten der Macht''' sitzen und mit den Wolken des '''Himmels''' kommen sehen.
&lt;/blockquote&gt;

&lt;blockquote&gt;
16,19 Nachdem Jesus, der Herr, dies zu ihnen gesagt hatte, wurde er in den '''Himmel''' aufgenommen und setzte sich '''zur Rechten Gottes'''.
&lt;/blockquote&gt;

==== Evangelium nach Lukas ====
Im Evangelium nach Lukas ist es folgendermaßen formuliert:

&lt;blockquote&gt;
22,69 Von nun an wird der Menschensohn '''zur Rechten der Macht Gottes''' sitzen.
&lt;/blockquote&gt;

==== Evangelium nach Matthäus ====
Auch im Evangelium nach Matthäus findet sich eine entsprechende Stelle:

&lt;blockquote&gt;
26,64 Jesus antwortete: Du hast es gesagt. Doch ich erkläre euch: Von nun an werdet ihr den Menschensohn '''zur Rechten der Macht''' sitzen und auf den Wolken des '''Himmels''' kommen sehen.
&lt;/blockquote&gt;

==== Brief an die Hebräer ====
Im Brief an die Hebräer, dessen Autor unbekannt ist, gibt es etliche entsprechende Stellen:

&lt;blockquote&gt;
'''Gottes Rede in seinem Sohn'''&lt;br/&gt;
1,3 er ist der Abglanz seiner Herrlichkeit und das Abbild seines Wesens; er trägt '''das All''' durch sein machtvolles Wort, hat die Reinigung von den Sünden bewirkt und sich dann '''zur Rechten der Majestät in der Höhe''' gesetzt;&lt;br/&gt;
1,10 Und: Du, Herr, hast vorzeiten der Erde Grund gelegt, die '''Himmel''' sind das Werk deiner Hände.&lt;br/&gt;
1,11 Sie werden vergehen, '''du aber bleibst'''; sie alle veralten wie ein Gewand;&lt;br/&gt;
1,12 du rollst sie zusammen wie einen Mantel und wie ein Gewand werden sie gewechselt. Du aber bleibst, der du bist, und '''deine Jahre enden nie'''.&lt;br/&gt;
1,13 Zu welchem Engel hat er jemals gesagt: Setze dich mir '''zur Rechten''' und ich lege dir deine Feinde als Schemel unter die Füße?
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Die Liturgie des neuen Bundes'''&lt;br/&gt;
8,1 Die Hauptsache bei dem Gesagten aber ist: Wir haben einen solchen Hohepriester, der sich '''zur Rechten des Thrones der Majestät im Himmel''' gesetzt hat,&lt;br/&gt;
8,2 als Diener des Heiligtums und des '''wahren Zeltes''', das der Herr selbst aufgeschlagen hat, nicht ein Mensch.
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Christus als Mittler des neuen Bundes'''&lt;br/&gt;
9,24 Denn Christus ist nicht in ein von Menschenhand gemachtes Heiligtum hineingegangen, in ein Abbild des wirklichen, sondern '''in den Himmel selbst''', um jetzt '''vor Gottes Angesicht''' zu erscheinen für uns;
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Das Opfer Jesu Christi als endgültige Versöhnung mit Gott'''&lt;br/&gt;
10,12 Dieser aber hat nur ein einziges Opfer für die Sünden dargebracht und sich dann '''für immer zur Rechten Gottes''' gesetzt;
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Das Beispiel Jesu Christi'''&lt;br/&gt;
12,2 und dabei auf Jesus blicken, den Urheber und Vollender des Glaubens; er hat angesichts der vor ihm liegenden Freude das Kreuz auf sich genommen, ohne auf die Schande zu achten, und sich '''zur Rechten von Gottes Thron''' gesetzt.
&lt;/blockquote&gt;

==== Erster Brief des Petrus ====
Der erste Brief des Petrus zählt zu den katholischen Briefen des Neuen Testaments. Dort heißt es im letzten Satz über Jesus Christus:

&lt;blockquote&gt;
22 der in den '''Himmel''' gegangen ist; dort ist er '''zur Rechten''' Gottes und Engel, Gewalten und Mächte sind ihm unterworfen.
&lt;/blockquote&gt;

==== Apostelgeschichte ====
Die Apostelgeschichte schließt an das Evangelium nach Lukas an und wird ebenfalls diesem zugeschrieben. Hier kommen der erste bekennende sowie erste berufene Apostel Petrus und der erste christliche Märtyrer Stephanus zu Wort:

&lt;blockquote&gt;
'''Die Pfingstpredigt des Petrus'''&lt;br/&gt;
2,33 '''Zur Rechten Gottes''' erhöht, hat er vom Vater den verheißenen Heiligen Geist empfangen und ihn ausgegossen, wie ihr seht und hört.
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Steinigung des Stephanus'''&lt;br/&gt;
7,55 Er aber, erfüllt vom Heiligen Geist, blickte zum '''Himmel''' empor, sah die Herrlichkeit Gottes und Jesus '''zur Rechten Gottes''' stehen&lt;br/&gt;
7,56 und rief: Siehe, ich sehe den Himmel offen und den Menschensohn '''zur Rechten Gottes''' stehen.
&lt;/blockquote&gt;

=== Himmelspforte ===
Das Sternbild Widder (Aries) repräsentiert als das Lamm Gottes den nördlichen Pfeiler des Goldenen Tors der Ekliptik. Der fette Schwanz des Lammes wird nach altarabischer Tradition durch das Siebengestirn (Plejaden) gebildet, das heute zu Sternbild Stier (Taurus) gezählt wird. Der südliche Pfeiler des Goldenen Tors der Ekliptik wird durch die Hyaden und den Stern Menkar im Sternbild Walfisch (Cetus) gebildet. Das Goldene Tor der Ekliptik stellt mit diesen beiden Pfeilern somit eine '''Himmelspforte''' dar, durch die alle Wandelgestirne regelmäßig von Westen aus dem dunklen Urozean der winterlichen Wassersternbilder sowie der Richtung des Sonnenuntergangs nach Osten in das helle Gebiet des Sternenhimmels mit den Frühlings- und Sommersternbildern sowie die Richtung des Sonnenaufgangs treten.

[[Datei:Mars.im.Goldenen.Tor.der.Ekliptik.P1091607.jpg|mini|hochkant=3|zentriert|Der am nordwestlichen Horizont in der Nähe der Ekliptiklinie und im Goldenen Tor der Ekliptik untergehende Mars (rote Scheibe unten halb rechts) drei Tage vor dem Durchqueren der '''Himmelspforte''' zwischen dem Kopf des Himmelsstieres mit dem Sternhaufen der Hyaden (unten links) und den Plejaden nördlich der Ekliptik (rechts unten).]]

Die Genesis berichtet im 28.&amp;nbsp;Kapitel unter der Überschrift &quot;Jakob in Bet-El&quot; (hebräisch בֵּית אֵל „Haus des El“ oder „Haus Gottes“) über einen Traum von Jakob, in dem er eine Treppe zum Himmel (die Himmelsleiter oder Jakobsleiter) sieht, an dessen oberen Ende sich das Tor des Himmels (die Himmelspforte) befindet:

&lt;blockquote&gt;
10 Jakob zog aus Beerscheba weg und ging nach Haran.&lt;br/&gt;
11 Er kam an einen bestimmten Ort und übernachtete dort, denn die Sonne war untergegangen. Er nahm einen von den Steinen dieses Ortes, legte ihn unter seinen Kopf und schlief dort ein.&lt;br/&gt;
12 Da hatte er einen Traum: Siehe, eine Treppe stand auf der Erde, ihre Spitze reichte bis zum '''Himmel'''. Und siehe: Auf ihr stiegen Engel Gottes auf und nieder.&lt;br/&gt;
13 Und siehe, der HERR stand vor ihm und sprach: Ich bin der HERR, der Gott deines Vaters Abraham und der Gott Isaaks. Das Land, auf dem du liegst, will ich dir und deinen Nachkommen geben.&lt;br/&gt;
14 Deine Nachkommen werden zahlreich sein wie der Staub auf der Erde. Du wirst dich '''nach Westen und Osten, nach Norden und Süden''' ausbreiten und durch dich und deine Nachkommen werden alle Sippen der Erde Segen erlangen.&lt;br/&gt;
15 Siehe, ich bin mit dir, ich behüte dich, wohin du auch gehst, und bringe dich zurück in dieses Land. Denn ich verlasse dich nicht, bis ich vollbringe, was ich dir versprochen habe.&lt;br/&gt;
16 Jakob erwachte aus seinem Schlaf und sagte: Wirklich, der HERR ist an diesem Ort und ich wusste es nicht.&lt;br/&gt;
17 Er fürchtete sich und sagte: Wie Ehrfurcht gebietend ist doch dieser Ort! Er ist nichts anderes als das Haus Gottes und das '''Tor des Himmels'''.&lt;br/&gt;
&lt;/blockquote&gt;

El war für die semitischen Ugariter im zweiten vorchristlichen Jahrtausend der Name ihres höchsten Gottes. Jakob war der der erste der drei Erzväter des Volkes Israel und der älteste Sohn des ältesten Sohnes Isaak von Abraham. Abraham war aus dem mesopotamischen Ur über Haran nach Bet-El gezogen, und Jakob ging in dieser Schilderung aus Beerscheba in der Nähe des Ortes Bet-El nach Haran zurück.

Der Apostel Paulus schreibt in seinem zweiten Brief an die Bewohner der griechischen Hafenstadt Korinth zu Beginn des 5.&amp;nbsp;Kapitels mit der Überschrift &quot;Die Hoffnung des Apostels&quot; über das Gebäude hinter der Pforte zum Himmel:

&lt;blockquote&gt;
1 Wir wissen: Wenn unser irdisches Zelt abgebrochen wird, dann haben wir eine Wohnung von Gott, ein nicht von Menschenhand errichtetes '''ewiges Haus im Himmel'''.
&lt;/blockquote&gt;

=== Gedanken zur wundersamen Brotvermehrung ===
==== Evangelien ====
[[Datei:Face de chapiteau figurant la Multiplication des pains, choeur de l'église de Saint-Nectaire, Puy-de-Dôme.jpg|mini|rechts|hochkant=2|Jesus mit vier seiner Jünger mit fünf Broten und zwei Fischen an einem Säulenkapitell in der romanischen Wallfahrtskirche Saint Nectaire auf dem Mont Cornadore in Saint-Nectaire in Frankreich (Département Puy-de-Dôme in der Region Auvergne-Rhône-Alpes).]]

Die wundersame Speisung der mehreren Tausend mit wenigen Broten und Fischen wird in aller vier Evangelien der Bibel erwähnt. Das Ereignis fand auf einem Berg am Ufer des Sees von Galiläa (auch als &quot;See von Tiberias&quot;, &quot;See Genezareth&quot; oder &quot;Galiläisches Meer&quot; bekannt) statt. In der abgelegenen Gegend gab es damals sehr wenig künstliche Lichtquellen, so dass ein ungestörter Anblick des Sternenhimmels möglich war.

===== Evangelium nach Johannes =====
Im sechsten Kapitel des Evangeliums nach '''Johannes''' tauchen bei der Beschreibung der Brotvermehrung durch Jesus zum jüdischen Pessachfest neben einigen weiteren Symbolen mit astronomischer Deutungsmöglichkeit auch die expliziten Zahlen Zwei, Fünf und Zwölf auf:

&lt;blockquote&gt;
9 Hier ist ein kleiner Junge, der hat '''fünf Gerstenbrote''' und '''zwei Fische'''; doch was ist das für so viele?&lt;br/&gt;
10 Jesus sagte: Lasst die Leute sich setzen! Es gab dort nämlich viel Gras. Da setzten sie sich; es waren etwa '''fünftausend''' Männer.&lt;br/&gt;
11 Dann nahm Jesus die '''Brote''', sprach das Dankgebet und teilte an die Leute aus, so viel sie wollten; ebenso machte er es mit den '''Fischen'''.&lt;br/&gt;
12 Als die Menge satt geworden war, sagte er zu seinen Jüngern: Sammelt die übrig gebliebenen Brocken, damit nichts verdirbt!&lt;br/&gt;
13 Sie sammelten und füllten '''zwölf Körbe''' mit den Brocken, die von den '''fünf Gerstenbroten''' nach dem Essen übrig waren.&lt;br/&gt;
...&lt;br/&gt;
31 Unsere Väter haben das '''Manna''' in der Wüste gegessen, wie es in der Schrift heißt: '''Brot vom Himmel''' gab er ihnen zu essen.&lt;br/&gt;
32 Jesus sagte zu ihnen: Amen, amen, ich sage euch: Nicht Mose hat euch das '''Brot vom Himmel''' gegeben, sondern mein Vater gibt euch das wahre '''Brot vom Himmel'''.&lt;br/&gt;
33 Denn das '''Brot''', das Gott gibt, kommt vom '''Himmel''' herab und gibt der Welt das Leben.&lt;br/&gt;
34 Da baten sie ihn: Herr, gib uns immer dieses '''Brot'''!&lt;br/&gt;
35 Jesus antwortete ihnen: Ich bin das '''Brot des Lebens'''; wer zu mir kommt, wird nie mehr hungern, und wer an mich glaubt, wird nie mehr Durst haben.&lt;br/&gt;
...&lt;br/&gt;
48 Ich bin das '''Brot des Lebens'''.&lt;br/&gt;
49 Eure Väter haben in der Wüste das '''Manna''' gegessen und sind gestorben.&lt;br/&gt;
50 So aber ist es mit dem '''Brot''', das vom '''Himmel''' herabkommt: Wenn jemand davon isst, wird er nicht sterben.&lt;br/&gt;
51 Ich bin das '''lebendige Brot''', das vom '''Himmel''' herabgekommen ist. Wer von diesem '''Brot''' isst, wird in Ewigkeit leben. Das '''Brot''', das ich geben werde, ist mein Fleisch für das Leben der Welt.
&lt;/blockquote&gt;

===== Evangelium nach Markus =====
Eine ähnliche Schilderung befindet sich im sechsten Kapitel des Evangeliums nach '''Markus''', wo das Ereignis an einem abgelegenen und einsamen Ort stattgefunden hat:

&lt;blockquote&gt;
38 Er sagte zu ihnen: Wie viele '''Brote''' habt ihr? Geht und seht nach! Sie sahen nach und berichteten: '''Fünf Brote''' und außerdem '''zwei Fische'''.&lt;br/&gt;
39 Dann befahl er ihnen, sie sollten sich in Mahlgemeinschaften im grünen Gras lagern.&lt;br/&gt;
40 Und sie ließen sich in Gruppen zu hundert und zu fünfzig nieder.&lt;br/&gt;
41 Darauf nahm er die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis, brach die '''Brote''' und gab sie den Jüngern, damit sie diese an die Leute austeilten. Auch die '''zwei Fische''' ließ er unter allen verteilen.&lt;br/&gt;
42 Und alle aßen und wurden satt.&lt;br/&gt;
43 Und sie hoben Brocken auf, '''zwölf Körbe''' voll, und Reste von den '''Fischen'''.&lt;br/&gt;
44 Es waren '''fünftausend''' Männer, die von den '''Broten''' gegessen hatten.
&lt;/blockquote&gt;

Die Brotvermehrung auch ein weiteres Mal im achten Kapitel des Evangeliums nach '''Markus''' erwähnt:

&lt;blockquote&gt;
5 Er fragte sie: Wie viele '''Brote''' habt ihr? Sie antworteten: '''Sieben'''.&lt;br/&gt;
6 Da forderte er die Leute auf, sich auf den Boden zu setzen. Dann nahm er die sieben '''Brote''', sprach das Dankgebet, brach die '''Brote''' und gab sie seinen Jüngern zum Verteilen; und die Jünger teilten sie an die Leute aus.&lt;br/&gt;
7 Sie hatten auch noch ein paar '''Fische''' bei sich. Jesus segnete sie und ließ auch sie austeilen.&lt;br/&gt;
8 Die Leute aßen und wurden satt. Und sie hoben die Überreste der '''Brotstücke''' auf, '''sieben Körbe''' voll.&lt;br/&gt;
9 Es waren etwa '''viertausend''' Menschen beisammen. Danach schickte er sie nach Hause.&lt;br/&gt;
...&lt;br/&gt;
19 Als ich die '''fünf Brote''' für die '''Fünftausend''' brach, wie viele '''Körbe voll Brotstücke''' habt ihr da aufgehoben? Sie antworteten ihm: '''Zwölf'''.&lt;br/&gt;
20 Und als ich die '''sieben Brote''' für die '''Viertausend''' brach, wie viele '''Körbe''' voll habt ihr da aufgehoben? Sie antworteten: '''Sieben'''.&lt;br/&gt;
21 Da sagte er zu ihnen: Versteht ihr immer noch nicht?
&lt;/blockquote&gt;

===== Evangelium nach Lukas =====
Ebenso verhält es sich im neunten Kapitel des Evangeliums nach '''Lukas''', wo das Ereignis dem Ort Betsaida (zu Deutsch: „Haus des Fisches“) am See Genezareth zugeordnet ist:

&lt;blockquote&gt;
12 Als der Tag zur Neige ging, kamen '''die Zwölf''' und sagten zu ihm: Schick die Leute weg, damit sie in die umliegenden Dörfer und Gehöfte gehen, dort Unterkunft finden und etwas zu essen bekommen; denn wir sind hier an einem abgelegenen Ort.&lt;br/&gt;
13 Er antwortete ihnen: Gebt ihr ihnen zu essen! Sie sagten: Wir haben nicht mehr als '''fünf Brote''' und '''zwei Fische'''; wir müssten erst weggehen und für dieses ganze Volk etwas zu essen kaufen.&lt;br/&gt;
14 Es waren nämlich etwa '''fünftausend''' Männer. Er aber sagte zu seinen Jüngern: Lasst sie sich in Gruppen zu ungefähr fünfzig lagern!&lt;br/&gt;
15 Die Jünger taten so und veranlassten, dass sich alle lagerten.&lt;br/&gt;
16 Jesus aber nahm die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis und brach sie; dann gab er sie den Jüngern, damit sie diese an die Leute austeilten.&lt;br/&gt;
17 Und alle aßen und wurden satt. Als man die übrig gebliebenen Brotstücke einsammelte, waren es '''zwölf Körbe''' voll.
&lt;/blockquote&gt;

===== Evangelium nach Matthäus =====
Auch im vierzehnten Kapitel des Evangeliums nach '''Matthäus''' ist von einem abgelegenen Ort in einer einsamen Gegend die Rede:

&lt;blockquote&gt;
17 Sie sagten zu ihm: Wir haben nur '''fünf Brote''' und '''zwei Fische''' hier.&lt;br/&gt;
18 Er antwortete: Bringt sie mir her!&lt;br/&gt;
19 Dann ordnete er an, die Leute sollten sich ins Gras setzen. Und er nahm die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis, brach die Brote und gab sie den Jüngern; die Jünger aber gaben sie den Leuten&lt;br/&gt;
20 und alle aßen und wurden satt. Und sie sammelten die übrig gebliebenen Brotstücke ein, '''zwölf Körbe''' voll.&lt;br/&gt;
21 Es waren etwa '''fünftausend''' Männer, die gegessen hatten, dazu noch Frauen und Kinder.
&lt;/blockquote&gt;

Etwas abgewandelt taucht die Brotvermehrung mit '''sieben Körben''' auch im fünfzehnten Kapitel des Evangeliums nach '''Matthäus''' auf:

&lt;blockquote&gt;
34 Jesus sagte zu ihnen: Wie viele '''Brote''' habt ihr? Sie antworteten: '''Sieben''' - und ein paar '''Fische'''.&lt;br/&gt;
35 Da forderte er die Leute auf, sich auf den Boden zu setzen.&lt;br/&gt;
36 Und er nahm die '''sieben Brote''' und die '''Fische''', sprach das Dankgebet, brach sie und gab sie den Jüngern und die Jünger gaben sie den Menschen.&lt;br/&gt;
37 Und alle aßen und wurden satt. Und sie sammelten die übrig gebliebenen Stücke ein, '''sieben Körbe''' voll.&lt;br/&gt;
38 Es waren '''viertausend''' Männer, die gegessen hatten, dazu noch Frauen und Kinder.&lt;br/&gt;
39 Danach schickte er die Menge nach Hause, stieg ins Boot und fuhr in die Gegend von Magadan.
&lt;/blockquote&gt;

Der Ort Magadan ist möglicherweise mit dem heutigen Ort Migdal (aramäisch: Magdala) am westlichen Ufer des Sees Genezareth gleichzusetzen.

==== Astronomische Bezüge ====
[[Datei:Sternenhimmel.Pessach.25.3.23.png|mini|rechts|hochkant=2|Sternenhimmel am jüdischen Pessachfest im Jahr 25 nach Christus. Der Vollmond stand hoch über dem Horizont im Süden im Herbstpunkt beim Stern Spica (= &quot;Kornähre&quot;) im Sternbild Jungfrau (Virgo). Gleichzeitig befand sich die Sonne tief unter dem Horizont im Norden in der Nähe des Frühlingspunktes im Sternbild Fische (Pisces).]]
[[Datei:Dendera.09.Jungfrau.Loewe.jpg|mini|rechts|hochkant=2|Das Sternbild Jungfrau (links) mit der Kornähre in der Hand und das Sternbild Löwe (rechts) im ägyptischen Zodiak von Dendera aus der Zeit kurz vor Christi Geburt.]]
[[Datei:Dendera.03.Fische.Wassermann.jpg|mini|rechts|hochkant=2|Das Sternbild Fische (links) und das Sternbild Wassermann (rechts unten) im ägyptischen Zodiak von Dendera aus der Zeit kurz vor Christi Geburt.]]

Zu diesen Bibelstellen sind im Folgenden einige Hinweise mit astronomischen Bezügen aufgeführt. Die [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|Bezugspunkte]] liegen hierbei in der Nähe der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Die_Ekliptik|Ekliptik]]:

* In den Versen im Evangelium nach Johannes ist mehrfach vom '''Brot, das vom Himmel herabkommt''' die Rede.
* Das zur Herstellung von Brot erforderliche Getreide kann durch eine '''Kornähre''' symbolisiert werden. Am Sternenhimmel wird die Kornähre durch den hellen, ekliptiknahen Stern '''Spica''' (α Virginis) im Sternbild '''Jungfrau''' (Virgo) repräsentiert. Der Vollmond stand zum jüdischen Pessachfest beim Stern Spica.
* Alle Pflanzen benötigen für das Gedeihen '''Wasser'''. Das '''Wasser''' wird am Himmel durch die drei Wassersternbilder der Ekliptik '''Fische''' (Pisces), '''Wassermann''' (Aquarius), und '''Ziegenfisch''' (Steinbock, Capricornus) westlich des [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Frühlingspunkt|Frühlingspunktes]] repräsentiert. Diese Sternbilder bilden mit einigen weiteren angrenzenden Wassersternbildern den [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|Urozean am Himmel]] (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Trichter_der_Thuraya|Der Trichter der Thuraya]]). Die Wassersternbilder waren zum Pessachfest in den drei Monaten unmittelbar zuvor von der Sonne durchlaufen worden und befanden sich beim Sonnenuntergang deshalb bereits unterhalb des westlichen Horizonts.
* Das Sternbild '''Fische''' (Pisces) besteht seit der Antike aus '''zwei Fischen'''.
* Zu Lebzeiten von Jesus von Nazareth war der '''Frühlingspunkt''' vom Sternbild Widder (Aries, ursprünglich das Hinterteil des großen Sternbilds [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|Himmelsstier (Taurus caeli)]]) in das Sternbild '''Fische''' (Pisces) gewandert. Inzwischen ist er innerhalb dieses Sternbilds noch weiter nach Westen gewandert. Die Sonne und der Neumond standen zu Beginn des jüdischen Monats Nisan, also dem Monat des jüdischen Pessachfestes, im Sternbild '''Fische'''. Der erste Monat des Jahres Nisan hieß bereits in der mesopotamischen Tradition, als sich der Frühlingspunkt noch im Sternbild Widder (Aries) befand, auf Akkadisch &quot;nisannu&quot; (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|Plejaden-Schaltregeln]]). In der alten jüdischen Tradition war der Nisan deswegen mit dem Sternbild Widder verbunden. Ferner wurde der Widder dem israelitischen Stamm Juda zugeordnet.
* Zu Lebzeiten von Jesus von Nazareth war der '''Herbstpunkt''' vom Sternbild Waage (Libra, ursprünglich die Scheren des großen Sternbilds [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsskorpion|Himmelsskorpion (Scorpio caeli)]]) in das Sternbild Jungfrau (Virgo) gewandert. Inzwischen ist er innerhalb dieses Sternbilds noch weiter nach Westen gewandert. Um 285 nach Christi erreichte der '''Herbstpunkt''' dann die ekliptikale Länge des Sterns '''Spica''' (α Virginis).
* Der '''Frühlingspunkt''' –&amp;nbsp;damals im Sternbild Fische&amp;nbsp;– und der '''Herbstpunkt''' –&amp;nbsp;damals im Sternbild Jungfrau (Virgo) beim Stern Spica&amp;nbsp;– befinden sich immer in genau gegenüber liegenden Punkten auf der Ekliptik. Auf diese Weise umfassen diese beiden ausgezeichneten Punkte den Lebewesenkreis (Zodiak) mit seinen '''zwölf''' Sternbildern sowie die Bahnen aller '''sieben''' Wandelgestirne. Diese beiden Punkte teilten die Ekliptik in '''zwei''' gleichgroße Teile, das Sommerhalbjahr und das Winterhalbjahr. Siehe hierzu auch &quot;[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|Beobachtungen in der Nähe der Ekliptik]]&quot;.
** Die '''fünf Brote''' können also mit den fünf mit bloßem Auge sichtbaren Wandelgestirnen (Planeten) '''Merkur''', '''Venus''', '''Mars''', '''Jupiter '''und '''Saturn''' gleichgesetzt werden.&lt;br/&gt;'''''Anmerkung''': In der Bibel wird in der Regel nicht zwischen Fixsternen und Planeten unterschieden. Für eine Ausnahme siehe 2.&amp;nbsp;Buch der Könige, Kapitel 23, Vers 5 aus dem siebenten vorchristlichen Jahrhundert, wo in der Einheitsübersetzung explizit von &quot;den Wandelsternen&quot; und in der Luther-Bibel von &quot;den Planeten&quot; die Rede ist.&lt;ref&gt;[https://www.bibleserver.com/EU/2.K%C3%B6nige23%2C5 2.&amp;nbsp;Buch der Könige, Kapitel 23, Vers 5], bibleserver.com, Einheitsübersetzung 2016&lt;/ref&gt; Die Vulgata schreibt hier allerdings von den &quot;duodecim signis&quot; (zu Deutsch: &quot;'''zwölf''' Zeichen&quot;), womit die '''zwölf''' Sternzeichen der Ekliptik gemeint sind, durch die die '''sieben''' Wandelgestirne ziehen. Die Septuaginta spricht noch allgemeiner von den &quot;μαζουρωθ&quot; (&quot;mazuroth&quot;) nach dem Hebräischen Wort &quot;מַזָּלָה&quot; (&quot;mazzaroth&quot;), womit allgemein eher Sternkonstellationen und nur im engeren Sinne die Sternzeichen des Zodiaks gemeint sind.''
** Die '''zwei Fische''' können also mit den beiden flächenhaft wahrnehmbaren Wandelgestirnen '''Sonne''' und '''Mond '''gleichgesetzt werden.
** Die Summe der '''fünf Brote''' und der '''zwei Fische''' respektive die '''sieben Brote''' (oder die '''sieben Körbe''') entsprechen der Anzahl der freiäugig sichtbaren '''sieben Wandelgestirne''', die sich entlang der Ekliptiklinie stetig gegenüber dem Fixsternhimmel bewegen. Siehe hierzu auch &quot;[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Zusammenhang_mit_dem_Stier|Zu den Etyma und den Kognaten von &quot;Sieben&quot;, &quot;Stier&quot;, &quot;Gestirn&quot; und &quot;Stern&quot;]]&quot;.
** Die ausgeteilten '''Brote''' und '''Fische''' durchmaßen die gesamte versammelte Menschenmenge, die durch den vollständigen [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|Lebewesenkreis (Zodiak)]] mit den '''zwölf Lebewesenkreiszeichen''' beziehungsweise durch die '''zwölf Körbe''' symbolisiert wird. Der Planet Jupiter, der den Zodiak in zwölf Jahren einmal durchläuft, wurde in Babylonien mit dem babylonischen Hauptgott Marduk gleichgesetzt.
* Insgesamt gibt es am Fixsternhimmel gut 2800&amp;nbsp;Sterne bis zur scheinbaren Helligkeit 5,5&lt;sup&gt;m&lt;/sup&gt; und knapp 8800&amp;nbsp;Sterne bis zur scheinbaren Helligkeit&amp;nbsp;6,5&lt;sup&gt;m&lt;/sup&gt;, die ohne Lichtverschmutzung mit bloßem Auge als einzelne Lichtpunkte gesehen werden können. Diese verteilen sich allerdings in der gesamten Himmelssphäre, so dass von einem Punkt auf der Erdoberfläche aus zu jedem Zeitpunkt immer nur ungefähr die Hälfte davon über dem Horizont steht. An den beiden Polen sind stets nur die Sterne der jeweiligen nördlichen oder südlichen Hemisphäre zu sehen, und am Äquator können im Laufe eines Jahres alle Sterne gesehen werden. Je nach Breitengrad und Zeitpunkt können bei Neumond (kein Streulicht) innerhalb einer wolkenlosen Nacht viertausend bis zu fast siebentausend Sterne beobachtet werden.&lt;ref&gt;Bob King: [https://skyandtelescope.org/astronomy-blogs/how-many-stars-night-sky-09172014/ 9,096 Stars in the Sky—Is that all? How many stars in the sky can you see?], skyandtelescope.org - The essential Guide to Astronomy, 17. September 2014&lt;/ref&gt; Diese Spanne entspricht der Angabe der bei der Brotvermehrung versammelten Menschen, deren Anzahl in den Evangelien mit '''viertausend''' beziehungsweise '''fünftausend''' angegeben ist.
** Im ersten Buch des Alten Testaments ('''Genesis''') wird Abram aus Ur in Mesopotamien bereits das Folgende prophezeit:
&lt;blockquote&gt;
15,5 ''Sieh doch zum Himmel hinauf und zähl die Sterne, wenn du sie zählen kannst! Und er sprach zu ihm: So zahlreich werden deine Nachkommen sein''&lt;br/&gt;
...&lt;br/&gt;
17,5 ''Man wird dich nicht mehr Abram nennen. Abraham, Vater der Menge, wird dein Name sein; denn zum Stammvater einer Menge von Völkern habe ich dich bestimmt.''
&lt;/blockquote&gt;
* Die Gruppen von (ungefähr) '''fünfzig''' oder '''hundert Männern''' entsprechen den Sternbildern, die über den gesamten Himmel verteilt sind. Nach der Festlegung der Internationalen Astronomischen Union (IAU) von 1930 gibt es heute 88&amp;nbsp;Sternbilder, die den Himmel vollständig abdecken. Mit den maximal fast 8800&amp;nbsp;freiäugig sichtbaren Sternen entspricht dies im Mittel also 100&amp;nbsp;Sternen pro Sternbild. Bei 4400&amp;nbsp;freiäugig sichtbaren Sternen wären es 50&amp;nbsp;Sterne pro Sternbild. Dies entspricht genau der Spanne der Gruppenstärke, die im Neuen Testament angegeben sind.
* Das '''Brot''' und der '''Wein''' werden nach der christlichen Lehre bei der Transsubstantiation in den Leib und das Blut des vom '''Himmel''' herabgekommenen &quot;Brot des Lebens&quot; (vergleiche die Rede über das Himmelsbrot von Jesus in der Synagoge von Kafarnaum in Evangelium nach Johannes 6,48–58) gewandelt, das die kosmische Ewigkeit verheißt.

Die Zahlen '''Zwei''', '''Fünf''', '''Sieben''' und '''Zwölf''' stehen in einem einfachen arithmetischen Zusammenhang, bei dem die beiden jeweils vorhergehenden Zahlen der Folge addiert werden:

{| class=&quot;wikitable&quot;
|+
|'''Zahl'''
|'''Summe'''
|'''Anmerkung'''
|-
|'''2'''
|
|Anzahl der freiäugig als '''flächenhaft wahrnehmbaren Wandelgestirne''' ('''Sonne''' und '''Mond'''), siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwei|Zur Zwei]]
|-
|'''5'''
|
|Anzahl der freiäugig als '''punktförmig wahrnehmbaren Wandelgestirne''' '''Merkur''', '''Venus''', '''Mars''', '''Jupiter''', '''Saturn'''
|-
|'''7'''
|= 2 + 5
|Anzahl der freiäugig wahrnehmbaren '''Wandelgestirne''' sowie der '''Tage in der Woche''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Sieben|Zur Sieben]]
|-
|'''12'''
|= 5 + 7
|Anzahl der '''Monate im Jahr''', der '''Lebewesenkreiszeichen des Zodiaks''' sowie der '''Erdenjahre pro Jupiterjahr''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwölf|Zur Zwölf]], vergleiche hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|Der Zodiak]]
|-
|'''19'''
|= 7 + 12
|Anzahl der '''Jahre''' mit '''zwölf Monaten''' und '''sieben Schaltmonaten''' einer '''Meton-Periode''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Neunzehn|Zur Neunzehn]], vergleiche hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|Die Plejaden-Schaltregeln]] und [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Mondzyklen#Der_Meton-Zyklus|Der Meton-Zyklus]]
|}

=== Weitere Bezüge ===
Weitere Bezüge von der Astronomie zur Theologie ergeben sich bei den folgenden Sachverhalten:

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Biblische_Erwähnungen|'''biblische Erwähnungen von Konstellationen''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Der_Stern_von_Bethlehem|'''Der Stern von Bethlehem''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Ochs_und_Esel|'''Ochs und Esel / Krippe / „Ich bin das Alpha und das Omega“''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Biblische_Bezüge|'''Biblische Bezüge zu den Mondhäusern / Mondstationen''']].

== Zur Kosmologie ==
[[Datei:Kosmologisches.Modell.Schwarze.Schale.Rotverschiebung.png|mini|rechts|hochkant=2.5|Ein kosmologisches Modell unseres im Zentrum isotropen und inhomogenen Universums, das von einer undurchsichtigen und massereichen schwarzen Kugelschale umgeben ist. Von der äußeren Region aus betrachtet, ist unser Universum ein gigantisches Schwarzes Loch. Zwischen dem inneren und dem äußeren Bereich der schwarzen Kugelschale ist kein Informationsaustausch möglich. Jegliche Materie, die von innen oder außen in die schwarze Kugelschale gelangt, ist von innen und von außen nicht mehr sichtbar. Sowohl die innere als auch die äußere Grenze der schwarzen Kugelschale stellen demzufolge einen Ereignishorizont dar.]]

Die '''Kosmologie''' beschäftigt sich mit der Struktur, dem Ursprung und der Entwicklung des Universums. Dadurch ergeben sich zahlreiche Bezüge zur beobachtenden '''Astronomie''' und zur '''Astrophysik''', aber auch zur '''Quantenphysik'''.

In der Antike gingen die Menschen noch davon aus, dass sich die Erde im Mittelpunkt der Welt und somit auch in der Mitte des sichtbaren Universums befindet. Dieses geozentrische Weltbild wurde seit dem 16.&amp;nbsp;Jahrhundert, ausgelöst durch die kopernikanische Wende, zunehmend verworfen und durch ein heliozentrisches Weltbild ersetzt. Durch die Erfindung und Verwendung von Fernrohren konnten seit dem Beginn des 17.&amp;nbsp;Jahrhunderts immer mehr Details im Sternenhimmel entdeckt werden. Durch astronomische Beobachtungen ergaben sich immer mehr Indizien für die Tatsache, dass die Erde einmal pro Jahr auf einer Ellipsenbahn die Sonne umrundet und nicht die Sonne die Erde umkreist. Der Philosoph Immanuel Kant (1724–1804) erkannte bereits 1755 in seiner Allgemeinen Naturgeschichte und Theorie des Himmels das innere Wesen unserer Milchstraße. Mit der ersten zuverlässigen Messung der Parallaxe von unserer Erde zum benachbarten Fixstern 61&amp;nbsp;Cygni (&quot;Bessel's Stern&quot;) durch Friedrich Wilhelm Bessel (1784–1846) in Königsberg und der daraus folgenden Berechnung von dessen Entfernung von gut zehn Lichtjahren im Jahr 1838 war die Tatsache, dass die Erde um die Sonne läuft, endgültig bewiesen.

Die Auswertung der astronomischen Beobachtungen hat zu der heute allgemein geteilten Auffassung geführt, dass unser Universum bei einem Urknall entstanden ist und seitdem expandiert. Die Berücksichtigung des Äquivalenzprinzips zwischen schwerer und träger Masse, das zu der von '''Albert Einstein''' (1879–1955) formulierten Allgemeinen Relativitätstheorie führt, brachte '''Alexander Friedmann''' (1888–1925) 1922 zu der theoretischen Vorhersage eines dynamischen Universums. Fünf Jahre später schlussfolgerte der belgische Astronom '''Georges Lemaître''' (1894–1966) aus den von '''Vesto Slipher''' (1875–1969) beobachteten Rotverschiebungen von fernen Galaxien und den von '''Edwin Hubble''' (1889–1953) ermittelten Entfernungen dieser Galaxien, dass das Universum expandiert. Aufgrund dieser Erkenntnis ergibt sich, dass das Universum einen Ursprung mit sehr kleinem Radius gehabt haben muss. Diesen Zustand nannte er &quot;primordiales Atom&quot; beziehungsweise &quot;Uratom&quot;. In der Folgezeit etablierte sich für diesen initialen Vorgang der Begriff &quot;'''Urknall'''&quot; (im Englischen: &quot;'''Big Bang'''&quot;).&lt;ref&gt;Markus Bautsch: ''[https://en.wikibooks.org/wiki/Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell/Brief_historical_review Moving objects in retarded gravitational potentials of an expanding spherical shell / Brief historical review], Wikibook (englisch), 2024, abgerufen am 28. Februar 2026&lt;/ref&gt;

Viele Astrophysiker versuchen heute mit dem sogenannten '''Standardmodell der Kosmologie''' (auch '''ΛCDM-Modell''' beziehungsweise Lambda-CDM-Modell, wobei &quot;CDM&quot; für &quot;cold dark matter&quot; steht, also für &quot;kalte, dunkle Materie&quot;) die Entwicklung des Universums nachzubilden. Hierfür wenden sie das kosmologische Prinzip an, das von zwei grundlegenden Annahmen ausgeht:&lt;ref&gt;Markus Bautsch: ''[https://en.wikibooks.org/wiki/Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell/Preface Moving objects in retarded gravitational potentials of an expanding spherical shell / Preface], Wikibook (englisch), 2024, abgerufen am 28. Februar 2026&lt;/ref&gt;

# Das Weltall sei '''homogen''', was bedeutet, dass es in groben Zügen von jedem Punkt aus gleich aussieht.
# Das Weltall sei '''isotrop''', was besagt, dass es in groben Zügen in jede Richtung gleich aussieht.

Mit diesen Annahmen kann das Modell berechnet werden, und mit diversen zusätzlichen Annahmen stimmt es in vielerlei Hinsicht mit den astronomischen Beobachtungen überein. Zu den zusätzlichen Annahmen gehören die folgenden beiden hypothetischen Größen:

* '''Kalte, dunkle Materie''', die zwar der Gravitation unterläge, aber keine Wechselwirkung mit elektromagnetischer Strahlung zeigt.
* Eine '''kosmologische Konstante''' Λ, die eine '''dunkle Energie''' beschreibt und für die beschleunigte Expansion des Universums verantwortlich sei.

Weder für die Homogenität noch für die Isotropie des Kosmos konnten bislang Belege gefunden werden, und auch für die kalte dunkle Materie und die dunkle Energie konnte bislang keine physikalische Interpretation geliefert werden.

Ferner ist auch die Annahme, dass die Naturkonstanten unveränderliche Werte haben, nicht begründbar. Auf kosmischen Zeitskalen kann es durchaus Änderungen geben, die wir derzeit nicht messen können. Die gilt insbesondere für die Hubble-Konstante, die die Expansionsrate des Universums beschreibt, für die Gravitationskonstante, die die Anziehung zweier Massen beschreibt, oder für die kosmologische Konstante, die die beschleunigte Expansion des Universums beschreibt. In diesem Kontext sei darauf hingewiesen, dass unser Universum genauso groß ist wie ein Schwarzes Loch mit der Masse unseres Universums. Deshalb gehen einige Kosmologen davon aus, dass wir innerhalb eines Schwarzen Loches der Größe und Masse unseres Universums leben könnten.

Siehe hierzu auch: [[:en:Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell|'''Moving objects in retarded gravitational potentials of an expanding spherical shell''']].

Darüber hinaus mehren sich Anzeichen und Hinweise, die gegen die Ergebnisse des Standardmodells der Kosmologie sprechen, beziehungsweise durch weitere Hypothesen, die physikalisch nicht begründet werden können, im Standardmodell berücksichtigt werden müssen. Die folgende unvollständige Liste soll hierzu einige Anhaltspunkte liefern:

* Präzise astronomische Beobachtungen zeigen, dass das Weltall auch auf großen Längenskalen '''nicht homogen''' ist, sondern Strukturen zeigt.
* Präzise astronomische Beobachtungen zeigen, dass das Weltall auch auf großen Längenskalen '''nicht isotrop''' ist (Asymmetrie der kosmischen Hintergrundstrahlung).
* Die Hubble-Konstante hat heute einen anderen Wert als früher (&quot;'''Hubble tension'''&quot;), was mit dem Standardmodell nicht im Einklang steht.
* Das beobachtete Vorkommen des dritten Elements im Periodensystem, also des Alkalimetalls '''Lithium''', ist mindestens dreimal geringer als vom Standardmodell vorhergesagt.
* Die '''Rotverschiebung von fernen Galaxien''' ist deutlich größer als es nach dem Standardmodell möglich wäre.
* Die beobachteten '''Rotationskurven von Spiralgalaxien''' stehen im Widerspruch zu den Ergebnissen des Standardmodells.
* Das Standardmodell ist nicht in der Lage, die Abwesenheit von '''Antimaterie''' im sichtbaren Teil des Universums zu erklären.
* Die im frühen Universum beobachteten '''primordialen Schwarzen Löcher und Galaxien''' mit explodierende '''Supernovae''' sowie dem Vorkommen von '''Sauerstoff''' stehen im Widerspruch zu den Ergebnissen des Standardmodells.

== Zur Astrologie ==
Eine Sonderstellung nimmt die '''{{w|Astrologie}}''' (zusammengesetzt mit dem altgriechischen ἄστρον (&quot;astron&quot;), zu Deutsch „Sternenlehre“) ein. Sie ist ein weiteres Beispiel für eine Disziplin, bei der grundlegende Kenntnisse über die Astronomie eine Voraussetzung sind. Sie versucht, Zusammenhänge zwischen den Konstellationen der Wandelgestirne oder astronomischen Ereignissen am Sternenhimmel mit irdischen Geschehnissen oder Veränderungen herzustellen, insbesondere was bestimmte Konjunktionen und daraus abgeleitete Prophezeiungen betrifft. Sie wurde bereits in Mesopotamien und in anderen alten Kulturkreisen von Astronomen ausgeübt. Noch der Astronom '''{{w|Johannes Kepler}}''' (1571–1630) hat als einer der letzten Astronomen einen wesentlichen Teil seiner Einkünfte durch die Erstellung von Horoskopen bestritten. Aber schon Aristoteles hatte festgestellt und beschrieben, dass die bei bestimmten Konstellationen am Himmel vorhergesagten Ereignisse nicht eingetreten waren.

Vor der Aufklärung haben astrologische Prophezeiungen noch eine große und weitreichende gesellschaftliche Bedeutung gehabt. Als Beispiel seien die Behauptungen des ersten im Kurfürstentum Brandenburg tätigen Astrologen '''{{w|Johannes Carion}}''' (1499–1537) genannt, der für 1524 eine Sintflut vorhersagte, die nicht eingetroffen ist.&lt;ref&gt;{{Literatur |Autor=Markus Bautsch, Friedhelm Pedde |Titel=Vor 500 Jahren: Die Sintflut von 1524 die nicht stattfand |Online=https://wfs.berlin/wp-content/uploads/2024/05/A19-BROplanetA4_40s-feb2024ff_www-rz.pdf |Sammelwerk=Dem Himmel nahe. |WerkErg=Mitteilungen der Wilhelm-Foerster-Sternwarte e.V.|Nummer=19 |Hrsg=Wilhelm-Foerster-Sternwarte e.V. / Zeiss-Planetarium am Insulaner |Ort=Berlin |Datum=2024-02 |Seiten=16–19 |Sprache=de |Abruf=2025-08-03|ISSN=2940-9330}}&lt;/ref&gt; Der Wiener Hofastronom '''{{w|Georg Tannstetter}}''' (1482–1535) sah sich 1523 bemüßigt, die schon lange im Voraus erhitzten und besorgten Gemüter zu beruhigen:&lt;ref&gt;Georg Tannstetter: ''Libellus consolatorius contra opiniones de diluvio et aliis horrendis periculis anni 1523''&lt;/ref&gt;

&lt;blockquote&gt;
Nun hat sich überall, in allen Köpfen, in allen Seelen das Gerücht eingeschlichen:&lt;br/&gt;
die Gelehrten und Weisen sind in ständigem Streitgespräch, andere hingegen sind derart verstört, dass sie ihren Geschäften nicht mehr nachgehen können; sie verkaufen ihre Anwesen, ihre Felder und Besitztümer oder lassen davon ab, Güter zu kaufen, in der Hoffnung, ihr Geld leichter in die sicheren Berge transportieren zu können. Andere wiederum verschieben ihr Heiratsversprechen, kündigen ohne scheinbaren Grund Verträge auf, entziehen sich ihren christlichen Gelübden, arbeiten faul und missmutig auf dem Land und fragen sich, was es denn nütze, Geld und Gut anzuhäufen, wenn doch in kürzester Zeit niemand mehr davon Nutzen ziehen könne.
&lt;/blockquote&gt;

'''→ Siehe auch:'''

* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Definition|'''Konjunktionen''', Abschnitt '''Definition''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Historische_Konjunktionen|'''Historische Konjunktionen''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|'''Beobachtungen in der Nähe der Ekliptik''']].
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

== Einzelnachweise ==
&lt;references&gt;&lt;/references&gt;</text>
      <sha1>5pd0s2yjl8rjli7d53jgsz3mjkniseo</sha1>
    </revision>
    <revision>
      <id>1088600</id>
      <parentid>1088599</parentid>
      <timestamp>2026-07-04T09:56:59Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <comment>/* Himmelspforte */ Beinamen von El</comment>
      <origin>1088600</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="88168" sha1="6atgvp8ouhcpy5k8c8429jj4zo7m9ml" xml:space="preserve">Viele Bezeichnungen für verschiedene Lehren werden mit der aus dem Altgriechischen stammenden Endung &quot;-logie&quot; (altgriechisch λόγος (&quot;logos&quot;), zu Deutsch „Lehre“) gebildet. Die folgenden Disziplinen sind in diesem Kontext hervorzuheben, da sie insbesondere für die '''{{w|Archäoastronomie}}''' wertvolle wissenschaftliche Ergänzungen zur '''{{w|Astronomie}}''' (aus den altgriechischen Wörtern ἄστρον (&quot;ástron&quot;, zu Deutsch „Stern“) und νόμος (&quot;nómos, zu Deutsch „Gesetz“) zusammengesetzt also „Sterngesetz“) liefern:

* Die '''{{w|Archäologie}}''' (zusammengesetzt mit dem altgriechischen Wort ἀρχαῖος (&quot;archaios&quot;), zu Deutsch „Altertumslehre“) beschäftigt sich mit der kulturellen Entwicklung der Menschheit.
* Die '''{{w|Etymologie}}''' (zusammengesetzt mit dem altgriechischen Wort ἔτυμος (&quot;etymos&quot;), zu Deutsch „Wortherkunftslehre“) untersucht die geschichtliche Herkunft von Wörtern.
* Die '''{{w|Mythologie}}''' (zusammengesetzt mit dem altgriechischen Wort μῦθος (&quot;mythos&quot;), zu Deutsch „Erzählungslehre“), die sich wissenschaftlich mit der Sagenwelt beschäftigt.
* Die '''{{w|Theologie}}''' (zusammengesetzt mit dem altgriechischen Wort θεός (&quot;theós&quot;), zu Deutsch „Gotteslehre“) mit ihren Lehren zum religiösen Glauben und dessen Glaubensdokumenten.
* Die '''{{w|Kosmologie}}''' (zusammengesetzt mit dem altgriechischen Wort κόσμος (&quot;kósmos&quot;), zu Deutsch „Weltenlehre“) ist hingegen eine Lehre, die sich im Laufe der Jahrtausende deutlich verändert hat und sich auch heute noch erheblich weiterentwickelt, da es in der modernen Astronomie und Astrophysik mit zunehmend hohem technischem Aufwand immer wieder zu neuen Erkenntnissen kommt.
* Die '''{{w|Numerologie}}''' (zusammengesetzt mit dem lateinischen Wort numerus, zu Deutsch „Zahlenlehre“) mit ihren mystischen Lehren über die symbolische Zuweisung von Bedeutungen an Zahlen.

Von der Antike bis ins Mittelalter galt die Beherrschung der '''{{w|sieben freien Künste}}''' als Voraussetzung für das Betreiben von Philosophie. Zu den drei &quot;trivialen&quot; Künsten der {{w|Grammatik}}, der {{w|Rhetorik}} und der {{w|Dialektik}} des '''{{w|Trivium|Triviums}}''' wurden die vier Künste der {{w|Musiktheorie}}, der {{w|Arithmetik}}, der {{w|Geometrie}} und der {{w|Astronomie}} zu den Künsten des '''{{w|Quadrivium|Quadriviums}}''' gezählt → siehe hierzu auch [[Quadriviale_Kuriositäten|'''Wikibook ''Quadriviale Kuriositäten''''']].

== Zur Etymologie ==
Die Genesis aus dem Alten Testament greift die Thematik der Verwirrung der einheitlichen Sprache in ihrem elften Kapitel auf, und beschreibt, wie die bereits sternenkundigen Menschen im Norden Mesopotamiens übermütig geworden waren und in Babel einen Turm mit einer Spitze '''bis in den Himmel''' errichten wollten:&lt;ref&gt;[https://www.bibleserver.com/EU/1.Mose11 Genesis 11], Genesis, Kapitel 11, Einheitsübersetzung&lt;/ref&gt;

&lt;blockquote&gt;
1 Die ganze Erde hatte eine Sprache und ein und dieselben Worte.&lt;br/&gt;
2 Als sie ostwärts aufbrachen, fanden sie eine Ebene im Land Schinar und siedelten sich dort an.&lt;br/&gt;
3 Sie sagten zueinander: Auf, formen wir Lehmziegel und brennen wir sie zu Backsteinen. So dienten ihnen gebrannte Ziegel als Steine und Erdpech als Mörtel.&lt;br/&gt;
4 Dann sagten sie: Auf, bauen wir uns eine Stadt und einen Turm mit einer Spitze '''bis in den Himmel'''! So wollen wir uns einen Namen machen, damit wir uns nicht über die ganze Erde zerstreuen.&lt;br/&gt;
5 Da stieg der HERR herab, um sich Stadt und Turm anzusehen, die die Menschenkinder bauten.&lt;br/&gt;
6 Und der HERR sprach: Siehe, ein Volk sind sie und eine Sprache haben sie alle. Und das ist erst der Anfang ihres Tuns. Jetzt wird ihnen nichts mehr unerreichbar sein, wenn sie es sich zu tun vornehmen.&lt;br/&gt;
7 Auf, steigen wir hinab und verwirren wir dort ihre Sprache, sodass keiner mehr die Sprache des anderen versteht.&lt;br/&gt;
8 Der HERR zerstreute sie von dort aus über die ganze Erde und sie hörten auf, an der Stadt zu bauen.&lt;br/&gt;
9 Darum gab man der Stadt den Namen Babel, Wirrsal, denn dort hat der HERR die Sprache der ganzen Erde verwirrt und von dort aus hat er die Menschen über die ganze Erde zerstreut.
&lt;/blockquote&gt;

Es mag weniger verwunderlich sein, dass Schöpfungsmythen oder Berichte über Katastrophen nicht nur einen astronomischen Hintergrund haben, sondern in völlig verschiedenen Kulturen sehr ähnliche Merkmale zeigen, wenn man sich das Folgende bewusst macht: Einige Indizien deuten auf einen für viele Kulturen gemeinsamen Ursprung hin, der auf eine tiefsinnige Betrachtung und Beobachtung des Himmelsgeschehens hindeutet.

Bei bestimmten Wörtern sind die Ähnlichkeiten in vielen lebenden und toten Sprachen so auffällig, dass sie ein gemeinsames Ursprungswort (Etymon) haben und somit Kognaten sein dürften. 

=== &quot;Stern&quot; ===
Bei den Wörtern „Gestirn“ beziehungsweise „Stern“ sind die Ähnlichkeiten in vielen lebenden und toten Sprachen sehr auffällig, und diese Verwandtschaften mögen durch die Wörter für &quot;Stern&quot; in den folgenden Sprachen belegt werden:

* Akkadisch &quot;istar&quot;
* Indogermanisch &quot;ster&quot;
* Griechisch &quot;astro&quot; / &quot;asteri&quot;
* Lateinisch &quot;astrum&quot; / &quot;stella&quot;
* Althochdeutsch &quot;stern(o)&quot;
* Jiddisch &quot;shtern&quot;
* Katalanisch und Spanisch &quot;estrella&quot;
* Portugiesisch &quot;estrela&quot;
* Englisch &quot;star&quot;
* Niederländisch &quot;ster&quot;
* Westfriesisch &quot;stjer&quot;
* Italienisch und Korsisch &quot;stella&quot;
* Rumänisch &quot;stea&quot;
* Sardisch &quot;istedda&quot;
* Maltesisch &quot;stilla&quot;
* Französisch &quot;étoile&quot; aus Altfranzösisch &quot;estoile&quot;
* Galicisch &quot;estrela&quot;
* Walisisch &quot;seren&quot;
* Dänisch und Norwegisch &quot;stjerne&quot;
* Schwedisch &quot;stjärna&quot;
* Isländisch &quot;stjarna&quot;
* Kurdisch &quot;stêrk&quot;
* Gujarati &quot;Tārō&quot;
* Hindi &quot;तारा&quot; (taara)
* Marathi &quot;तारा&quot; (Tārā)
* Nepalesisch &quot;तारा&quot; (Tārā)
* Punjabi &quot;ਤਾਰਾ&quot; (Tārā)
* Singhalesisch &quot;තරුව&quot; (taruva)
* Khmer &quot;តារា&quot; (tara)
* Armenisch &quot;աստղ&quot; (astgh)
* Tadschikisch &quot;ситора&quot; (sitora)
* Hausa &quot;tauraro&quot;
* Krio &quot;sta&quot;

=== &quot;Stier&quot; ===
Eine starke Ähnlichkeit gibt es in vielen Sprachen auch zwischen den Wörtern „Stern“ und „Stier“. Der Stier bezeichnet zudem auch ein bedeutendes und eines der ältesten Sternbilder überhaupt:

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|'''Himmelsstier''']].

* Akkadisch und Assyrisch &quot;šūru&quot;
* Aramäisch &quot;tōra&quot;
* Hebräisch &quot;šǒr&quot;
* Ugaritisch &quot;twr&quot;
* Arabisch &quot;ثور&quot; (&quot;thawr&quot;)
* Griechisch &quot;ταύρος&quot; (&quot;tauros&quot;)
* Lateinisch &quot;taurus&quot;
* Althochdeutsch &quot;stior&quot;
* Italienisch, Katalanisch und Spanisch &quot;toro&quot;
* Galicisch &quot;touro&quot;
* Gallisch &quot;tarvos&quot;
* Französisch &quot;taureau&quot;
* Schwedisch &quot;tjur&quot;
* Dänisch &quot;tyr&quot;
* Irisch und Gälisch &quot;tarbh&quot;
* Wallisisch &quot;tarw&quot;

=== &quot;Horn&quot; ===
Auch die Hörner des Stieres betreffend setzen sich die vielen Ähnlichkeiten fort:

* Akkadisch &quot;carnu&quot;
* Aramäisch &quot;qeren&quot;
* Griechisch &quot;κόρνο&quot; (&quot;korno&quot;)
* Lateinisch &quot;cornu&quot;
* Maltesisch &quot;qrun&quot;*
* Arabisch &quot;قرون&quot; (&quot;qurun&quot;)
* Französisch &quot;corne&quot;
* Italienisch &quot;corne&quot;
* Rumänisch &quot;corn&quot;
* Haitianisch &quot;kòn&quot;

=== &quot;Sieben&quot; ===
Die in vielen Kulturen als heilig angesehene Zahl Sieben taucht im Zusammenhang mit der Astronomie als Anzahl der mit bloßem Auge sichtbaren Wandelgestirne und als Zahl der Hauptsterne in vielen Asterismen auf:

* Sieben Wandelgestirne: Sonne Mond, Merkur, Venus, Mars, Jupiter, Saturn
* Siebengestirn im Himmelsstier: Alkione, Atlas, Electra, Maia, Merope, Taygeta, Pleione
* Sternbild Orion: Beteigeuze, Rigel, Bellatrix, Alnilam, Alnitak, Saiph, Mintaka
* Asterismus Großer Wagen: Alioth, Dubhe, Alkaid, Mizar, Merak, Phekda, Megrez

→ Siehe auch:

* [[Quadriviale_Kuriositäten/_Zahlen#Zur_Sieben|'''Zur Sieben''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Der_Fixsternhimmel#Die_sieben_hellsten_Objekte_der_Ekliptik|'''Die sieben hellsten Objekte der Ekliptik''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Kalenderführung#Die_Siebentagewoche|'''Die Siebentagewoche''']].

Wegen der hohen kulturellen, rituellen oder mythischen Bedeutung gibt es in vielen Kulturen und Sprachen etymologische Übereinstimmungen:

* Akkadisch &quot;sebe&quot;
* Proto-Indoeuropäisch &quot;septḿ̥&quot;
* Hetitisch &quot;sipta&quot;
* Proto-Germanisch &quot;*sebun&quot;
* Althochdeutsch &quot;sibun&quot;
* Hebräisch &quot;sajin&quot; (Buchstabe) oder &quot;scheva&quot; (Wort)
* Etruskisch &quot;semph&quot;
* Maltesisch &quot;sebgħa&quot;
* Arabisch &quot;sabʿa&quot;
* Griechisch &quot;επτά&quot; (&quot;(h)epta&quot;)
* Lateinisch &quot;septem&quot;
* Ungarisch &quot;het&quot;
* Proto-Balto-slawisch &quot;septin&quot;
* Proto-Indo-Iranisch &quot;saptá&quot;
* Katalanisch &quot;set&quot;
* Spanisch &quot;siete&quot;
* Galicisch &quot;sete&quot;
* Lettisch &quot;septiņi&quot;
* Italienisch &quot;sette&quot;
* Französisch &quot;sept&quot;
* Englisch &quot;seven&quot;
* Wallisisch &quot;saith&quot;
* Bosnisch / Kroatisch &quot;sedam&quot;
* Rumänisch &quot;șapte&quot;
* Irisch &quot;seacht&quot;
* Swahili &quot;saba&quot;
* Haitianisch &quot;sèt&quot;

== Zur Mythologie ==
Seit Jahrtausenden blicken Menschen in den Nachthimmel und versuchen, die unzähligen Lichter am Firmament zu deuten. Schon früh begannen sie, die von ihnen erfundenen Sternbilder und die unablässig durch den Himmel ziehenden Wandelgestirne durch Geschichten über Götter, Helden oder andere Wesen zu interpretieren, zu erzählen und zum Teil über Jahrhunderte hinweg zu tradieren. Die '''Mythologie''' spielte dabei eine zentrale Rolle: Sie half nicht nur, eine symbolische Ordnung in den geheimnisvollen Kosmos zu bringen, sondern prägte auch viele der Bezeichnungen und Vorstellungen, die bis heute in der beschreibenden Astronomie überlebt haben.

Die Verbindung zwischen Mythologie und Astronomie ist tief verwurzelt und zeugt vom menschlichen Bedürfnis, das wahrgenommene, aber dennoch unfassbare Universum durch räumliche und zeitliche Vorstellungen sowie durch Erzählungen begreifbar zu machen. Das Geschehen am Himmel musste auf die Menschen vor der Erfindung der Bewegtbilder und des Films in der späten Neuzeit sowohl attraktiv als auch spektakulär gewirkt haben. So konnten verschiedene mythische Gestalten am Himmel durch ihre scheinbaren Handlungen wahrgenommen werden. Durch die Wiederholung solcher Deutungen konnten sich besonders beliebte Mythen im kulturellen Kontext über die Zeit verfestigen, und entsprechende Riten konnten sich etablieren.

Damit war auch eine wesentliche Voraussetzung für den Glauben der Menschen an eine höhere Macht oder mehrere höhere Mächte gegeben. Der Begriff '''Religion''' stammt vom lateinischen Inifiniv &quot;relegere&quot; ab. Dieses Verb bedeutet wörtlich übersetzt &quot;wieder lesen&quot; und meint im Sinne von &quot;überdenken&quot; das bewusste Wahrnehmen von Prophezeiungen oder Omen sowie das nachhaltige Beachten tradierter Vorschriften.

'''→ Siehe:'''

* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Der Urozean''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Sagenwelt|'''Die Plejaden / Sagenwelt''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Mythologie|'''Der Himmelsstier''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Babylonische_Himmelswege|'''Babylonische Himmelswege''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Mithraskult|'''Mithraskult und Tauroktonie''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Höhlenmalerei_in_der_Magura-Höhle|'''Die Höhlenmalerei in der Magura-Höhle''']].

== Zur Theologie ==
Die '''Theologie''' (vom Altgriechischen θεός = theós = Gott und λόγος = lógos = Lehre) ist die Lehre von einem Gott oder von mehreren Göttern. Sie lehrt einen ausgeprägten religiösen Glauben, begründet rituelle Traditionen und deutet die vorhandenen Glaubensdokumente.

[[Datei:Aristoteles.Theologie.png|mini|rechts|Wahrnehmbarkeit und Vergänglichkeit nach Aristoteles]]

Die Theologie des '''{{w|Aristoteles}}''' (384–322) postuliert drei mögliche Substanzen:&lt;ref&gt;Aristoteles: ''Metaphysik'', Kapitel XII (Λ), Philosophische Theologie, Seiten 1069a –1076a&lt;/ref&gt;

{| class=&quot;wikitable&quot;
|+ Mögliche Substanzen nach Aristoteles
! Nummer !! Substanz !! Erläuterung !! Interpretationsbeispiel
|-
| 1. || Die sinnlich wahrnehmbare und vergängliche Substanz || Konkrete Dinge, die nur eine begrenzte Teilhabe an der Ewigkeit haben. || Lebewesen
|-
| 2. || Die sinnlich wahrnehmbare und unvergängliche Substanz || Konkrete Dinge, die eine unbegrenzte Teilhabe an der Ewigkeit haben. || Die sieben Wandelgestirne und die Fixsterne
|-
| 3. || Die sinnlich nicht wahrnehmbare und unvergängliche Substanz || Lebendiger, unbewegter Beweger, der der Ursprung aller anderen Dinge ist. || Gott
|}

Dieses theologische Prinzip wurde später auch von '''{{w|Thomas van Aquin}}''' (1225-1274) in seinen ''Quinque viae ad Deum'' (&quot;Fünf Wege zu Gott&quot;) aufgegriffen:

{| class=&quot;wikitable&quot;
|+ Nach dem ''Quinque viae ad Deum'' (&quot;Fünf Wege zu Gott&quot;) von Thomas von Aquin
! Weg !! Bezeichnung !! Voraussetzung !! Feststellung !! Folgerung
|-
| Via&amp;nbsp;I || Bewegungsbeweis || In der Welt ist überall Bewegung. || Alles Bewegte muss von einem anderen in Bewegung gebracht worden sein. || Der Erstbeweger ist Gott.
|-
| Via&amp;nbsp;II || Kausalitätsbeweis || In der Welt gibt es überall Ursachen und Wirkungen. || Jede Wirkung muss eine Ursache haben. || Die erste Ursache der Welt ist Gott.
|-
| Via&amp;nbsp;III || Kontingenzbeweis || Alles Empirische in der Welt entsteht und vergeht wieder. || Jedes empirische Wesen muss das Sein von einem absoluten Wesen empfangen haben. || Das absolute Wesen ist Gott.
|-
| Via&amp;nbsp;IV || Stufenbeweis || In der Welt gibt es abgestuft gute, wahre und schöne Dinge. || Das absolute Wesen muss die höchste Güte, Wahrheit und Schönheit haben. || Das höchste Gute, Wahre und Schöne ist Gott.
|-
| Via&amp;nbsp;V || Finalitätsbeweis || In der Welt gibt es Ordnung und Gesetzmäßigkeit. || Ordnung und Gesetzmäßigkeit müssen auf einen denkenden Geist zurückgehen. || Dieser Geist kommt von Gott.
|}

Auch '''{{w|Gottfried Wilhelm Leibniz}}''' (1646-1717) lehnt sich in seiner Hypothese von „Gott als letztem und zureichendem Grund der Welt“ daran an.

Auch im 90. Psalm wird dieser Ansatz thematisiert:

&lt;blockquote&gt;
Das vierte Buch&lt;br/&gt;
Der '''ewige''' Gott – der '''vergängliche''' Mensch&lt;br/&gt;&lt;br/&gt;
1 Ein Bittgebet des Mose, des Mannes Gottes. O Herr, du warst uns Wohnung '''von Geschlecht zu Geschlecht'''.&lt;br/&gt;
2 '''Ehe geboren wurden die Berge, ehe du unter Wehen hervorbrachtest Erde und Erdkreis''', bist du '''Gott von Ewigkeit zu Ewigkeit'''.&lt;br/&gt;
3 '''Zum Staub zurückkehren lässt du den Menschen''', du sprichst: Ihr Menschenkinder, kehrt zurück!&lt;br/&gt;
4 Denn tausend Jahre sind in deinen Augen wie der Tag, der gestern vergangen ist, wie eine Wache in der Nacht.
&lt;/blockquote&gt;

Darüber hinaus gibt der vierte Vers einen deutlichen Hinweis auf das Verhältnis zwischen der Länge des viele Jahrtausende dauernden Präzessionszyklus und der Länge eines siderischen Monats: der Mond wandert entlang der Ekliptiklinie an einem Tag genauso weit wie der Frühlingspunkt in tausend Jahren.

→ Siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Präzession|'''Präzession''']].

Der griechische Dichter '''{{w|Aratos von Soloi}}''' in Kilikien (≈310–245) hatte seine astronomischen Kenntnisse vom Astronomen und Mathematiker '''{{w|Eudoxos von Knidos}}''' (geboren nach 390, gestorben nach 338) erhalten. In dem in der Antike verbreiteten Lehrgedicht Φαινόμενα (Phainomena = „Himmelserscheinungen“) von Aratos wird der Sternenhimmel in zahlreichen Hexametern beschrieben. Sein monumentales sechseckiges Grab aus der antiken Stadt Pompeiopolis wurde 2020 in der türkischen Provinz Mersin wiederentdeckt.&lt;ref&gt;Patricia Claus: [https://greekreporter.com/2021/07/11/memorial-tomb-of-ancient-greek-astronomer-aratus-unearthed-in-turkey/ Memorial Tomb of Ancient Greek Astronomer Aratus Unearthed in Turkey], The Greek Reporter, 11. Juli 2021&lt;/ref&gt;

Hier der Beginn des Prologs des Lehrgedichts:

&lt;blockquote&gt;
Εκ Διὸς ἀρχώμεσθα , τὸν οὐδέποτ᾽ ἄνδρες ἐῶμεν&lt;br/&gt;
῎Αῤῥητον . Μεσταὶ δὲ Διὸς πᾶσαι μὲν ἀγυιαὶ ,&lt;br/&gt;
Πᾶσαι δ᾽ ἀνθρώπων ἀγοραί · μεστὴ δὲ θάλασσα ,&lt;br/&gt;
Καὶ λιμένες. πάντη δὲ Διὸς κεχρήμεθα πάντες .&lt;br/&gt;
'''Τοῦ γὰρ καὶ γένος εἰμέν''' · ὁ δ᾽ ἤπιος ἀνθρώποισι&lt;br/&gt;
Δεξιὰ σημαίνει · λαοὺς δ᾽ ἐπὶ ἔργον ἐγείρει ,&lt;br/&gt;
Μιμνήσκων βιότοιο . λέγει δ᾽ , ὅτε βῶλος ἀρίστη&lt;br/&gt;
Βουσί τε καὶ μακέλῃσι · λέγει δ᾽ , ὅτε δεξιαὶ ὧραι ,&lt;br/&gt;
Καὶ φυτὰ γύρῶσαι , καὶ σπέρματα πάντα βαλέσθαι .&lt;br/&gt;
Αὐτὸς γὰρ τάγε σήματ᾽ ἐν '''οὐρανῷ''' ἐστήριξεν ,&lt;br/&gt;
'''Αστρα''' διακρίνας · ἐσκέψατο δ᾽ εἰς ἐνιαυτὸν&lt;br/&gt;
'''᾿Αστέρας''' , οἵ κε μάλιστα τετυγμένα σημαίνοιεν&lt;br/&gt;
᾿Ανδράσιν ὡράων , ὄφρ᾽ ἔμπεδα πάντα φύωνται .&lt;br/&gt;
Τῷ μιν ἀεὶ πρῶτόν τε καὶ ὕστατον ἱλάσκονται .&lt;br/&gt;
Χαῖρε , πάτερ , μέγα θαῦμα , μέγ᾽ ἀνθρώποισιν ὄνειαρ ,&lt;br/&gt;
Αὐτὸς καὶ προτέρη γενεή ! χαίροιτε δὲ , Μοῦσαι&lt;br/&gt;
Μειλίχιαι , μάλα πᾶσαι ! ἐμοί γε μὲν '''ἀστέρας''' εἰπεῖν ,&lt;br/&gt;
Ηἱ θέμις εὐχομένῳ , τεκμήρατε πᾶσαν ἀοιδήν .&lt;br/&gt;
Οἱ μὲν ὁμῶς πολέες τε , καὶ ἄλλυδις ἄλλοι ἐόντες ,&lt;br/&gt;
'''Οὐρανῷ''' ἕλκονται πάντ᾽ ἤματα συνεχὲς αἰεί.&lt;br/&gt;
Αὐτὰρ ὅγ᾽ οὐδ᾽ ὀλίγον μετανίσσεται · ἀλλὰ μάλ' αὕτως&lt;br/&gt;
'''῎Αξων''' οἱ ἐνάρηρεν · ἔχει δ᾽ ἀτάλαντον ἁπάντη&lt;br/&gt;
'''Μεσσηγὺς γαῖαν''' , περὶ δ᾽ '''οὐρανὸν''' αὐτὸν ἀγινεῖ.&lt;br/&gt;
Καί μιν πειραίνουσι δύω '''πόλοι''' ἀμφοτέρωθεν ·&lt;br/&gt;
᾿Αλλ᾽ ὁ μὲν οὐκ ἐπίοπτος · ὁ δ᾽ ἀντίος ἐκ '''Βορέαο''' ,&lt;br/&gt;
Ὑψόθεν Ὠκεανοῖο . Δύω δὲ μιν ἀμφὶς ἔχουσαι&lt;br/&gt;
'''Ἄρκτοι''' ἅμα τροχόωσι · τὸ δὴ καλέονται '''῞Αμαξαι''' .
&lt;/blockquote&gt;

Übersetzung unter Beibehaltung der Hexameter nach dem deutschen Dichter, Übersetzer und Hochschullehrer Johann Heinrich Voss (1751–1826) von 1824:&lt;ref&gt;АРАТОΥ ΦΑΙΝΟΜΕΝΑ ΚΑΙ ΔΙΟΣΗΜΕΙΑ. Des Aratos Sternerscheinungen und Wetterzeichen. Übersetzt und erklärt von Johann Heinrich Voss. Heidelberg bei Christian Friedrich Winter. 1824.&lt;/ref&gt;

&lt;blockquote&gt;
Zeus sei unser Beginn , und niemals bleib' er uns Männern&lt;br/&gt;
Ungelobt. Voll wahrlich des Zeus sind alle des Wandels&lt;br/&gt;
Weg' , und alle Versammlung der Welt ; voll jegliche Meerflut ,&lt;br/&gt;
Jeglicher Port ; ringsum ja des Zeus bedürfen wir alle .&lt;br/&gt;
'''Seines Geschlechts auch sind wir''' ; und Er , mildherzig den Menschen,&lt;br/&gt;
Zeichnet, was frommt, rechtsher ; und zu Tätigkeit weckt er die Völker,&lt;br/&gt;
Mahnend an Lebensbedarf : Er sagt , wann besser dem Pflugstier&lt;br/&gt;
Fuge die Scholl' , und dem Karst ; er sagt , wann schickliche Jahrszeit,&lt;br/&gt;
Dass man die Pflanze behäuf&quot; , und einsenk' allerlei Anwachs .&lt;br/&gt;
Denn selbst hat er die Zeichen am oberen '''Himmel''' befestigt ,&lt;br/&gt;
Und '''Sternbilder''' verteilt ; er hat fürsehend dem Jahrlauf&lt;br/&gt;
'''Sterne''' bestimmt , die den Menschen zumeist annahende Wechsel&lt;br/&gt;
Deuteten jeglicher Zeit , dass in Völligkeit alles erwachse .&lt;br/&gt;
Drum ihn immer zuerst , und zulezt ihn , sühnen sie feiernd.&lt;br/&gt;
Heil , anstaunlicher Vater , den Sterblichen mächtiges Labsal ,&lt;br/&gt;
Du auch , selbst des Geschlechts Ursprung ! Heil , freundliche Musen,&lt;br/&gt;
Heil euch allen gesamt ! doch mir , der , die '''Sterne''' zu melden ,&lt;br/&gt;
Euch , wie geziemt , anfleht , bringt allen Gesang zur Vollendung.&lt;br/&gt;
Jene zugleich , so viele zerstreuete , andere anders ,&lt;br/&gt;
Ziehn mit dem '''Himmel''' einher in ewigem Zuge beständig .&lt;br/&gt;
Doch nie schwanket er selbst um ein weniges; sondern durchaus so&lt;br/&gt;
Bleibt ihm die '''Axe''' geheftet ; die hält gleichschwebend vom Umfang&lt;br/&gt;
Hier '''in der Mitte die Erd'''' , und umher dort dreht sie den '''Himmel''' .&lt;br/&gt;
Sie dann hat zween '''Pol'''' an jeglichem Ende gerichtet :&lt;br/&gt;
Unsichtbar ist jener; doch hier um den '''Boreas''' ragt er&lt;br/&gt;
Ob dem Okeanos hoch. Zwo dem zu den Seiten gestellte&lt;br/&gt;
'''Bärinnen''' rollen umher: drum auch '''Rollwagen''' benamet.
&lt;/blockquote&gt;

'''''Hinweise:'''''
* Die &quot;Axe&quot; beschreibt die Erdachse.
* ''Mit dem &quot;Boreas&quot; ist der Himmelsnordpol gemeint.''
* ''Bei den beiden Bärinnen handelt es sich um die Sternbilder des Großen Bären (Ursa Maior) und des Kleinen Bären (Ursa Minor).''
* ''Die beiden Rollwagen sind bei uns heute die Asterismen Großer Wagen und Kleiner Wagen.''

Der Apostel '''{{w|Paulus von Tarsus}}''' (geboren vor 10, gestorben nach 60) war der bedeutendste Missionar des Urchristentums und kannte diesen Text offensichtlich. Im 17.&amp;nbsp;Kapitel der Apostelgeschichte des Lukas wird ihm ein Zitat aus dem Prolog des Lehrgedichts über die Abstammung der Menschen von Gott in den Mund gelegt.&lt;ref&gt;[https://www.die-bibel.de/bibel/NA28,EUE/ACT.17.28 Apostelgeschichte 17,28], Abschnitt: ''Paulus in Athen'', Novum Testamentum Graece und Einheitsübersetzung&lt;/ref&gt;

&lt;blockquote&gt;
Apostelgeschichte 17,28: '''Τοῦ γὰρ καὶ γένος ἐσμέν.'''
&lt;/blockquote&gt;

&lt;blockquote&gt;
Apostelgeschichte 17,28: '''Wir sind von seinem Geschlecht.'''
&lt;/blockquote&gt;

=== Zahlen in Religionen ===
Die '''Zwei''' steht oft für Gegensätze, wie zum Beispiel Tag und Nacht, Aufgang und Untergang, Sommerhalbjahr und Winterhalbjahr, zunehmender und abnehmender Mond oder obere und untere Kulmination. Eine solche Zweiteilung findet sich oft auch in gegensätzliche Kategorien wieder, die in vielen Disziplinen, insbesondere auch in der Ethik und in Religionen verwendet werden, wie beispielsweise gut und böse, oben und unten, Leben und Tod, Licht und Schatten, Wärme und Kälte oder Himmel und Hölle.

Interessant ist auch die frühgeschichtliche astronomische Auffassung von '''zwei''' mächtigen Gegenspielern, die sich im Sternenhimmel an zwei gegenüberliegenden Seiten befinden, der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|der Himmelsstier]] und der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsskorpion|der Himmelsskorpion]].

→ Siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwei|'''Zur Zwei''']].

Die astronomischen Zahlen '''Sieben''' und '''Zwölf''' werden als heilige Zahlen angesehen. Sie werden in vielfältigen Kontexten in religiösen Texten erwähnt und für viele religiöse Symbole verwendet. Ferner spielt auch die astronomische Zahl '''Vier''' in Religionen eine bedeutende Rolle, wo sie deswegen manchmal ebenfalls als heilige Zahlen angesehen wird:

* '''Vier''' Hauptsterne respektive Hauptsternbilder mit den '''vier''' Himmelsrichtungen und den '''vier''' Jahreszeiten: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Vier_in_Religionen|'''Bedeutung der Vier in Religionen''']].
* '''Sieben''' Wandelgestirne mit den die '''sieben''' Tagen einer Woche beziehungsweise eines Mondviertels: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Sieben_in_Religionen|'''Bedeutung der Sieben in Religionen''']].
* '''Zwölf''' Ekliptiksternbilder, '''zwölf''' Monate pro Jahr, '''zwölf''' Jahre Umlaufzeit des Planeten Jupiter, jeweils '''zwölf''' Stunden Tag und Nacht: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Zwölf_in_Religionen|'''Bedeutung der Zwölf in Religionen''']].

=== Altes Testament ===
In der Bibel wird in der Regel nicht zwischen Fixsternen und Planeten unterschieden. Eine Ausnahme gibt es im 2.&amp;nbsp;Buch der Könige, Kapitel&amp;nbsp;23, Vers&amp;nbsp;5 aus dem siebenten vorchristlichen Jahrhundert, wo in der deutschsprachigen Einheitsübersetzung von &quot;den Wandelsternen&quot; und in der Luther-Bibel von &quot;den Planeten&quot; die Rede ist. Die Vulgata schreibt hier allerdings von den &quot;duodecim signis&quot;, womit sicherlich die zwölf Sternzeichen der Ekliptik gemeint sind, durch die die sieben Wandelgestirne ziehen. Die Septuaginta spricht noch allgemeiner von den &quot;μαζουρωθ&quot; nach dem Hebräischen Wort &quot;מַזָּלָה&quot; (&quot;mazzaroth&quot;), womit vermutlich Sternkonstellationen und im engeren Sinne ebenfalls die zwölf Sternzeichen des Zodiaks gemeint sind:

&lt;blockquote&gt;
'''Septuaginta '''&lt;br/&gt;
5 καὶ κατέπαυσεν τοὺς χωμαριμ, οὓς ἔδωκαν βασιλεῖς Ιουδα καὶ ἐθυμίων ἐν τοῖς ὑψηλοῖς καὶ ἐν ταῖς πόλεσιν Ιουδα καὶ τοῖς περικύκλῳ Ιερουσαλημ, καὶ τοὺς θυμιῶντας τῷ Βααλ καὶ τῷ ἡλίῳ καὶ τῇ σελήνῃ καὶ τοῖς '''μαζουρωθ''' καὶ πάσῃ τῇ δυνάμει τοῦ οὐρανοῦ.&lt;br/&gt;
&lt;br/&gt;
'''Vulgata'''&lt;br/&gt;
5 Et delevit aedituos, quos posuerant reges Iudae ad sacrificandum in excelsis per civitates Iudae et in circuitu Ierusalem, et eos, qui adolebant Baal et soli et lunae et '''duodecim signis''' et omni militiae caeli.&lt;br/&gt;
&lt;br/&gt;
'''Einheitsübersetzung (2016)'''&lt;br/&gt;
5 Auch setzte er die Götzenpriester ab, die von den Königen von Juda bestellt worden waren und die auf den Kulthöhen, in den Städten Judas und in der Umgebung Jerusalems Opfer verbrannt sowie dem Baal, der Sonne, dem Mond, den '''Wandelsternen''' und dem ganzen Heer des Himmels geopfert hatten.&lt;br/&gt;
&lt;br/&gt;
'''Luther-Bibel (2017)'''&lt;br/&gt;
5 Und er setzte die Götzenpriester ab, die die Könige von Juda eingesetzt hatten, um auf den Höhen zu opfern in den Städten Judas und um Jerusalem her; auch die dem Baal geräuchert hatten, der Sonne und dem Mond und den '''Planeten''' und allem Heer am Himmel.&lt;br/&gt;
&lt;/blockquote&gt;

Der Prophet Habakuk erwähnt in seinem Psalm in Kapitel&amp;nbsp;3 aus dem siebenten vorchristlichen Jahrhundert das Konzept der Aufteilung der Ekliptik in Mondstationen respektive in Mondhäuser:

&lt;blockquote&gt;
10 Wenn sie dich sehen, erbeben die Berge,&lt;br/&gt;
das Tosen der Wasser rauscht vorüber; es erhebt die Urflut ihre Stimme,&lt;br/&gt;
hoch oben vergisst die Sonne ihre Strahlen.&lt;br/&gt;
11 '''Der Mond bleibt in der Behausung;'''&lt;br/&gt;
als Beleuchtung schwirren deine Pfeile,&lt;br/&gt;
als heller Schein das Blitzen deiner Lanze.
&lt;/blockquote&gt;

In den folgenden Bibelstellen aus dem Alten Testament spiegeln sich astronomische Vorstellungen in Bezug auf Gott wider:

'''Genesis 1:'''
&lt;blockquote&gt;
1 Im Anfang erschuf Gott '''Himmel''' und Erde.&lt;br/&gt;
2 Die '''Erde''' war wüst und wirr und '''Finsternis''' lag über der '''Urflut''' und Gottes Geist schwebte über dem '''Wasser'''.&lt;br/&gt;
3 Gott sprach: Es werde '''Licht'''. Und es wurde '''Licht'''.
...&lt;br/&gt;
5 Und Gott nannte das Licht '''Tag''' und die Finsternis nannte er '''Nacht'''. Es wurde '''Abend''' und es wurde '''Morgen''': erster Tag.&lt;br/&gt;
...&lt;br/&gt;
14 Dann sprach Gott: Lichter sollen am '''Himmelsgewölbe''' sein, um '''Tag''' und '''Nacht''' zu scheiden. Sie sollen als Zeichen für '''Festzeiten''', für '''Tage''' und '''Jahre''' dienen.&lt;br/&gt;
15 Sie sollen Lichter am Himmelsgewölbe sein, um über die Erde hin zu leuchten. Und so geschah es.&lt;br/&gt;
16 Gott machte '''die beiden großen Lichter''', das große zur Herrschaft über den '''Tag''', das kleine zur Herrschaft über die '''Nacht''', und die '''Sterne'''.
&lt;/blockquote&gt;

'''Psalm 8:'''
&lt;blockquote&gt;
4 Seh ich deine '''Himmel''', die Werke deiner Finger, '''Mond '''und '''Sterne''', die du befestigt.
&lt;/blockquote&gt;

[[Datei:Johannes.Kepler.Coeli.enarrant.gloriam.Dei.png|mini|rechts|Portrait des jungen Johannes Keplers mit dem Motto &quot;Coeli enarrant gloriam Dei.&quot; nach Psalm 19: &quot;Die Himmel erzählen die Herrlichkeit Gottes.&quot;]]

'''Psalm 19:'''
&lt;blockquote&gt;
2 Die '''Himmel''' erzählen die Herrlichkeit Gottes und das '''Firmament''' kündet das Werk seiner Hände.
&lt;/blockquote&gt;

'''Psalm 90:'''
&lt;blockquote&gt;
2 Ehe geboren wurden die Berge, ehe du unter Wehen hervorbrachtest '''Erde''' und '''Erdkreis''', bist du Gott von Ewigkeit zu Ewigkeit.
&lt;/blockquote&gt;

'''Psalm 102:'''
&lt;blockquote&gt;
26 Vorzeiten hast du der Erde Grund gelegt, die '''Himmel''' sind das Werk deiner Hände.
&lt;/blockquote&gt;

'''Psalm 103:'''
&lt;blockquote&gt;
19 Der HERR hat seinen Thron errichtet im '''Himmel''', seine königliche Macht beherrscht '''das All'''.
&lt;/blockquote&gt;

'''Psalm 104:'''
&lt;blockquote&gt;
19 Du machst den '''Mond''' zum Maß für die Zeiten, die '''Sonne''' weiß, wann sie untergeht.
&lt;/blockquote&gt;

'''Psalm 113:'''
&lt;blockquote&gt;
3 Vom '''Aufgang der Sonne''' bis zu ihrem '''Untergang''' sei gelobt der Name des HERRN.&lt;br/&gt;
4 Erhaben ist der HERR über alle Völker, über den '''Himmeln''' ist seine Herrlichkeit.
&lt;/blockquote&gt;

'''Psalm 136:'''
&lt;blockquote&gt;
3 Dankt dem Herrn der Herren, denn seine Huld währt ewig!&lt;br/&gt;
4 Ihm, der allein große Wunder tut, denn seine Huld währt ewig,&lt;br/&gt;
5 der den '''Himmel''' gemacht hat in Weisheit, denn seine Huld währt ewig,&lt;br/&gt;
6 der die Erde gefestigt hat über den Wassern, denn seine Huld währt ewig,&lt;br/&gt;
7 der '''die großen Leuchten''' gemacht hat, denn seine Huld währt ewig,&lt;br/&gt;
8 die '''Sonne''' zur Herrschaft über den '''Tag''', denn seine Huld währt ewig,&lt;br/&gt;
9 den '''Mond''' und die '''Sterne''' zur Herrschaft über die '''Nacht''', denn seine Huld währt ewig.
&lt;/blockquote&gt;

'''Psalm 147:'''
&lt;blockquote&gt;
4 Er bestimmt die Zahl der '''Sterne''' und ruft sie alle mit Namen.
&lt;/blockquote&gt;

'''Psalm 148:'''
&lt;blockquote&gt;
'''Lobpreis auf den Herrn, den König des Kosmos'''&lt;br/&gt;
1 Halleluja! Lobt den HERRN vom '''Himmel''' her, lobt ihn in den Höhen:&lt;br/&gt;
2 Lobt ihn, all seine Engel, lobt ihn, all seine Heerscharen,&lt;br/&gt;
3 lobt ihn, '''Sonne''' und '''Mond''', lobt ihn, all ihr leuchtenden '''Sterne''',&lt;br/&gt;
4 lobt ihn, ihr '''Himmel der Himmel''', ihr Wasser über dem '''Himmel'''!
&lt;/blockquote&gt;

Mit den &quot;Wassern über dem Himmel&quot; können nicht die Wolken unterhalb der Sternensphäre gemeint sein. Vielmehr dürfte es sich um eine Anspielung auf den Urozean beziehungsweise die Urflut handeln (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Urozean''']]). Diese Urflut existierte bereits vor der Erschaffung des Lichts und der Gestirne. Man erinnere sich an den Beginn der Schöpfungsgeschichte in den ersten drei Versen der Bibel (siehe oben).

'''Buch der Weisheit (Weisheit Salomos):'''
&lt;blockquote&gt;
'''Salomos Gebet um Weisheit'''&lt;br/&gt;
9,1 Gott der Väter und Herr des Erbarmens, du hast '''das All''' durch dein Wort gemacht.
&lt;/blockquote&gt;

'''Jesus Sirach 42:'''
&lt;blockquote&gt;
'''Lob Gottes in der Schöpfung'''&lt;br/&gt;
15 Nun will ich der Werke des Herrn gedenken, und was ich gesehen habe, werde ich erzählen: Durch die Worte des Herrn sind seine Werke und durch seinen Segen gab er ihnen ihre Bestimmung.&lt;br/&gt;
16 Die leuchtende '''Sonne''' blickt auf alles hernieder und von der Herrlichkeit des Herrn ist sein Werk erfüllt.&lt;br/&gt;
17 Der Herr gab es selbst den Heiligen nicht, all seine Wunder zu erzählen, der Herr der Herrscher über '''das All''', hat sie gegründet, sodass '''das All''' in seiner Herrlichkeit Bestand hat.&lt;br/&gt;
18 Abgrund und Herz hat er durchforscht und ihre Absichten hat er durchschaut; denn der Höchste kennt alles Wissen und er blickt auf die '''Zeichen der Zeiten'''.&lt;br/&gt;
19 Er tut das Vergangene und das Kommende kund und enthüllt die Spuren des Verborgenen.&lt;br/&gt;
20 Kein Gedanke entgeht ihm und kein einziges Wort bleibt ihm verborgen.&lt;br/&gt;
21 Die Großtaten seiner Weisheit hat er geordnet; wie er ist '''von Ewigkeit und in Ewigkeit'''. Ihm ist weder etwas hinzugefügt noch weggenommen worden und er hat keines Ratgebers bedurft.
&lt;/blockquote&gt;

Auch im nachfolgenden Kapitel lobt Jesus Sirach die Sonne, den Mond und die Sterne in den höchsten Tönen:

'''Jesus Sirach 43:'''
&lt;blockquote&gt;
1 Der Stolz der Höhe ist ein '''Firmament''' von Reinheit, die Gestalt des '''Himmels''' beim Anblick der Herrlichkeit.&lt;br/&gt;
2 Die '''Sonne''' verkündet durch ihr Erscheinen beim Aufgang, ein wunderbares Geschöpf, ein Werk des Höchsten!&lt;br/&gt;
3 Zur '''Mittagszeit''' trocknet sie den Boden aus, wer wird bestehen vor ihrer Glut?&lt;br/&gt;
4 Wer in einen Ofen bläst bei Arbeiten mit Glut - dreimal so stark versengt die '''Sonne''' Berge; sie atmet Feuerdämpfe aus und blendet mit gleißenden Strahlen die Augen.&lt;br/&gt;
5 Groß ist der Herr, der sie gemacht hat, mit seinen Worten beschleunigt er ihren Lauf.&lt;br/&gt;
6 Auch der '''Mond''' hält sich in allem an seinen Zeitpunkt, zur '''Festsetzung der Zeiten''' und als Zeichen auf Dauer.&lt;br/&gt;
7 Vom '''Mond''' geht das Zeichen für einen Festtag aus, ein Gestirn, das abnimmt bis zur Vollendung.&lt;br/&gt;
8 Der Name '''Monat''' kommt vom '''Neumond''', der wunderbar zunimmt beim Wechsel, ein Geschöpf des Heeres in der Höhe, das am '''Himmelsgewölbe''' leuchtet.&lt;br/&gt;
9 Die Schönheit des '''Himmels''' ist der Glanz der '''Sterne''', ein strahlender Schmuck in den Höhen des Herrn.&lt;br/&gt;
10 Durch die Worte des Heiligen stehen sie gemäß ihrer Bestimmung und sie ermüden nie bei ihrer Wache.&lt;br/&gt;
...&lt;br/&gt;
27 Vieles werden wir sagen, aber wir kommen nie an ein Ziel und das Ende der Worte ist: Er ist '''das All'''.
&lt;/blockquote&gt;

'''Jesaja 40:'''
&lt;blockquote&gt;
26 Hebt eure Augen in die Höhe und seht: Wer hat diese '''Gestirne''' erschaffen?&lt;br/&gt;
Der vollzählig herausführt ihr Heer, er ruft sie alle beim Namen.&lt;br/&gt;
Wegen seiner Fülle an Kraft und mächtiger Stärke fehlt kein einziges.
&lt;/blockquote&gt;

Das Buch Baruch gehört zu den späten Schriften des Alten Testaments. Im dritten Kapitel werden das Licht und die Sterne in Bezug auf Gott thematisiert:

'''Baruch 3:'''
&lt;blockquote&gt;
33 Er entsendet das '''Licht''' und es eilt dahin; er ruft es zurück und zitternd gehorcht es ihm.&lt;br/&gt;
34 Froh leuchten die '''Sterne''' auf ihren Posten.&lt;br/&gt;
35 Ruft er sie, so antworten sie: Hier sind wir. Sie leuchten mit Freude für ihren Schöpfer.&lt;br/&gt;
36 Das ist unser Gott; kein anderer gilt neben ihm.
&lt;/blockquote&gt;

Ein Lobpreis auf die Werke, Engel und Mächte Gottes am Gewölbe des Himmels findet sich im '''Buch Daniel''' im dritten Kapitel. Der Text macht inhaltlich eine ähnliche Aussage wie der Lobpreis auf den Herrn, den König des Kosmos in Psalm 148 (siehe oben):

'''Daniel 3:'''
&lt;blockquote&gt;
56 Gepriesen bist du am Gewölbe des '''Himmels''', gerühmt und verherrlicht in Ewigkeit.&lt;br/&gt;
57 Preist den HERRN, all ihr Werke des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
58 Preist den HERRN, ihr '''Himmel'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
59 Preist den HERRN, ihr Engel des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
60 Preist den HERRN, all ihr '''Wasser über dem Himmel'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
61 Preist den HERRN, all ihr Mächte des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
62 Preist den HERRN, '''Sonne und Mond'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
63 Preist den HERRN, ihr '''Sterne am Himmel'''; lobt und rühmt ihn in Ewigkeit!
&lt;/blockquote&gt;

=== Der Himmelsthron ===
Der '''Himmelsthron''' wir in vielen Texten des Alten Testaments als der Sitz Gottes genannt. Hier zunächst einige Erwähnungen in den Psalmen:

&lt;blockquote&gt;
11,4 Der HERR ist in seinem heiligen Tempel, der HERR hat seinen '''Thron im Himmel'''.&lt;br/&gt;
Seine Augen schauen herab, seine Blicke prüfen die Menschen.
&lt;/blockquote&gt;

&lt;blockquote&gt;
33,13 Der HERR blickt herab vom '''Himmel''', er sieht alle Menschen.&lt;br/&gt;
33,14 Von seinem '''Thronsitz''' schaut er nieder auf alle Bewohner der Erde.
&lt;/blockquote&gt;

&lt;blockquote&gt;
89,37 Sein Haus soll bleiben auf ewig, sein '''Thron''' habe Bestand vor mir wie die '''Sonne''';
&lt;/blockquote&gt;

&lt;blockquote&gt;
103,19 Der HERR hat seinen '''Thron''' errichtet im '''Himmel''', seine königliche Macht beherrscht '''das All'''.
&lt;/blockquote&gt;

Im Buch der Weisheit stehen die folgenden beiden Verse:

&lt;blockquote&gt;
9,9 Mit dir ist die Weisheit, die deine Werke kennt und die zugegen war, als du die Welt erschufst. Sie weiß, was wohlgefällig ist in deinen Augen und was recht ist nach deinen Geboten.&lt;br/&gt;
9,10 Sende sie vom heiligen '''Himmel''' und schick sie vom '''Thron''' deiner Herrlichkeit, damit sie bei mir sei und alle Mühe mit mir teile und ich erkenne, was wohlgefällig ist bei dir!
&lt;/blockquote&gt;

Diese Bild von Gottes Thron im Himmel wir auch im Neuen Testament aufgegriffen, wie beispielsweise beim Evangelisten Matthäus (Kapitel 5, Vers 34) oder in der Offenbarung des Johannes, wo im vierten Kapitel die eröffnende Himmelsvision mit dem Abschnitt über &quot;Die Huldigung vor dem Thron Gottes&quot; beginnt:

&lt;blockquote&gt;
1 Danach sah ich und siehe, eine Tür war geöffnet am '''Himmel'''; und die erste Stimme, die ich gleich einer Posaune mit mir reden gehört hatte, sagte: Komm herauf und ich werde dir zeigen, was dann geschehen muss.&lt;br/&gt;
2 Sogleich wurde ich vom Geist ergriffen. Und siehe, '''ein Thron stand im Himmel'''; auf dem Thron saß einer,&lt;br/&gt;
3 der wie ein Jaspis und ein Karneol aussah. Und über dem '''Thron''' wölbte sich ein Regenbogen, der wie ein Smaragd aussah.&lt;br/&gt;
4 Und rings um den '''Thron standen vierundzwanzig Throne''' und auf den Thronen saßen vierundzwanzig Älteste, in weiße Gewänder gekleidet und mit goldenen Kränzen auf dem Haupt.&lt;br/&gt;
5 Von dem Thron gingen Blitze, Stimmen und Donner aus. Und '''sieben lodernde Fackeln brannten vor dem Thron; das sind die sieben Geister Gottes'''.&lt;br/&gt;
6 Und vor dem Thron war etwas wie ein gläsernes Meer, gleich Kristall. Und in der Mitte des Thrones und rings um den Thron waren '''vier Lebewesen''' voller Augen, vorn und hinten.&lt;br/&gt;
7 Das erste Lebewesen glich einem '''Löwen''', das zweite einem '''Stier''', das dritte sah aus wie ein '''Mensch''', das vierte glich einem '''fliegenden Adler'''.&lt;br/&gt;
&lt;/blockquote&gt;

Der achtstrophige Adventshymnus ''Veni redemptor gentium'' (die deutschsprachige Kontrafaktur heißt &quot;Nun komm, der Heiden Heiland&quot;) wird dem Kirchenvater Ambrosius von Mailand (339–397) zugeschrieben. In der fünften Strophe wird mit Bezug auf die Himmelfahrt des Messias der Sitz Gottes erwähnt:

&lt;blockquote&gt;
5,1 Egressus eius a Patre,&lt;br/&gt;
5,2 Regressus eius ad Patrem;&lt;br/&gt;
5,3 Excursus usque ad inferos,&lt;br/&gt;
5,4 Recursus ad '''sedem Dei'''.
&lt;/blockquote&gt;

&lt;blockquote&gt;
5,1 Sein Ausgang ist vom Vater,&lt;br/&gt;
5,2 Seine Rückkehr ist beim Vater;&lt;br/&gt;
5,3 Hinausgelaufen bis zu den Toten,&lt;br/&gt;
5,4 Zurückgelaufen bis zum '''Sitz Gottes'''.
&lt;/blockquote&gt;

Es ist nicht viel Phantasie erforderlich, um den Thron Gottes im '''Himmelsstier''' wiederzuerkennen. Die vierundzwanzig Throne, die sich entlang der '''Ekliptik''' um diesen Thron herum aufreihen, stehen für die vierundzwanzig Stunden eines Tages, und sie sind je zwei für jedes der zwölf Lebewesenkreiszeichen des '''Zodiaks'''. Die als sieben lodernde Fackeln vor dem Thron sind die sieben '''Wandelgestirne''', die als die '''sieben Geister Gottes''' immer wieder durch das '''Goldene Tor der Ekliptik''' in der Sitzfläche des Thrones ziehen. Die '''vier besonderen Lebewesen''' sind die vier Evangelistensymbole bei den vier zoroastrischen '''Königssternen'''.

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|'''Himmelsstier''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Die_Ekliptik|'''Ekliptik''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|'''Zodiak''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|'''Goldenes Tor der Ekliptik''']].

→ Siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Vier_in_Religionen|'''Bedeutung der Vier in Religionen''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Königssterne|'''Königssterne''']].

&lt;gallery caption=&quot;Throne&quot; widths=640 heights=480 perrow=2&gt;
Aachen_Cathedral_Karlsthron_02.jpg|Thron Karls des Großen aus den 790er Jahren im Aachener Dom.
Himmelsthron.Taurus.Aries.png|Himmelsthron in den Sternbildern Stier (Taurus) und Widder (Aries) vor dem Untergang in Richtung Westen.
&lt;/gallery&gt;

=== Das Lamm ===
Im ersten Kapitel des Evangeliums nach Johannes wird Jesus von Nazareth explizit als &quot;Lamm Gottes&quot; bezeichnet:&lt;ref&gt;[https://www.bibleserver.com/EU/Johannes1%2C29 Johannes 1,29], bibleserver.com, Einheitsübersetzung (2016)&lt;/ref&gt;

&lt;blockquote&gt;
29b Seht, das '''Lamm Gottes''', das die Sünde der Welt hinwegnimmt!&lt;br/&gt;
...&lt;br/&gt;
36b Seht, das '''Lamm Gottes'''!
&lt;/blockquote&gt;

Es handelt sich beim „Lamm Gottes“ (Kirchenlatein: „Agnus Dei“) um ein seit ältester Zeit verbreitetes Symbol für Jesus Christus. Es wird auch als das Osterlamm bezeichnet, das am Ostertag, also kurz nach der Tag-und-Nacht-Gleiche im Frühjahr auferstanden ist. Nach dem Evangelisten Markus wurde die Auferstehung „... am ersten Tag der Woche, früh am Morgen, als eben die Sonne aufging“, also am Ostersonntag während der Morgenröte im Osten entdeckt.&lt;ref&gt;[https://www.bibleserver.com/LUT/Markus16%2C2 Markus 16,2], Einheitsübersetzung, 2016&lt;/ref&gt; Am 40.&amp;nbsp;Tag ist Jesus Christus nach dem Zeugnis der Evangelisten Markus und Lukas in den Himmel aufgefahren. Zu Beginn der Apostelgeschichte wird dieses Ereignis folgendermaßen beschrieben:&lt;ref&gt;[https://www.bibleserver.com/EU/Apostelgeschichte1 Apostelgeschichte 1], Einheitsübersetzung, 2016&lt;/ref&gt;

&lt;blockquote&gt;
7 Er sagte zu ihnen: Euch steht es nicht zu, Zeiten und Fristen zu erfahren, die der Vater in seiner Macht festgesetzt hat.&lt;br/&gt;
8 Aber ihr werdet Kraft empfangen, wenn der Heilige Geist auf euch herabkommen wird; und ihr werdet meine Zeugen sein in Jerusalem und in ganz Judäa und Samarien und bis an die Grenzen der Erde.&lt;br/&gt;
9 Als er das gesagt hatte, wurde er vor ihren Augen emporgehoben und eine Wolke nahm ihn auf und entzog ihn ihren Blicken.&lt;br/&gt;
&lt;/blockquote&gt;

Im altrömischen Glaubensbekenntnis gibt es die Textstelle:

&lt;blockquote&gt;
„ascendit in caelis, sedet ad dexteram Patris“
&lt;/blockquote&gt;

Zu Deutsch:

&lt;blockquote&gt;
„aufgefahren in den Himmel, er sitzt zur Rechten des Vaters“
&lt;/blockquote&gt;

Das '''Lamm''' (astronomisch Widder) befindet sich am nördlichen Sternenhimmel '''zur Rechten''' des Stieres (Taurus). Sowohl der mesopotamische Himmelsstier als auch das altarabische Sternbild Thuraya verbinden diese beiden neuzeitlichen Sternbilder zu einer Einheit. Der Hauptstern im Sternbild Widder (Aries) heißt Hamal, und das arabische Wort &quot;hamal&quot; steht für ein einjähriges Lamm.&lt;ref name=&quot;Adams&quot;&gt;Danielle Adams: [http://onesky.arizona.edu/arab-star-names/the-lamb/ The Lamb – A folkloric celestial complex], Two Deserts, one Sky – Arab Star Calendars&lt;/ref&gt; Der fette Schwanz des Lammes wird durch die '''Plejaden (Siebengestirn)''' markiert.&lt;ref name=&quot;Adams&quot; /&gt; Die Augen des Stieres sind die Sterne '''Aldebaran''' und '''Ain'''. Zwischen dem Kopf des Stieres und den '''Plejaden''' befindet sich das '''Goldene Tor der Ekliptik''', durch das alle Wandelgestirne regelmäßig hindurchziehen.

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Bibelstellen|'''Bibelstellen zum Siebengestirn''']].

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|'''Goldenes Tor der Ekliptik''']].

Der Frühlingspunkt der Sonne, also deren Ort auf der Ekliptiklinie zur Tag-und-Nacht-Gleiche im Frühjahr, ist von der monotheistischen Schöpfung bis zur Geburt des christlichen Gottessohns vom Kopf des Stiers (bei den Sternen '''Aldebaran''' und '''Ain''' im Goldenen Tor der Ekliptik) im heutigen Sternbild Stier (Taurus) bis zum Kopf des Lammes (beim Stern '''Hamal''') im heutigen Sternbild Widder (Aries) nach Westen gewandert. Heute befindet sich der Frühlingspunkt bereits am westlichen Ende des Sternbilds Fische (Pisces), das sich westlich an das Sternbild Widder anschließt.

==== Offenbarung des Johannes ====
In der Offenbarung des Johannes heißt es im 7.&amp;nbsp;Kapitel:

&lt;blockquote&gt;
10b Die Rettung kommt von unserem '''Gott''', der auf dem '''Thron''' sitzt, und von dem '''Lamm'''.&lt;br/&gt;
17a Denn das Lamm in der Mitte vor dem Thron wird sie weiden und zu den Quellen führen, aus denen das '''Wasser des Lebens''' strömt.
&lt;/blockquote&gt;

Wird der '''Thron Gottes''' mit dem Himmelsstier identifiziert (siehe oben), dann sitzt das '''Lamm''' (Aries, Sternbild Widder) westlich und somit rechts vor diesem Thron. Im weiteren Verlauf der Ekliptik nach Westen befinden sich die zusammenhängenden '''Wassersternbilder''' des Urozeans, dem Urquell des Lebens. Es handelt ich um die heutigen Sternbilder Fluss Eridanus, Walfisch (Cetus), Fische (Pisces), Wassermann (Aquarius), Südlicher Fisch (Piscis Austrinus) und Delphin (Delphinus) sowie Steinbock (Capricornus, früher Ziegenfisch).

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Urozean''']].

&lt;gallery caption=&quot;Das Lamm zur Rechten des Stieres&quot; mode=packed widths=800 heights=600&gt;
Himmelsstier.P1117152.jpg|Astrophotographie vom Asterismus Himmelsstier
Himmelsstier.Sternbilder.P1117152.png|Beschriftete Astrophotographie vom Himmelsstier am winterlichen Abendhimmel in Richtung südlicher Meridian. Die Ekliptiklinie verläuft horizontal etwas unterhalb der Bildmitte.
Haende.der.Thuraya.Vollmond.Sterne.P1079912.jpg|Astrophotographie der Himmelsregion mit dem beduinischen Sternbild &quot;Hände der Thuraya&quot; (grüne durchgezogene Linien, Ekliptik rot gepunktete Linie) mit arabisch bezeichneten Sternen. Der Vollmond befindet sich zwischen den Sternbildern Taurus, Aries und Cetus.
Urozean.Wassersternbilder.png|Die zusammenhängenden Wassersternbilder des Urozeans am Sternenhimmel: Fluss Eridanus, Walfisch (Cetus), Fische (Pisces), Wassermann (Aquarius), Südlicher Fisch (Piscis Austrinus), Delphin (Delphinus) sowie Ziegenfisch (Steinbock, Capricornus).
&lt;/gallery&gt;

Interpretiert man das Sternbild &quot;Lamm&quot; (Widder / Aries) als Mittler auf dem ekliptischen Weg vom finsteren kosmischen Urozean im Westen (rechts) zum strahlenden majestätischen Sternbild Stier (Taurus) im Osten (links), ergeben auch andere Bibelstellen in Bezug auf den Sternenhimmel einen tiefen symbolischen Sinn, die in den folgenden Abschnitten aufgeführt sind.

==== Evangelium nach Johannes ====
Die Rede von Jesus an den Jünger Thomas aus dem 14.&amp;nbsp;Kapitel des Evangeliums nach Johannes ist in diesem Zusammenhang interessant:

&lt;blockquote&gt;
6 Jesus sagte zu ihm: Ich bin der Weg und die Wahrheit und das Leben; niemand kommt zum Vater außer durch mich.&lt;br/&gt;
7 Wenn ihr mich erkannt habt, werdet ihr auch meinen Vater erkennen. Schon jetzt kennt ihr ihn und habt ihn gesehen.
&lt;/blockquote&gt;

Alle Wandelgestirne bewegen sich entlang der Ekliptiklinie (Weg) durch das heutige Sternbild Widder (das altarabische Sternbild &quot;Lamm&quot;) im Westen zum [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der-Ekliptik|Goldenen Tor der Ekliptik]] nach Osten im großen Himmelsstier (Vater / Thron).

==== Evangelium nach Markus ====
Im Evangelium nach Markus heißt es:

&lt;blockquote&gt;
14,62 Jesus sagte: Ich bin es. Und ihr werdet den Menschensohn '''zur Rechten der Macht''' sitzen und mit den Wolken des '''Himmels''' kommen sehen.
&lt;/blockquote&gt;

&lt;blockquote&gt;
16,19 Nachdem Jesus, der Herr, dies zu ihnen gesagt hatte, wurde er in den '''Himmel''' aufgenommen und setzte sich '''zur Rechten Gottes'''.
&lt;/blockquote&gt;

==== Evangelium nach Lukas ====
Im Evangelium nach Lukas ist es folgendermaßen formuliert:

&lt;blockquote&gt;
22,69 Von nun an wird der Menschensohn '''zur Rechten der Macht Gottes''' sitzen.
&lt;/blockquote&gt;

==== Evangelium nach Matthäus ====
Auch im Evangelium nach Matthäus findet sich eine entsprechende Stelle:

&lt;blockquote&gt;
26,64 Jesus antwortete: Du hast es gesagt. Doch ich erkläre euch: Von nun an werdet ihr den Menschensohn '''zur Rechten der Macht''' sitzen und auf den Wolken des '''Himmels''' kommen sehen.
&lt;/blockquote&gt;

==== Brief an die Hebräer ====
Im Brief an die Hebräer, dessen Autor unbekannt ist, gibt es etliche entsprechende Stellen:

&lt;blockquote&gt;
'''Gottes Rede in seinem Sohn'''&lt;br/&gt;
1,3 er ist der Abglanz seiner Herrlichkeit und das Abbild seines Wesens; er trägt '''das All''' durch sein machtvolles Wort, hat die Reinigung von den Sünden bewirkt und sich dann '''zur Rechten der Majestät in der Höhe''' gesetzt;&lt;br/&gt;
1,10 Und: Du, Herr, hast vorzeiten der Erde Grund gelegt, die '''Himmel''' sind das Werk deiner Hände.&lt;br/&gt;
1,11 Sie werden vergehen, '''du aber bleibst'''; sie alle veralten wie ein Gewand;&lt;br/&gt;
1,12 du rollst sie zusammen wie einen Mantel und wie ein Gewand werden sie gewechselt. Du aber bleibst, der du bist, und '''deine Jahre enden nie'''.&lt;br/&gt;
1,13 Zu welchem Engel hat er jemals gesagt: Setze dich mir '''zur Rechten''' und ich lege dir deine Feinde als Schemel unter die Füße?
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Die Liturgie des neuen Bundes'''&lt;br/&gt;
8,1 Die Hauptsache bei dem Gesagten aber ist: Wir haben einen solchen Hohepriester, der sich '''zur Rechten des Thrones der Majestät im Himmel''' gesetzt hat,&lt;br/&gt;
8,2 als Diener des Heiligtums und des '''wahren Zeltes''', das der Herr selbst aufgeschlagen hat, nicht ein Mensch.
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Christus als Mittler des neuen Bundes'''&lt;br/&gt;
9,24 Denn Christus ist nicht in ein von Menschenhand gemachtes Heiligtum hineingegangen, in ein Abbild des wirklichen, sondern '''in den Himmel selbst''', um jetzt '''vor Gottes Angesicht''' zu erscheinen für uns;
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Das Opfer Jesu Christi als endgültige Versöhnung mit Gott'''&lt;br/&gt;
10,12 Dieser aber hat nur ein einziges Opfer für die Sünden dargebracht und sich dann '''für immer zur Rechten Gottes''' gesetzt;
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Das Beispiel Jesu Christi'''&lt;br/&gt;
12,2 und dabei auf Jesus blicken, den Urheber und Vollender des Glaubens; er hat angesichts der vor ihm liegenden Freude das Kreuz auf sich genommen, ohne auf die Schande zu achten, und sich '''zur Rechten von Gottes Thron''' gesetzt.
&lt;/blockquote&gt;

==== Erster Brief des Petrus ====
Der erste Brief des Petrus zählt zu den katholischen Briefen des Neuen Testaments. Dort heißt es im letzten Satz über Jesus Christus:

&lt;blockquote&gt;
22 der in den '''Himmel''' gegangen ist; dort ist er '''zur Rechten''' Gottes und Engel, Gewalten und Mächte sind ihm unterworfen.
&lt;/blockquote&gt;

==== Apostelgeschichte ====
Die Apostelgeschichte schließt an das Evangelium nach Lukas an und wird ebenfalls diesem zugeschrieben. Hier kommen der erste bekennende sowie erste berufene Apostel Petrus und der erste christliche Märtyrer Stephanus zu Wort:

&lt;blockquote&gt;
'''Die Pfingstpredigt des Petrus'''&lt;br/&gt;
2,33 '''Zur Rechten Gottes''' erhöht, hat er vom Vater den verheißenen Heiligen Geist empfangen und ihn ausgegossen, wie ihr seht und hört.
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Steinigung des Stephanus'''&lt;br/&gt;
7,55 Er aber, erfüllt vom Heiligen Geist, blickte zum '''Himmel''' empor, sah die Herrlichkeit Gottes und Jesus '''zur Rechten Gottes''' stehen&lt;br/&gt;
7,56 und rief: Siehe, ich sehe den Himmel offen und den Menschensohn '''zur Rechten Gottes''' stehen.
&lt;/blockquote&gt;

=== Himmelspforte ===
Das Sternbild Widder (Aries) repräsentiert als das Lamm Gottes den nördlichen Pfeiler des Goldenen Tors der Ekliptik. Der fette Schwanz des Lammes wird nach altarabischer Tradition durch das Siebengestirn (Plejaden) gebildet, das heute zu Sternbild '''Stier''' (Taurus) gezählt wird. Der südliche Pfeiler des Goldenen Tors der Ekliptik wird durch die Hyaden und den Stern Menkar im Sternbild Walfisch (Cetus) gebildet. Das Goldene Tor der Ekliptik stellt mit diesen beiden Pfeilern somit eine '''Himmelspforte''' dar, durch die alle Wandelgestirne regelmäßig von Westen aus dem dunklen Urozean der winterlichen Wassersternbilder sowie der Richtung des Sonnenuntergangs nach Osten in das helle Gebiet des Sternenhimmels mit den Frühlings- und Sommersternbildern sowie die Richtung des Sonnenaufgangs treten.

[[Datei:Mars.im.Goldenen.Tor.der.Ekliptik.P1091607.jpg|mini|hochkant=3|zentriert|Der am nordwestlichen Horizont in der Nähe der Ekliptiklinie und im Goldenen Tor der Ekliptik untergehende Mars (rote Scheibe unten halb rechts) drei Tage vor dem Durchqueren der '''Himmelspforte''' zwischen dem Kopf des Himmelsstieres mit dem Sternhaufen der Hyaden (unten links) und den Plejaden nördlich der Ekliptik (rechts unten).]]

Die Genesis berichtet im 28.&amp;nbsp;Kapitel unter der Überschrift &quot;Jakob in Bet-El&quot; (hebräisch בֵּית אֵל „Haus des El“ oder „Haus Gottes“) über einen Traum von Jakob, in dem er eine Treppe zum Himmel (die Himmelsleiter oder Jakobsleiter) sieht, an dessen oberen Ende sich das Tor des Himmels (die Himmelspforte) befindet:

&lt;blockquote&gt;
10 Jakob zog aus Beerscheba weg und ging nach Haran.&lt;br/&gt;
11 Er kam an einen bestimmten Ort und übernachtete dort, denn die Sonne war untergegangen. Er nahm einen von den Steinen dieses Ortes, legte ihn unter seinen Kopf und schlief dort ein.&lt;br/&gt;
12 Da hatte er einen Traum: Siehe, eine Treppe stand auf der Erde, ihre Spitze reichte bis zum '''Himmel'''. Und siehe: Auf ihr stiegen Engel Gottes auf und nieder.&lt;br/&gt;
13 Und siehe, der HERR stand vor ihm und sprach: Ich bin der HERR, der Gott deines Vaters Abraham und der Gott Isaaks. Das Land, auf dem du liegst, will ich dir und deinen Nachkommen geben.&lt;br/&gt;
14 Deine Nachkommen werden zahlreich sein wie der Staub auf der Erde. Du wirst dich '''nach Westen und Osten, nach Norden und Süden''' ausbreiten und durch dich und deine Nachkommen werden alle Sippen der Erde Segen erlangen.&lt;br/&gt;
15 Siehe, ich bin mit dir, ich behüte dich, wohin du auch gehst, und bringe dich zurück in dieses Land. Denn ich verlasse dich nicht, bis ich vollbringe, was ich dir versprochen habe.&lt;br/&gt;
16 Jakob erwachte aus seinem Schlaf und sagte: Wirklich, der HERR ist an diesem Ort und ich wusste es nicht.&lt;br/&gt;
17 Er fürchtete sich und sagte: Wie Ehrfurcht gebietend ist doch dieser Ort! Er ist nichts anderes als das Haus Gottes und das '''Tor des Himmels'''.&lt;br/&gt;
&lt;/blockquote&gt;

El war für die semitischen Ugariter im zweiten vorchristlichen Jahrtausend der Name ihres höchsten Gottes. Ihm wurden die Beinamen „König“, „Freundlicher“ und „'''Stier'''“ verliehen. Diese Symbolik weist auf den Himmelsstier hin. Der Name El wurde von den Israeliten übernommen, und dieser Gott wurde von ihnen mit ihrem einzigen Gott gleichgesetzt.

Jakob war der der erste der drei Erzväter des Volkes Israel und der älteste Sohn des ältesten Sohnes Isaak von Abraham. Abraham war aus dem mesopotamischen Ur über Haran nach Bet-El gezogen, und Jakob ging in dieser Schilderung aus Beerscheba in der Nähe des Ortes Bet-El nach Haran zurück.

Der Apostel Paulus schreibt in seinem zweiten Brief an die Bewohner der griechischen Hafenstadt Korinth zu Beginn des 5.&amp;nbsp;Kapitels mit der Überschrift &quot;Die Hoffnung des Apostels&quot; über das Gebäude hinter der Pforte zum Himmel:

&lt;blockquote&gt;
1 Wir wissen: Wenn unser irdisches Zelt abgebrochen wird, dann haben wir eine Wohnung von Gott, ein nicht von Menschenhand errichtetes '''ewiges Haus im Himmel'''.
&lt;/blockquote&gt;

=== Gedanken zur wundersamen Brotvermehrung ===
==== Evangelien ====
[[Datei:Face de chapiteau figurant la Multiplication des pains, choeur de l'église de Saint-Nectaire, Puy-de-Dôme.jpg|mini|rechts|hochkant=2|Jesus mit vier seiner Jünger mit fünf Broten und zwei Fischen an einem Säulenkapitell in der romanischen Wallfahrtskirche Saint Nectaire auf dem Mont Cornadore in Saint-Nectaire in Frankreich (Département Puy-de-Dôme in der Region Auvergne-Rhône-Alpes).]]

Die wundersame Speisung der mehreren Tausend mit wenigen Broten und Fischen wird in aller vier Evangelien der Bibel erwähnt. Das Ereignis fand auf einem Berg am Ufer des Sees von Galiläa (auch als &quot;See von Tiberias&quot;, &quot;See Genezareth&quot; oder &quot;Galiläisches Meer&quot; bekannt) statt. In der abgelegenen Gegend gab es damals sehr wenig künstliche Lichtquellen, so dass ein ungestörter Anblick des Sternenhimmels möglich war.

===== Evangelium nach Johannes =====
Im sechsten Kapitel des Evangeliums nach '''Johannes''' tauchen bei der Beschreibung der Brotvermehrung durch Jesus zum jüdischen Pessachfest neben einigen weiteren Symbolen mit astronomischer Deutungsmöglichkeit auch die expliziten Zahlen Zwei, Fünf und Zwölf auf:

&lt;blockquote&gt;
9 Hier ist ein kleiner Junge, der hat '''fünf Gerstenbrote''' und '''zwei Fische'''; doch was ist das für so viele?&lt;br/&gt;
10 Jesus sagte: Lasst die Leute sich setzen! Es gab dort nämlich viel Gras. Da setzten sie sich; es waren etwa '''fünftausend''' Männer.&lt;br/&gt;
11 Dann nahm Jesus die '''Brote''', sprach das Dankgebet und teilte an die Leute aus, so viel sie wollten; ebenso machte er es mit den '''Fischen'''.&lt;br/&gt;
12 Als die Menge satt geworden war, sagte er zu seinen Jüngern: Sammelt die übrig gebliebenen Brocken, damit nichts verdirbt!&lt;br/&gt;
13 Sie sammelten und füllten '''zwölf Körbe''' mit den Brocken, die von den '''fünf Gerstenbroten''' nach dem Essen übrig waren.&lt;br/&gt;
...&lt;br/&gt;
31 Unsere Väter haben das '''Manna''' in der Wüste gegessen, wie es in der Schrift heißt: '''Brot vom Himmel''' gab er ihnen zu essen.&lt;br/&gt;
32 Jesus sagte zu ihnen: Amen, amen, ich sage euch: Nicht Mose hat euch das '''Brot vom Himmel''' gegeben, sondern mein Vater gibt euch das wahre '''Brot vom Himmel'''.&lt;br/&gt;
33 Denn das '''Brot''', das Gott gibt, kommt vom '''Himmel''' herab und gibt der Welt das Leben.&lt;br/&gt;
34 Da baten sie ihn: Herr, gib uns immer dieses '''Brot'''!&lt;br/&gt;
35 Jesus antwortete ihnen: Ich bin das '''Brot des Lebens'''; wer zu mir kommt, wird nie mehr hungern, und wer an mich glaubt, wird nie mehr Durst haben.&lt;br/&gt;
...&lt;br/&gt;
48 Ich bin das '''Brot des Lebens'''.&lt;br/&gt;
49 Eure Väter haben in der Wüste das '''Manna''' gegessen und sind gestorben.&lt;br/&gt;
50 So aber ist es mit dem '''Brot''', das vom '''Himmel''' herabkommt: Wenn jemand davon isst, wird er nicht sterben.&lt;br/&gt;
51 Ich bin das '''lebendige Brot''', das vom '''Himmel''' herabgekommen ist. Wer von diesem '''Brot''' isst, wird in Ewigkeit leben. Das '''Brot''', das ich geben werde, ist mein Fleisch für das Leben der Welt.
&lt;/blockquote&gt;

===== Evangelium nach Markus =====
Eine ähnliche Schilderung befindet sich im sechsten Kapitel des Evangeliums nach '''Markus''', wo das Ereignis an einem abgelegenen und einsamen Ort stattgefunden hat:

&lt;blockquote&gt;
38 Er sagte zu ihnen: Wie viele '''Brote''' habt ihr? Geht und seht nach! Sie sahen nach und berichteten: '''Fünf Brote''' und außerdem '''zwei Fische'''.&lt;br/&gt;
39 Dann befahl er ihnen, sie sollten sich in Mahlgemeinschaften im grünen Gras lagern.&lt;br/&gt;
40 Und sie ließen sich in Gruppen zu hundert und zu fünfzig nieder.&lt;br/&gt;
41 Darauf nahm er die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis, brach die '''Brote''' und gab sie den Jüngern, damit sie diese an die Leute austeilten. Auch die '''zwei Fische''' ließ er unter allen verteilen.&lt;br/&gt;
42 Und alle aßen und wurden satt.&lt;br/&gt;
43 Und sie hoben Brocken auf, '''zwölf Körbe''' voll, und Reste von den '''Fischen'''.&lt;br/&gt;
44 Es waren '''fünftausend''' Männer, die von den '''Broten''' gegessen hatten.
&lt;/blockquote&gt;

Die Brotvermehrung auch ein weiteres Mal im achten Kapitel des Evangeliums nach '''Markus''' erwähnt:

&lt;blockquote&gt;
5 Er fragte sie: Wie viele '''Brote''' habt ihr? Sie antworteten: '''Sieben'''.&lt;br/&gt;
6 Da forderte er die Leute auf, sich auf den Boden zu setzen. Dann nahm er die sieben '''Brote''', sprach das Dankgebet, brach die '''Brote''' und gab sie seinen Jüngern zum Verteilen; und die Jünger teilten sie an die Leute aus.&lt;br/&gt;
7 Sie hatten auch noch ein paar '''Fische''' bei sich. Jesus segnete sie und ließ auch sie austeilen.&lt;br/&gt;
8 Die Leute aßen und wurden satt. Und sie hoben die Überreste der '''Brotstücke''' auf, '''sieben Körbe''' voll.&lt;br/&gt;
9 Es waren etwa '''viertausend''' Menschen beisammen. Danach schickte er sie nach Hause.&lt;br/&gt;
...&lt;br/&gt;
19 Als ich die '''fünf Brote''' für die '''Fünftausend''' brach, wie viele '''Körbe voll Brotstücke''' habt ihr da aufgehoben? Sie antworteten ihm: '''Zwölf'''.&lt;br/&gt;
20 Und als ich die '''sieben Brote''' für die '''Viertausend''' brach, wie viele '''Körbe''' voll habt ihr da aufgehoben? Sie antworteten: '''Sieben'''.&lt;br/&gt;
21 Da sagte er zu ihnen: Versteht ihr immer noch nicht?
&lt;/blockquote&gt;

===== Evangelium nach Lukas =====
Ebenso verhält es sich im neunten Kapitel des Evangeliums nach '''Lukas''', wo das Ereignis dem Ort Betsaida (zu Deutsch: „Haus des Fisches“) am See Genezareth zugeordnet ist:

&lt;blockquote&gt;
12 Als der Tag zur Neige ging, kamen '''die Zwölf''' und sagten zu ihm: Schick die Leute weg, damit sie in die umliegenden Dörfer und Gehöfte gehen, dort Unterkunft finden und etwas zu essen bekommen; denn wir sind hier an einem abgelegenen Ort.&lt;br/&gt;
13 Er antwortete ihnen: Gebt ihr ihnen zu essen! Sie sagten: Wir haben nicht mehr als '''fünf Brote''' und '''zwei Fische'''; wir müssten erst weggehen und für dieses ganze Volk etwas zu essen kaufen.&lt;br/&gt;
14 Es waren nämlich etwa '''fünftausend''' Männer. Er aber sagte zu seinen Jüngern: Lasst sie sich in Gruppen zu ungefähr fünfzig lagern!&lt;br/&gt;
15 Die Jünger taten so und veranlassten, dass sich alle lagerten.&lt;br/&gt;
16 Jesus aber nahm die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis und brach sie; dann gab er sie den Jüngern, damit sie diese an die Leute austeilten.&lt;br/&gt;
17 Und alle aßen und wurden satt. Als man die übrig gebliebenen Brotstücke einsammelte, waren es '''zwölf Körbe''' voll.
&lt;/blockquote&gt;

===== Evangelium nach Matthäus =====
Auch im vierzehnten Kapitel des Evangeliums nach '''Matthäus''' ist von einem abgelegenen Ort in einer einsamen Gegend die Rede:

&lt;blockquote&gt;
17 Sie sagten zu ihm: Wir haben nur '''fünf Brote''' und '''zwei Fische''' hier.&lt;br/&gt;
18 Er antwortete: Bringt sie mir her!&lt;br/&gt;
19 Dann ordnete er an, die Leute sollten sich ins Gras setzen. Und er nahm die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis, brach die Brote und gab sie den Jüngern; die Jünger aber gaben sie den Leuten&lt;br/&gt;
20 und alle aßen und wurden satt. Und sie sammelten die übrig gebliebenen Brotstücke ein, '''zwölf Körbe''' voll.&lt;br/&gt;
21 Es waren etwa '''fünftausend''' Männer, die gegessen hatten, dazu noch Frauen und Kinder.
&lt;/blockquote&gt;

Etwas abgewandelt taucht die Brotvermehrung mit '''sieben Körben''' auch im fünfzehnten Kapitel des Evangeliums nach '''Matthäus''' auf:

&lt;blockquote&gt;
34 Jesus sagte zu ihnen: Wie viele '''Brote''' habt ihr? Sie antworteten: '''Sieben''' - und ein paar '''Fische'''.&lt;br/&gt;
35 Da forderte er die Leute auf, sich auf den Boden zu setzen.&lt;br/&gt;
36 Und er nahm die '''sieben Brote''' und die '''Fische''', sprach das Dankgebet, brach sie und gab sie den Jüngern und die Jünger gaben sie den Menschen.&lt;br/&gt;
37 Und alle aßen und wurden satt. Und sie sammelten die übrig gebliebenen Stücke ein, '''sieben Körbe''' voll.&lt;br/&gt;
38 Es waren '''viertausend''' Männer, die gegessen hatten, dazu noch Frauen und Kinder.&lt;br/&gt;
39 Danach schickte er die Menge nach Hause, stieg ins Boot und fuhr in die Gegend von Magadan.
&lt;/blockquote&gt;

Der Ort Magadan ist möglicherweise mit dem heutigen Ort Migdal (aramäisch: Magdala) am westlichen Ufer des Sees Genezareth gleichzusetzen.

==== Astronomische Bezüge ====
[[Datei:Sternenhimmel.Pessach.25.3.23.png|mini|rechts|hochkant=2|Sternenhimmel am jüdischen Pessachfest im Jahr 25 nach Christus. Der Vollmond stand hoch über dem Horizont im Süden im Herbstpunkt beim Stern Spica (= &quot;Kornähre&quot;) im Sternbild Jungfrau (Virgo). Gleichzeitig befand sich die Sonne tief unter dem Horizont im Norden in der Nähe des Frühlingspunktes im Sternbild Fische (Pisces).]]
[[Datei:Dendera.09.Jungfrau.Loewe.jpg|mini|rechts|hochkant=2|Das Sternbild Jungfrau (links) mit der Kornähre in der Hand und das Sternbild Löwe (rechts) im ägyptischen Zodiak von Dendera aus der Zeit kurz vor Christi Geburt.]]
[[Datei:Dendera.03.Fische.Wassermann.jpg|mini|rechts|hochkant=2|Das Sternbild Fische (links) und das Sternbild Wassermann (rechts unten) im ägyptischen Zodiak von Dendera aus der Zeit kurz vor Christi Geburt.]]

Zu diesen Bibelstellen sind im Folgenden einige Hinweise mit astronomischen Bezügen aufgeführt. Die [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|Bezugspunkte]] liegen hierbei in der Nähe der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Die_Ekliptik|Ekliptik]]:

* In den Versen im Evangelium nach Johannes ist mehrfach vom '''Brot, das vom Himmel herabkommt''' die Rede.
* Das zur Herstellung von Brot erforderliche Getreide kann durch eine '''Kornähre''' symbolisiert werden. Am Sternenhimmel wird die Kornähre durch den hellen, ekliptiknahen Stern '''Spica''' (α Virginis) im Sternbild '''Jungfrau''' (Virgo) repräsentiert. Der Vollmond stand zum jüdischen Pessachfest beim Stern Spica.
* Alle Pflanzen benötigen für das Gedeihen '''Wasser'''. Das '''Wasser''' wird am Himmel durch die drei Wassersternbilder der Ekliptik '''Fische''' (Pisces), '''Wassermann''' (Aquarius), und '''Ziegenfisch''' (Steinbock, Capricornus) westlich des [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Frühlingspunkt|Frühlingspunktes]] repräsentiert. Diese Sternbilder bilden mit einigen weiteren angrenzenden Wassersternbildern den [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|Urozean am Himmel]] (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Trichter_der_Thuraya|Der Trichter der Thuraya]]). Die Wassersternbilder waren zum Pessachfest in den drei Monaten unmittelbar zuvor von der Sonne durchlaufen worden und befanden sich beim Sonnenuntergang deshalb bereits unterhalb des westlichen Horizonts.
* Das Sternbild '''Fische''' (Pisces) besteht seit der Antike aus '''zwei Fischen'''.
* Zu Lebzeiten von Jesus von Nazareth war der '''Frühlingspunkt''' vom Sternbild Widder (Aries, ursprünglich das Hinterteil des großen Sternbilds [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|Himmelsstier (Taurus caeli)]]) in das Sternbild '''Fische''' (Pisces) gewandert. Inzwischen ist er innerhalb dieses Sternbilds noch weiter nach Westen gewandert. Die Sonne und der Neumond standen zu Beginn des jüdischen Monats Nisan, also dem Monat des jüdischen Pessachfestes, im Sternbild '''Fische'''. Der erste Monat des Jahres Nisan hieß bereits in der mesopotamischen Tradition, als sich der Frühlingspunkt noch im Sternbild Widder (Aries) befand, auf Akkadisch &quot;nisannu&quot; (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|Plejaden-Schaltregeln]]). In der alten jüdischen Tradition war der Nisan deswegen mit dem Sternbild Widder verbunden. Ferner wurde der Widder dem israelitischen Stamm Juda zugeordnet.
* Zu Lebzeiten von Jesus von Nazareth war der '''Herbstpunkt''' vom Sternbild Waage (Libra, ursprünglich die Scheren des großen Sternbilds [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsskorpion|Himmelsskorpion (Scorpio caeli)]]) in das Sternbild Jungfrau (Virgo) gewandert. Inzwischen ist er innerhalb dieses Sternbilds noch weiter nach Westen gewandert. Um 285 nach Christi erreichte der '''Herbstpunkt''' dann die ekliptikale Länge des Sterns '''Spica''' (α Virginis).
* Der '''Frühlingspunkt''' –&amp;nbsp;damals im Sternbild Fische&amp;nbsp;– und der '''Herbstpunkt''' –&amp;nbsp;damals im Sternbild Jungfrau (Virgo) beim Stern Spica&amp;nbsp;– befinden sich immer in genau gegenüber liegenden Punkten auf der Ekliptik. Auf diese Weise umfassen diese beiden ausgezeichneten Punkte den Lebewesenkreis (Zodiak) mit seinen '''zwölf''' Sternbildern sowie die Bahnen aller '''sieben''' Wandelgestirne. Diese beiden Punkte teilten die Ekliptik in '''zwei''' gleichgroße Teile, das Sommerhalbjahr und das Winterhalbjahr. Siehe hierzu auch &quot;[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|Beobachtungen in der Nähe der Ekliptik]]&quot;.
** Die '''fünf Brote''' können also mit den fünf mit bloßem Auge sichtbaren Wandelgestirnen (Planeten) '''Merkur''', '''Venus''', '''Mars''', '''Jupiter '''und '''Saturn''' gleichgesetzt werden.&lt;br/&gt;'''''Anmerkung''': In der Bibel wird in der Regel nicht zwischen Fixsternen und Planeten unterschieden. Für eine Ausnahme siehe 2.&amp;nbsp;Buch der Könige, Kapitel 23, Vers 5 aus dem siebenten vorchristlichen Jahrhundert, wo in der Einheitsübersetzung explizit von &quot;den Wandelsternen&quot; und in der Luther-Bibel von &quot;den Planeten&quot; die Rede ist.&lt;ref&gt;[https://www.bibleserver.com/EU/2.K%C3%B6nige23%2C5 2.&amp;nbsp;Buch der Könige, Kapitel 23, Vers 5], bibleserver.com, Einheitsübersetzung 2016&lt;/ref&gt; Die Vulgata schreibt hier allerdings von den &quot;duodecim signis&quot; (zu Deutsch: &quot;'''zwölf''' Zeichen&quot;), womit die '''zwölf''' Sternzeichen der Ekliptik gemeint sind, durch die die '''sieben''' Wandelgestirne ziehen. Die Septuaginta spricht noch allgemeiner von den &quot;μαζουρωθ&quot; (&quot;mazuroth&quot;) nach dem Hebräischen Wort &quot;מַזָּלָה&quot; (&quot;mazzaroth&quot;), womit allgemein eher Sternkonstellationen und nur im engeren Sinne die Sternzeichen des Zodiaks gemeint sind.''
** Die '''zwei Fische''' können also mit den beiden flächenhaft wahrnehmbaren Wandelgestirnen '''Sonne''' und '''Mond '''gleichgesetzt werden.
** Die Summe der '''fünf Brote''' und der '''zwei Fische''' respektive die '''sieben Brote''' (oder die '''sieben Körbe''') entsprechen der Anzahl der freiäugig sichtbaren '''sieben Wandelgestirne''', die sich entlang der Ekliptiklinie stetig gegenüber dem Fixsternhimmel bewegen. Siehe hierzu auch &quot;[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Zusammenhang_mit_dem_Stier|Zu den Etyma und den Kognaten von &quot;Sieben&quot;, &quot;Stier&quot;, &quot;Gestirn&quot; und &quot;Stern&quot;]]&quot;.
** Die ausgeteilten '''Brote''' und '''Fische''' durchmaßen die gesamte versammelte Menschenmenge, die durch den vollständigen [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|Lebewesenkreis (Zodiak)]] mit den '''zwölf Lebewesenkreiszeichen''' beziehungsweise durch die '''zwölf Körbe''' symbolisiert wird. Der Planet Jupiter, der den Zodiak in zwölf Jahren einmal durchläuft, wurde in Babylonien mit dem babylonischen Hauptgott Marduk gleichgesetzt.
* Insgesamt gibt es am Fixsternhimmel gut 2800&amp;nbsp;Sterne bis zur scheinbaren Helligkeit 5,5&lt;sup&gt;m&lt;/sup&gt; und knapp 8800&amp;nbsp;Sterne bis zur scheinbaren Helligkeit&amp;nbsp;6,5&lt;sup&gt;m&lt;/sup&gt;, die ohne Lichtverschmutzung mit bloßem Auge als einzelne Lichtpunkte gesehen werden können. Diese verteilen sich allerdings in der gesamten Himmelssphäre, so dass von einem Punkt auf der Erdoberfläche aus zu jedem Zeitpunkt immer nur ungefähr die Hälfte davon über dem Horizont steht. An den beiden Polen sind stets nur die Sterne der jeweiligen nördlichen oder südlichen Hemisphäre zu sehen, und am Äquator können im Laufe eines Jahres alle Sterne gesehen werden. Je nach Breitengrad und Zeitpunkt können bei Neumond (kein Streulicht) innerhalb einer wolkenlosen Nacht viertausend bis zu fast siebentausend Sterne beobachtet werden.&lt;ref&gt;Bob King: [https://skyandtelescope.org/astronomy-blogs/how-many-stars-night-sky-09172014/ 9,096 Stars in the Sky—Is that all? How many stars in the sky can you see?], skyandtelescope.org - The essential Guide to Astronomy, 17. September 2014&lt;/ref&gt; Diese Spanne entspricht der Angabe der bei der Brotvermehrung versammelten Menschen, deren Anzahl in den Evangelien mit '''viertausend''' beziehungsweise '''fünftausend''' angegeben ist.
** Im ersten Buch des Alten Testaments ('''Genesis''') wird Abram aus Ur in Mesopotamien bereits das Folgende prophezeit:
&lt;blockquote&gt;
15,5 ''Sieh doch zum Himmel hinauf und zähl die Sterne, wenn du sie zählen kannst! Und er sprach zu ihm: So zahlreich werden deine Nachkommen sein''&lt;br/&gt;
...&lt;br/&gt;
17,5 ''Man wird dich nicht mehr Abram nennen. Abraham, Vater der Menge, wird dein Name sein; denn zum Stammvater einer Menge von Völkern habe ich dich bestimmt.''
&lt;/blockquote&gt;
* Die Gruppen von (ungefähr) '''fünfzig''' oder '''hundert Männern''' entsprechen den Sternbildern, die über den gesamten Himmel verteilt sind. Nach der Festlegung der Internationalen Astronomischen Union (IAU) von 1930 gibt es heute 88&amp;nbsp;Sternbilder, die den Himmel vollständig abdecken. Mit den maximal fast 8800&amp;nbsp;freiäugig sichtbaren Sternen entspricht dies im Mittel also 100&amp;nbsp;Sternen pro Sternbild. Bei 4400&amp;nbsp;freiäugig sichtbaren Sternen wären es 50&amp;nbsp;Sterne pro Sternbild. Dies entspricht genau der Spanne der Gruppenstärke, die im Neuen Testament angegeben sind.
* Das '''Brot''' und der '''Wein''' werden nach der christlichen Lehre bei der Transsubstantiation in den Leib und das Blut des vom '''Himmel''' herabgekommenen &quot;Brot des Lebens&quot; (vergleiche die Rede über das Himmelsbrot von Jesus in der Synagoge von Kafarnaum in Evangelium nach Johannes 6,48–58) gewandelt, das die kosmische Ewigkeit verheißt.

Die Zahlen '''Zwei''', '''Fünf''', '''Sieben''' und '''Zwölf''' stehen in einem einfachen arithmetischen Zusammenhang, bei dem die beiden jeweils vorhergehenden Zahlen der Folge addiert werden:

{| class=&quot;wikitable&quot;
|+
|'''Zahl'''
|'''Summe'''
|'''Anmerkung'''
|-
|'''2'''
|
|Anzahl der freiäugig als '''flächenhaft wahrnehmbaren Wandelgestirne''' ('''Sonne''' und '''Mond'''), siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwei|Zur Zwei]]
|-
|'''5'''
|
|Anzahl der freiäugig als '''punktförmig wahrnehmbaren Wandelgestirne''' '''Merkur''', '''Venus''', '''Mars''', '''Jupiter''', '''Saturn'''
|-
|'''7'''
|= 2 + 5
|Anzahl der freiäugig wahrnehmbaren '''Wandelgestirne''' sowie der '''Tage in der Woche''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Sieben|Zur Sieben]]
|-
|'''12'''
|= 5 + 7
|Anzahl der '''Monate im Jahr''', der '''Lebewesenkreiszeichen des Zodiaks''' sowie der '''Erdenjahre pro Jupiterjahr''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwölf|Zur Zwölf]], vergleiche hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|Der Zodiak]]
|-
|'''19'''
|= 7 + 12
|Anzahl der '''Jahre''' mit '''zwölf Monaten''' und '''sieben Schaltmonaten''' einer '''Meton-Periode''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Neunzehn|Zur Neunzehn]], vergleiche hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|Die Plejaden-Schaltregeln]] und [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Mondzyklen#Der_Meton-Zyklus|Der Meton-Zyklus]]
|}

=== Weitere Bezüge ===
Weitere Bezüge von der Astronomie zur Theologie ergeben sich bei den folgenden Sachverhalten:

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Biblische_Erwähnungen|'''biblische Erwähnungen von Konstellationen''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Der_Stern_von_Bethlehem|'''Der Stern von Bethlehem''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Ochs_und_Esel|'''Ochs und Esel / Krippe / „Ich bin das Alpha und das Omega“''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Biblische_Bezüge|'''Biblische Bezüge zu den Mondhäusern / Mondstationen''']].

== Zur Kosmologie ==
[[Datei:Kosmologisches.Modell.Schwarze.Schale.Rotverschiebung.png|mini|rechts|hochkant=2.5|Ein kosmologisches Modell unseres im Zentrum isotropen und inhomogenen Universums, das von einer undurchsichtigen und massereichen schwarzen Kugelschale umgeben ist. Von der äußeren Region aus betrachtet, ist unser Universum ein gigantisches Schwarzes Loch. Zwischen dem inneren und dem äußeren Bereich der schwarzen Kugelschale ist kein Informationsaustausch möglich. Jegliche Materie, die von innen oder außen in die schwarze Kugelschale gelangt, ist von innen und von außen nicht mehr sichtbar. Sowohl die innere als auch die äußere Grenze der schwarzen Kugelschale stellen demzufolge einen Ereignishorizont dar.]]

Die '''Kosmologie''' beschäftigt sich mit der Struktur, dem Ursprung und der Entwicklung des Universums. Dadurch ergeben sich zahlreiche Bezüge zur beobachtenden '''Astronomie''' und zur '''Astrophysik''', aber auch zur '''Quantenphysik'''.

In der Antike gingen die Menschen noch davon aus, dass sich die Erde im Mittelpunkt der Welt und somit auch in der Mitte des sichtbaren Universums befindet. Dieses geozentrische Weltbild wurde seit dem 16.&amp;nbsp;Jahrhundert, ausgelöst durch die kopernikanische Wende, zunehmend verworfen und durch ein heliozentrisches Weltbild ersetzt. Durch die Erfindung und Verwendung von Fernrohren konnten seit dem Beginn des 17.&amp;nbsp;Jahrhunderts immer mehr Details im Sternenhimmel entdeckt werden. Durch astronomische Beobachtungen ergaben sich immer mehr Indizien für die Tatsache, dass die Erde einmal pro Jahr auf einer Ellipsenbahn die Sonne umrundet und nicht die Sonne die Erde umkreist. Der Philosoph Immanuel Kant (1724–1804) erkannte bereits 1755 in seiner Allgemeinen Naturgeschichte und Theorie des Himmels das innere Wesen unserer Milchstraße. Mit der ersten zuverlässigen Messung der Parallaxe von unserer Erde zum benachbarten Fixstern 61&amp;nbsp;Cygni (&quot;Bessel's Stern&quot;) durch Friedrich Wilhelm Bessel (1784–1846) in Königsberg und der daraus folgenden Berechnung von dessen Entfernung von gut zehn Lichtjahren im Jahr 1838 war die Tatsache, dass die Erde um die Sonne läuft, endgültig bewiesen.

Die Auswertung der astronomischen Beobachtungen hat zu der heute allgemein geteilten Auffassung geführt, dass unser Universum bei einem Urknall entstanden ist und seitdem expandiert. Die Berücksichtigung des Äquivalenzprinzips zwischen schwerer und träger Masse, das zu der von '''Albert Einstein''' (1879–1955) formulierten Allgemeinen Relativitätstheorie führt, brachte '''Alexander Friedmann''' (1888–1925) 1922 zu der theoretischen Vorhersage eines dynamischen Universums. Fünf Jahre später schlussfolgerte der belgische Astronom '''Georges Lemaître''' (1894–1966) aus den von '''Vesto Slipher''' (1875–1969) beobachteten Rotverschiebungen von fernen Galaxien und den von '''Edwin Hubble''' (1889–1953) ermittelten Entfernungen dieser Galaxien, dass das Universum expandiert. Aufgrund dieser Erkenntnis ergibt sich, dass das Universum einen Ursprung mit sehr kleinem Radius gehabt haben muss. Diesen Zustand nannte er &quot;primordiales Atom&quot; beziehungsweise &quot;Uratom&quot;. In der Folgezeit etablierte sich für diesen initialen Vorgang der Begriff &quot;'''Urknall'''&quot; (im Englischen: &quot;'''Big Bang'''&quot;).&lt;ref&gt;Markus Bautsch: ''[https://en.wikibooks.org/wiki/Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell/Brief_historical_review Moving objects in retarded gravitational potentials of an expanding spherical shell / Brief historical review], Wikibook (englisch), 2024, abgerufen am 28. Februar 2026&lt;/ref&gt;

Viele Astrophysiker versuchen heute mit dem sogenannten '''Standardmodell der Kosmologie''' (auch '''ΛCDM-Modell''' beziehungsweise Lambda-CDM-Modell, wobei &quot;CDM&quot; für &quot;cold dark matter&quot; steht, also für &quot;kalte, dunkle Materie&quot;) die Entwicklung des Universums nachzubilden. Hierfür wenden sie das kosmologische Prinzip an, das von zwei grundlegenden Annahmen ausgeht:&lt;ref&gt;Markus Bautsch: ''[https://en.wikibooks.org/wiki/Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell/Preface Moving objects in retarded gravitational potentials of an expanding spherical shell / Preface], Wikibook (englisch), 2024, abgerufen am 28. Februar 2026&lt;/ref&gt;

# Das Weltall sei '''homogen''', was bedeutet, dass es in groben Zügen von jedem Punkt aus gleich aussieht.
# Das Weltall sei '''isotrop''', was besagt, dass es in groben Zügen in jede Richtung gleich aussieht.

Mit diesen Annahmen kann das Modell berechnet werden, und mit diversen zusätzlichen Annahmen stimmt es in vielerlei Hinsicht mit den astronomischen Beobachtungen überein. Zu den zusätzlichen Annahmen gehören die folgenden beiden hypothetischen Größen:

* '''Kalte, dunkle Materie''', die zwar der Gravitation unterläge, aber keine Wechselwirkung mit elektromagnetischer Strahlung zeigt.
* Eine '''kosmologische Konstante''' Λ, die eine '''dunkle Energie''' beschreibt und für die beschleunigte Expansion des Universums verantwortlich sei.

Weder für die Homogenität noch für die Isotropie des Kosmos konnten bislang Belege gefunden werden, und auch für die kalte dunkle Materie und die dunkle Energie konnte bislang keine physikalische Interpretation geliefert werden.

Ferner ist auch die Annahme, dass die Naturkonstanten unveränderliche Werte haben, nicht begründbar. Auf kosmischen Zeitskalen kann es durchaus Änderungen geben, die wir derzeit nicht messen können. Die gilt insbesondere für die Hubble-Konstante, die die Expansionsrate des Universums beschreibt, für die Gravitationskonstante, die die Anziehung zweier Massen beschreibt, oder für die kosmologische Konstante, die die beschleunigte Expansion des Universums beschreibt. In diesem Kontext sei darauf hingewiesen, dass unser Universum genauso groß ist wie ein Schwarzes Loch mit der Masse unseres Universums. Deshalb gehen einige Kosmologen davon aus, dass wir innerhalb eines Schwarzen Loches der Größe und Masse unseres Universums leben könnten.

Siehe hierzu auch: [[:en:Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell|'''Moving objects in retarded gravitational potentials of an expanding spherical shell''']].

Darüber hinaus mehren sich Anzeichen und Hinweise, die gegen die Ergebnisse des Standardmodells der Kosmologie sprechen, beziehungsweise durch weitere Hypothesen, die physikalisch nicht begründet werden können, im Standardmodell berücksichtigt werden müssen. Die folgende unvollständige Liste soll hierzu einige Anhaltspunkte liefern:

* Präzise astronomische Beobachtungen zeigen, dass das Weltall auch auf großen Längenskalen '''nicht homogen''' ist, sondern Strukturen zeigt.
* Präzise astronomische Beobachtungen zeigen, dass das Weltall auch auf großen Längenskalen '''nicht isotrop''' ist (Asymmetrie der kosmischen Hintergrundstrahlung).
* Die Hubble-Konstante hat heute einen anderen Wert als früher (&quot;'''Hubble tension'''&quot;), was mit dem Standardmodell nicht im Einklang steht.
* Das beobachtete Vorkommen des dritten Elements im Periodensystem, also des Alkalimetalls '''Lithium''', ist mindestens dreimal geringer als vom Standardmodell vorhergesagt.
* Die '''Rotverschiebung von fernen Galaxien''' ist deutlich größer als es nach dem Standardmodell möglich wäre.
* Die beobachteten '''Rotationskurven von Spiralgalaxien''' stehen im Widerspruch zu den Ergebnissen des Standardmodells.
* Das Standardmodell ist nicht in der Lage, die Abwesenheit von '''Antimaterie''' im sichtbaren Teil des Universums zu erklären.
* Die im frühen Universum beobachteten '''primordialen Schwarzen Löcher und Galaxien''' mit explodierende '''Supernovae''' sowie dem Vorkommen von '''Sauerstoff''' stehen im Widerspruch zu den Ergebnissen des Standardmodells.

== Zur Astrologie ==
Eine Sonderstellung nimmt die '''{{w|Astrologie}}''' (zusammengesetzt mit dem altgriechischen ἄστρον (&quot;astron&quot;), zu Deutsch „Sternenlehre“) ein. Sie ist ein weiteres Beispiel für eine Disziplin, bei der grundlegende Kenntnisse über die Astronomie eine Voraussetzung sind. Sie versucht, Zusammenhänge zwischen den Konstellationen der Wandelgestirne oder astronomischen Ereignissen am Sternenhimmel mit irdischen Geschehnissen oder Veränderungen herzustellen, insbesondere was bestimmte Konjunktionen und daraus abgeleitete Prophezeiungen betrifft. Sie wurde bereits in Mesopotamien und in anderen alten Kulturkreisen von Astronomen ausgeübt. Noch der Astronom '''{{w|Johannes Kepler}}''' (1571–1630) hat als einer der letzten Astronomen einen wesentlichen Teil seiner Einkünfte durch die Erstellung von Horoskopen bestritten. Aber schon Aristoteles hatte festgestellt und beschrieben, dass die bei bestimmten Konstellationen am Himmel vorhergesagten Ereignisse nicht eingetreten waren.

Vor der Aufklärung haben astrologische Prophezeiungen noch eine große und weitreichende gesellschaftliche Bedeutung gehabt. Als Beispiel seien die Behauptungen des ersten im Kurfürstentum Brandenburg tätigen Astrologen '''{{w|Johannes Carion}}''' (1499–1537) genannt, der für 1524 eine Sintflut vorhersagte, die nicht eingetroffen ist.&lt;ref&gt;{{Literatur |Autor=Markus Bautsch, Friedhelm Pedde |Titel=Vor 500 Jahren: Die Sintflut von 1524 die nicht stattfand |Online=https://wfs.berlin/wp-content/uploads/2024/05/A19-BROplanetA4_40s-feb2024ff_www-rz.pdf |Sammelwerk=Dem Himmel nahe. |WerkErg=Mitteilungen der Wilhelm-Foerster-Sternwarte e.V.|Nummer=19 |Hrsg=Wilhelm-Foerster-Sternwarte e.V. / Zeiss-Planetarium am Insulaner |Ort=Berlin |Datum=2024-02 |Seiten=16–19 |Sprache=de |Abruf=2025-08-03|ISSN=2940-9330}}&lt;/ref&gt; Der Wiener Hofastronom '''{{w|Georg Tannstetter}}''' (1482–1535) sah sich 1523 bemüßigt, die schon lange im Voraus erhitzten und besorgten Gemüter zu beruhigen:&lt;ref&gt;Georg Tannstetter: ''Libellus consolatorius contra opiniones de diluvio et aliis horrendis periculis anni 1523''&lt;/ref&gt;

&lt;blockquote&gt;
Nun hat sich überall, in allen Köpfen, in allen Seelen das Gerücht eingeschlichen:&lt;br/&gt;
die Gelehrten und Weisen sind in ständigem Streitgespräch, andere hingegen sind derart verstört, dass sie ihren Geschäften nicht mehr nachgehen können; sie verkaufen ihre Anwesen, ihre Felder und Besitztümer oder lassen davon ab, Güter zu kaufen, in der Hoffnung, ihr Geld leichter in die sicheren Berge transportieren zu können. Andere wiederum verschieben ihr Heiratsversprechen, kündigen ohne scheinbaren Grund Verträge auf, entziehen sich ihren christlichen Gelübden, arbeiten faul und missmutig auf dem Land und fragen sich, was es denn nütze, Geld und Gut anzuhäufen, wenn doch in kürzester Zeit niemand mehr davon Nutzen ziehen könne.
&lt;/blockquote&gt;

'''→ Siehe auch:'''

* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Definition|'''Konjunktionen''', Abschnitt '''Definition''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Historische_Konjunktionen|'''Historische Konjunktionen''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|'''Beobachtungen in der Nähe der Ekliptik''']].
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

== Einzelnachweise ==
&lt;references&gt;&lt;/references&gt;</text>
      <sha1>6atgvp8ouhcpy5k8c8429jj4zo7m9ml</sha1>
    </revision>
    <revision>
      <id>1088602</id>
      <parentid>1088600</parentid>
      <timestamp>2026-07-04T10:26:41Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <comment>/* Der Himmelsthron */ + ugaritischer Thron</comment>
      <origin>1088602</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="88349" sha1="4ozq6j1rsvtxvp04cglgzxjwm6siyzk" xml:space="preserve">Viele Bezeichnungen für verschiedene Lehren werden mit der aus dem Altgriechischen stammenden Endung &quot;-logie&quot; (altgriechisch λόγος (&quot;logos&quot;), zu Deutsch „Lehre“) gebildet. Die folgenden Disziplinen sind in diesem Kontext hervorzuheben, da sie insbesondere für die '''{{w|Archäoastronomie}}''' wertvolle wissenschaftliche Ergänzungen zur '''{{w|Astronomie}}''' (aus den altgriechischen Wörtern ἄστρον (&quot;ástron&quot;, zu Deutsch „Stern“) und νόμος (&quot;nómos, zu Deutsch „Gesetz“) zusammengesetzt also „Sterngesetz“) liefern:

* Die '''{{w|Archäologie}}''' (zusammengesetzt mit dem altgriechischen Wort ἀρχαῖος (&quot;archaios&quot;), zu Deutsch „Altertumslehre“) beschäftigt sich mit der kulturellen Entwicklung der Menschheit.
* Die '''{{w|Etymologie}}''' (zusammengesetzt mit dem altgriechischen Wort ἔτυμος (&quot;etymos&quot;), zu Deutsch „Wortherkunftslehre“) untersucht die geschichtliche Herkunft von Wörtern.
* Die '''{{w|Mythologie}}''' (zusammengesetzt mit dem altgriechischen Wort μῦθος (&quot;mythos&quot;), zu Deutsch „Erzählungslehre“), die sich wissenschaftlich mit der Sagenwelt beschäftigt.
* Die '''{{w|Theologie}}''' (zusammengesetzt mit dem altgriechischen Wort θεός (&quot;theós&quot;), zu Deutsch „Gotteslehre“) mit ihren Lehren zum religiösen Glauben und dessen Glaubensdokumenten.
* Die '''{{w|Kosmologie}}''' (zusammengesetzt mit dem altgriechischen Wort κόσμος (&quot;kósmos&quot;), zu Deutsch „Weltenlehre“) ist hingegen eine Lehre, die sich im Laufe der Jahrtausende deutlich verändert hat und sich auch heute noch erheblich weiterentwickelt, da es in der modernen Astronomie und Astrophysik mit zunehmend hohem technischem Aufwand immer wieder zu neuen Erkenntnissen kommt.
* Die '''{{w|Numerologie}}''' (zusammengesetzt mit dem lateinischen Wort numerus, zu Deutsch „Zahlenlehre“) mit ihren mystischen Lehren über die symbolische Zuweisung von Bedeutungen an Zahlen.

Von der Antike bis ins Mittelalter galt die Beherrschung der '''{{w|sieben freien Künste}}''' als Voraussetzung für das Betreiben von Philosophie. Zu den drei &quot;trivialen&quot; Künsten der {{w|Grammatik}}, der {{w|Rhetorik}} und der {{w|Dialektik}} des '''{{w|Trivium|Triviums}}''' wurden die vier Künste der {{w|Musiktheorie}}, der {{w|Arithmetik}}, der {{w|Geometrie}} und der {{w|Astronomie}} zu den Künsten des '''{{w|Quadrivium|Quadriviums}}''' gezählt → siehe hierzu auch [[Quadriviale_Kuriositäten|'''Wikibook ''Quadriviale Kuriositäten''''']].

== Zur Etymologie ==
Die Genesis aus dem Alten Testament greift die Thematik der Verwirrung der einheitlichen Sprache in ihrem elften Kapitel auf, und beschreibt, wie die bereits sternenkundigen Menschen im Norden Mesopotamiens übermütig geworden waren und in Babel einen Turm mit einer Spitze '''bis in den Himmel''' errichten wollten:&lt;ref&gt;[https://www.bibleserver.com/EU/1.Mose11 Genesis 11], Genesis, Kapitel 11, Einheitsübersetzung&lt;/ref&gt;

&lt;blockquote&gt;
1 Die ganze Erde hatte eine Sprache und ein und dieselben Worte.&lt;br/&gt;
2 Als sie ostwärts aufbrachen, fanden sie eine Ebene im Land Schinar und siedelten sich dort an.&lt;br/&gt;
3 Sie sagten zueinander: Auf, formen wir Lehmziegel und brennen wir sie zu Backsteinen. So dienten ihnen gebrannte Ziegel als Steine und Erdpech als Mörtel.&lt;br/&gt;
4 Dann sagten sie: Auf, bauen wir uns eine Stadt und einen Turm mit einer Spitze '''bis in den Himmel'''! So wollen wir uns einen Namen machen, damit wir uns nicht über die ganze Erde zerstreuen.&lt;br/&gt;
5 Da stieg der HERR herab, um sich Stadt und Turm anzusehen, die die Menschenkinder bauten.&lt;br/&gt;
6 Und der HERR sprach: Siehe, ein Volk sind sie und eine Sprache haben sie alle. Und das ist erst der Anfang ihres Tuns. Jetzt wird ihnen nichts mehr unerreichbar sein, wenn sie es sich zu tun vornehmen.&lt;br/&gt;
7 Auf, steigen wir hinab und verwirren wir dort ihre Sprache, sodass keiner mehr die Sprache des anderen versteht.&lt;br/&gt;
8 Der HERR zerstreute sie von dort aus über die ganze Erde und sie hörten auf, an der Stadt zu bauen.&lt;br/&gt;
9 Darum gab man der Stadt den Namen Babel, Wirrsal, denn dort hat der HERR die Sprache der ganzen Erde verwirrt und von dort aus hat er die Menschen über die ganze Erde zerstreut.
&lt;/blockquote&gt;

Es mag weniger verwunderlich sein, dass Schöpfungsmythen oder Berichte über Katastrophen nicht nur einen astronomischen Hintergrund haben, sondern in völlig verschiedenen Kulturen sehr ähnliche Merkmale zeigen, wenn man sich das Folgende bewusst macht: Einige Indizien deuten auf einen für viele Kulturen gemeinsamen Ursprung hin, der auf eine tiefsinnige Betrachtung und Beobachtung des Himmelsgeschehens hindeutet.

Bei bestimmten Wörtern sind die Ähnlichkeiten in vielen lebenden und toten Sprachen so auffällig, dass sie ein gemeinsames Ursprungswort (Etymon) haben und somit Kognaten sein dürften. 

=== &quot;Stern&quot; ===
Bei den Wörtern „Gestirn“ beziehungsweise „Stern“ sind die Ähnlichkeiten in vielen lebenden und toten Sprachen sehr auffällig, und diese Verwandtschaften mögen durch die Wörter für &quot;Stern&quot; in den folgenden Sprachen belegt werden:

* Akkadisch &quot;istar&quot;
* Indogermanisch &quot;ster&quot;
* Griechisch &quot;astro&quot; / &quot;asteri&quot;
* Lateinisch &quot;astrum&quot; / &quot;stella&quot;
* Althochdeutsch &quot;stern(o)&quot;
* Jiddisch &quot;shtern&quot;
* Katalanisch und Spanisch &quot;estrella&quot;
* Portugiesisch &quot;estrela&quot;
* Englisch &quot;star&quot;
* Niederländisch &quot;ster&quot;
* Westfriesisch &quot;stjer&quot;
* Italienisch und Korsisch &quot;stella&quot;
* Rumänisch &quot;stea&quot;
* Sardisch &quot;istedda&quot;
* Maltesisch &quot;stilla&quot;
* Französisch &quot;étoile&quot; aus Altfranzösisch &quot;estoile&quot;
* Galicisch &quot;estrela&quot;
* Walisisch &quot;seren&quot;
* Dänisch und Norwegisch &quot;stjerne&quot;
* Schwedisch &quot;stjärna&quot;
* Isländisch &quot;stjarna&quot;
* Kurdisch &quot;stêrk&quot;
* Gujarati &quot;Tārō&quot;
* Hindi &quot;तारा&quot; (taara)
* Marathi &quot;तारा&quot; (Tārā)
* Nepalesisch &quot;तारा&quot; (Tārā)
* Punjabi &quot;ਤਾਰਾ&quot; (Tārā)
* Singhalesisch &quot;තරුව&quot; (taruva)
* Khmer &quot;តារា&quot; (tara)
* Armenisch &quot;աստղ&quot; (astgh)
* Tadschikisch &quot;ситора&quot; (sitora)
* Hausa &quot;tauraro&quot;
* Krio &quot;sta&quot;

=== &quot;Stier&quot; ===
Eine starke Ähnlichkeit gibt es in vielen Sprachen auch zwischen den Wörtern „Stern“ und „Stier“. Der Stier bezeichnet zudem auch ein bedeutendes und eines der ältesten Sternbilder überhaupt:

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|'''Himmelsstier''']].

* Akkadisch und Assyrisch &quot;šūru&quot;
* Aramäisch &quot;tōra&quot;
* Hebräisch &quot;šǒr&quot;
* Ugaritisch &quot;twr&quot;
* Arabisch &quot;ثور&quot; (&quot;thawr&quot;)
* Griechisch &quot;ταύρος&quot; (&quot;tauros&quot;)
* Lateinisch &quot;taurus&quot;
* Althochdeutsch &quot;stior&quot;
* Italienisch, Katalanisch und Spanisch &quot;toro&quot;
* Galicisch &quot;touro&quot;
* Gallisch &quot;tarvos&quot;
* Französisch &quot;taureau&quot;
* Schwedisch &quot;tjur&quot;
* Dänisch &quot;tyr&quot;
* Irisch und Gälisch &quot;tarbh&quot;
* Wallisisch &quot;tarw&quot;

=== &quot;Horn&quot; ===
Auch die Hörner des Stieres betreffend setzen sich die vielen Ähnlichkeiten fort:

* Akkadisch &quot;carnu&quot;
* Aramäisch &quot;qeren&quot;
* Griechisch &quot;κόρνο&quot; (&quot;korno&quot;)
* Lateinisch &quot;cornu&quot;
* Maltesisch &quot;qrun&quot;*
* Arabisch &quot;قرون&quot; (&quot;qurun&quot;)
* Französisch &quot;corne&quot;
* Italienisch &quot;corne&quot;
* Rumänisch &quot;corn&quot;
* Haitianisch &quot;kòn&quot;

=== &quot;Sieben&quot; ===
Die in vielen Kulturen als heilig angesehene Zahl Sieben taucht im Zusammenhang mit der Astronomie als Anzahl der mit bloßem Auge sichtbaren Wandelgestirne und als Zahl der Hauptsterne in vielen Asterismen auf:

* Sieben Wandelgestirne: Sonne Mond, Merkur, Venus, Mars, Jupiter, Saturn
* Siebengestirn im Himmelsstier: Alkione, Atlas, Electra, Maia, Merope, Taygeta, Pleione
* Sternbild Orion: Beteigeuze, Rigel, Bellatrix, Alnilam, Alnitak, Saiph, Mintaka
* Asterismus Großer Wagen: Alioth, Dubhe, Alkaid, Mizar, Merak, Phekda, Megrez

→ Siehe auch:

* [[Quadriviale_Kuriositäten/_Zahlen#Zur_Sieben|'''Zur Sieben''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Der_Fixsternhimmel#Die_sieben_hellsten_Objekte_der_Ekliptik|'''Die sieben hellsten Objekte der Ekliptik''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Kalenderführung#Die_Siebentagewoche|'''Die Siebentagewoche''']].

Wegen der hohen kulturellen, rituellen oder mythischen Bedeutung gibt es in vielen Kulturen und Sprachen etymologische Übereinstimmungen:

* Akkadisch &quot;sebe&quot;
* Proto-Indoeuropäisch &quot;septḿ̥&quot;
* Hetitisch &quot;sipta&quot;
* Proto-Germanisch &quot;*sebun&quot;
* Althochdeutsch &quot;sibun&quot;
* Hebräisch &quot;sajin&quot; (Buchstabe) oder &quot;scheva&quot; (Wort)
* Etruskisch &quot;semph&quot;
* Maltesisch &quot;sebgħa&quot;
* Arabisch &quot;sabʿa&quot;
* Griechisch &quot;επτά&quot; (&quot;(h)epta&quot;)
* Lateinisch &quot;septem&quot;
* Ungarisch &quot;het&quot;
* Proto-Balto-slawisch &quot;septin&quot;
* Proto-Indo-Iranisch &quot;saptá&quot;
* Katalanisch &quot;set&quot;
* Spanisch &quot;siete&quot;
* Galicisch &quot;sete&quot;
* Lettisch &quot;septiņi&quot;
* Italienisch &quot;sette&quot;
* Französisch &quot;sept&quot;
* Englisch &quot;seven&quot;
* Wallisisch &quot;saith&quot;
* Bosnisch / Kroatisch &quot;sedam&quot;
* Rumänisch &quot;șapte&quot;
* Irisch &quot;seacht&quot;
* Swahili &quot;saba&quot;
* Haitianisch &quot;sèt&quot;

== Zur Mythologie ==
Seit Jahrtausenden blicken Menschen in den Nachthimmel und versuchen, die unzähligen Lichter am Firmament zu deuten. Schon früh begannen sie, die von ihnen erfundenen Sternbilder und die unablässig durch den Himmel ziehenden Wandelgestirne durch Geschichten über Götter, Helden oder andere Wesen zu interpretieren, zu erzählen und zum Teil über Jahrhunderte hinweg zu tradieren. Die '''Mythologie''' spielte dabei eine zentrale Rolle: Sie half nicht nur, eine symbolische Ordnung in den geheimnisvollen Kosmos zu bringen, sondern prägte auch viele der Bezeichnungen und Vorstellungen, die bis heute in der beschreibenden Astronomie überlebt haben.

Die Verbindung zwischen Mythologie und Astronomie ist tief verwurzelt und zeugt vom menschlichen Bedürfnis, das wahrgenommene, aber dennoch unfassbare Universum durch räumliche und zeitliche Vorstellungen sowie durch Erzählungen begreifbar zu machen. Das Geschehen am Himmel musste auf die Menschen vor der Erfindung der Bewegtbilder und des Films in der späten Neuzeit sowohl attraktiv als auch spektakulär gewirkt haben. So konnten verschiedene mythische Gestalten am Himmel durch ihre scheinbaren Handlungen wahrgenommen werden. Durch die Wiederholung solcher Deutungen konnten sich besonders beliebte Mythen im kulturellen Kontext über die Zeit verfestigen, und entsprechende Riten konnten sich etablieren.

Damit war auch eine wesentliche Voraussetzung für den Glauben der Menschen an eine höhere Macht oder mehrere höhere Mächte gegeben. Der Begriff '''Religion''' stammt vom lateinischen Inifiniv &quot;relegere&quot; ab. Dieses Verb bedeutet wörtlich übersetzt &quot;wieder lesen&quot; und meint im Sinne von &quot;überdenken&quot; das bewusste Wahrnehmen von Prophezeiungen oder Omen sowie das nachhaltige Beachten tradierter Vorschriften.

'''→ Siehe:'''

* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Der Urozean''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Sagenwelt|'''Die Plejaden / Sagenwelt''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Mythologie|'''Der Himmelsstier''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Babylonische_Himmelswege|'''Babylonische Himmelswege''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Mithraskult|'''Mithraskult und Tauroktonie''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Höhlenmalerei_in_der_Magura-Höhle|'''Die Höhlenmalerei in der Magura-Höhle''']].

== Zur Theologie ==
Die '''Theologie''' (vom Altgriechischen θεός = theós = Gott und λόγος = lógos = Lehre) ist die Lehre von einem Gott oder von mehreren Göttern. Sie lehrt einen ausgeprägten religiösen Glauben, begründet rituelle Traditionen und deutet die vorhandenen Glaubensdokumente.

[[Datei:Aristoteles.Theologie.png|mini|rechts|Wahrnehmbarkeit und Vergänglichkeit nach Aristoteles]]

Die Theologie des '''{{w|Aristoteles}}''' (384–322) postuliert drei mögliche Substanzen:&lt;ref&gt;Aristoteles: ''Metaphysik'', Kapitel XII (Λ), Philosophische Theologie, Seiten 1069a –1076a&lt;/ref&gt;

{| class=&quot;wikitable&quot;
|+ Mögliche Substanzen nach Aristoteles
! Nummer !! Substanz !! Erläuterung !! Interpretationsbeispiel
|-
| 1. || Die sinnlich wahrnehmbare und vergängliche Substanz || Konkrete Dinge, die nur eine begrenzte Teilhabe an der Ewigkeit haben. || Lebewesen
|-
| 2. || Die sinnlich wahrnehmbare und unvergängliche Substanz || Konkrete Dinge, die eine unbegrenzte Teilhabe an der Ewigkeit haben. || Die sieben Wandelgestirne und die Fixsterne
|-
| 3. || Die sinnlich nicht wahrnehmbare und unvergängliche Substanz || Lebendiger, unbewegter Beweger, der der Ursprung aller anderen Dinge ist. || Gott
|}

Dieses theologische Prinzip wurde später auch von '''{{w|Thomas van Aquin}}''' (1225-1274) in seinen ''Quinque viae ad Deum'' (&quot;Fünf Wege zu Gott&quot;) aufgegriffen:

{| class=&quot;wikitable&quot;
|+ Nach dem ''Quinque viae ad Deum'' (&quot;Fünf Wege zu Gott&quot;) von Thomas von Aquin
! Weg !! Bezeichnung !! Voraussetzung !! Feststellung !! Folgerung
|-
| Via&amp;nbsp;I || Bewegungsbeweis || In der Welt ist überall Bewegung. || Alles Bewegte muss von einem anderen in Bewegung gebracht worden sein. || Der Erstbeweger ist Gott.
|-
| Via&amp;nbsp;II || Kausalitätsbeweis || In der Welt gibt es überall Ursachen und Wirkungen. || Jede Wirkung muss eine Ursache haben. || Die erste Ursache der Welt ist Gott.
|-
| Via&amp;nbsp;III || Kontingenzbeweis || Alles Empirische in der Welt entsteht und vergeht wieder. || Jedes empirische Wesen muss das Sein von einem absoluten Wesen empfangen haben. || Das absolute Wesen ist Gott.
|-
| Via&amp;nbsp;IV || Stufenbeweis || In der Welt gibt es abgestuft gute, wahre und schöne Dinge. || Das absolute Wesen muss die höchste Güte, Wahrheit und Schönheit haben. || Das höchste Gute, Wahre und Schöne ist Gott.
|-
| Via&amp;nbsp;V || Finalitätsbeweis || In der Welt gibt es Ordnung und Gesetzmäßigkeit. || Ordnung und Gesetzmäßigkeit müssen auf einen denkenden Geist zurückgehen. || Dieser Geist kommt von Gott.
|}

Auch '''{{w|Gottfried Wilhelm Leibniz}}''' (1646-1717) lehnt sich in seiner Hypothese von „Gott als letztem und zureichendem Grund der Welt“ daran an.

Auch im 90. Psalm wird dieser Ansatz thematisiert:

&lt;blockquote&gt;
Das vierte Buch&lt;br/&gt;
Der '''ewige''' Gott – der '''vergängliche''' Mensch&lt;br/&gt;&lt;br/&gt;
1 Ein Bittgebet des Mose, des Mannes Gottes. O Herr, du warst uns Wohnung '''von Geschlecht zu Geschlecht'''.&lt;br/&gt;
2 '''Ehe geboren wurden die Berge, ehe du unter Wehen hervorbrachtest Erde und Erdkreis''', bist du '''Gott von Ewigkeit zu Ewigkeit'''.&lt;br/&gt;
3 '''Zum Staub zurückkehren lässt du den Menschen''', du sprichst: Ihr Menschenkinder, kehrt zurück!&lt;br/&gt;
4 Denn tausend Jahre sind in deinen Augen wie der Tag, der gestern vergangen ist, wie eine Wache in der Nacht.
&lt;/blockquote&gt;

Darüber hinaus gibt der vierte Vers einen deutlichen Hinweis auf das Verhältnis zwischen der Länge des viele Jahrtausende dauernden Präzessionszyklus und der Länge eines siderischen Monats: der Mond wandert entlang der Ekliptiklinie an einem Tag genauso weit wie der Frühlingspunkt in tausend Jahren.

→ Siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Präzession|'''Präzession''']].

Der griechische Dichter '''{{w|Aratos von Soloi}}''' in Kilikien (≈310–245) hatte seine astronomischen Kenntnisse vom Astronomen und Mathematiker '''{{w|Eudoxos von Knidos}}''' (geboren nach 390, gestorben nach 338) erhalten. In dem in der Antike verbreiteten Lehrgedicht Φαινόμενα (Phainomena = „Himmelserscheinungen“) von Aratos wird der Sternenhimmel in zahlreichen Hexametern beschrieben. Sein monumentales sechseckiges Grab aus der antiken Stadt Pompeiopolis wurde 2020 in der türkischen Provinz Mersin wiederentdeckt.&lt;ref&gt;Patricia Claus: [https://greekreporter.com/2021/07/11/memorial-tomb-of-ancient-greek-astronomer-aratus-unearthed-in-turkey/ Memorial Tomb of Ancient Greek Astronomer Aratus Unearthed in Turkey], The Greek Reporter, 11. Juli 2021&lt;/ref&gt;

Hier der Beginn des Prologs des Lehrgedichts:

&lt;blockquote&gt;
Εκ Διὸς ἀρχώμεσθα , τὸν οὐδέποτ᾽ ἄνδρες ἐῶμεν&lt;br/&gt;
῎Αῤῥητον . Μεσταὶ δὲ Διὸς πᾶσαι μὲν ἀγυιαὶ ,&lt;br/&gt;
Πᾶσαι δ᾽ ἀνθρώπων ἀγοραί · μεστὴ δὲ θάλασσα ,&lt;br/&gt;
Καὶ λιμένες. πάντη δὲ Διὸς κεχρήμεθα πάντες .&lt;br/&gt;
'''Τοῦ γὰρ καὶ γένος εἰμέν''' · ὁ δ᾽ ἤπιος ἀνθρώποισι&lt;br/&gt;
Δεξιὰ σημαίνει · λαοὺς δ᾽ ἐπὶ ἔργον ἐγείρει ,&lt;br/&gt;
Μιμνήσκων βιότοιο . λέγει δ᾽ , ὅτε βῶλος ἀρίστη&lt;br/&gt;
Βουσί τε καὶ μακέλῃσι · λέγει δ᾽ , ὅτε δεξιαὶ ὧραι ,&lt;br/&gt;
Καὶ φυτὰ γύρῶσαι , καὶ σπέρματα πάντα βαλέσθαι .&lt;br/&gt;
Αὐτὸς γὰρ τάγε σήματ᾽ ἐν '''οὐρανῷ''' ἐστήριξεν ,&lt;br/&gt;
'''Αστρα''' διακρίνας · ἐσκέψατο δ᾽ εἰς ἐνιαυτὸν&lt;br/&gt;
'''᾿Αστέρας''' , οἵ κε μάλιστα τετυγμένα σημαίνοιεν&lt;br/&gt;
᾿Ανδράσιν ὡράων , ὄφρ᾽ ἔμπεδα πάντα φύωνται .&lt;br/&gt;
Τῷ μιν ἀεὶ πρῶτόν τε καὶ ὕστατον ἱλάσκονται .&lt;br/&gt;
Χαῖρε , πάτερ , μέγα θαῦμα , μέγ᾽ ἀνθρώποισιν ὄνειαρ ,&lt;br/&gt;
Αὐτὸς καὶ προτέρη γενεή ! χαίροιτε δὲ , Μοῦσαι&lt;br/&gt;
Μειλίχιαι , μάλα πᾶσαι ! ἐμοί γε μὲν '''ἀστέρας''' εἰπεῖν ,&lt;br/&gt;
Ηἱ θέμις εὐχομένῳ , τεκμήρατε πᾶσαν ἀοιδήν .&lt;br/&gt;
Οἱ μὲν ὁμῶς πολέες τε , καὶ ἄλλυδις ἄλλοι ἐόντες ,&lt;br/&gt;
'''Οὐρανῷ''' ἕλκονται πάντ᾽ ἤματα συνεχὲς αἰεί.&lt;br/&gt;
Αὐτὰρ ὅγ᾽ οὐδ᾽ ὀλίγον μετανίσσεται · ἀλλὰ μάλ' αὕτως&lt;br/&gt;
'''῎Αξων''' οἱ ἐνάρηρεν · ἔχει δ᾽ ἀτάλαντον ἁπάντη&lt;br/&gt;
'''Μεσσηγὺς γαῖαν''' , περὶ δ᾽ '''οὐρανὸν''' αὐτὸν ἀγινεῖ.&lt;br/&gt;
Καί μιν πειραίνουσι δύω '''πόλοι''' ἀμφοτέρωθεν ·&lt;br/&gt;
᾿Αλλ᾽ ὁ μὲν οὐκ ἐπίοπτος · ὁ δ᾽ ἀντίος ἐκ '''Βορέαο''' ,&lt;br/&gt;
Ὑψόθεν Ὠκεανοῖο . Δύω δὲ μιν ἀμφὶς ἔχουσαι&lt;br/&gt;
'''Ἄρκτοι''' ἅμα τροχόωσι · τὸ δὴ καλέονται '''῞Αμαξαι''' .
&lt;/blockquote&gt;

Übersetzung unter Beibehaltung der Hexameter nach dem deutschen Dichter, Übersetzer und Hochschullehrer Johann Heinrich Voss (1751–1826) von 1824:&lt;ref&gt;АРАТОΥ ΦΑΙΝΟΜΕΝΑ ΚΑΙ ΔΙΟΣΗΜΕΙΑ. Des Aratos Sternerscheinungen und Wetterzeichen. Übersetzt und erklärt von Johann Heinrich Voss. Heidelberg bei Christian Friedrich Winter. 1824.&lt;/ref&gt;

&lt;blockquote&gt;
Zeus sei unser Beginn , und niemals bleib' er uns Männern&lt;br/&gt;
Ungelobt. Voll wahrlich des Zeus sind alle des Wandels&lt;br/&gt;
Weg' , und alle Versammlung der Welt ; voll jegliche Meerflut ,&lt;br/&gt;
Jeglicher Port ; ringsum ja des Zeus bedürfen wir alle .&lt;br/&gt;
'''Seines Geschlechts auch sind wir''' ; und Er , mildherzig den Menschen,&lt;br/&gt;
Zeichnet, was frommt, rechtsher ; und zu Tätigkeit weckt er die Völker,&lt;br/&gt;
Mahnend an Lebensbedarf : Er sagt , wann besser dem Pflugstier&lt;br/&gt;
Fuge die Scholl' , und dem Karst ; er sagt , wann schickliche Jahrszeit,&lt;br/&gt;
Dass man die Pflanze behäuf&quot; , und einsenk' allerlei Anwachs .&lt;br/&gt;
Denn selbst hat er die Zeichen am oberen '''Himmel''' befestigt ,&lt;br/&gt;
Und '''Sternbilder''' verteilt ; er hat fürsehend dem Jahrlauf&lt;br/&gt;
'''Sterne''' bestimmt , die den Menschen zumeist annahende Wechsel&lt;br/&gt;
Deuteten jeglicher Zeit , dass in Völligkeit alles erwachse .&lt;br/&gt;
Drum ihn immer zuerst , und zulezt ihn , sühnen sie feiernd.&lt;br/&gt;
Heil , anstaunlicher Vater , den Sterblichen mächtiges Labsal ,&lt;br/&gt;
Du auch , selbst des Geschlechts Ursprung ! Heil , freundliche Musen,&lt;br/&gt;
Heil euch allen gesamt ! doch mir , der , die '''Sterne''' zu melden ,&lt;br/&gt;
Euch , wie geziemt , anfleht , bringt allen Gesang zur Vollendung.&lt;br/&gt;
Jene zugleich , so viele zerstreuete , andere anders ,&lt;br/&gt;
Ziehn mit dem '''Himmel''' einher in ewigem Zuge beständig .&lt;br/&gt;
Doch nie schwanket er selbst um ein weniges; sondern durchaus so&lt;br/&gt;
Bleibt ihm die '''Axe''' geheftet ; die hält gleichschwebend vom Umfang&lt;br/&gt;
Hier '''in der Mitte die Erd'''' , und umher dort dreht sie den '''Himmel''' .&lt;br/&gt;
Sie dann hat zween '''Pol'''' an jeglichem Ende gerichtet :&lt;br/&gt;
Unsichtbar ist jener; doch hier um den '''Boreas''' ragt er&lt;br/&gt;
Ob dem Okeanos hoch. Zwo dem zu den Seiten gestellte&lt;br/&gt;
'''Bärinnen''' rollen umher: drum auch '''Rollwagen''' benamet.
&lt;/blockquote&gt;

'''''Hinweise:'''''
* Die &quot;Axe&quot; beschreibt die Erdachse.
* ''Mit dem &quot;Boreas&quot; ist der Himmelsnordpol gemeint.''
* ''Bei den beiden Bärinnen handelt es sich um die Sternbilder des Großen Bären (Ursa Maior) und des Kleinen Bären (Ursa Minor).''
* ''Die beiden Rollwagen sind bei uns heute die Asterismen Großer Wagen und Kleiner Wagen.''

Der Apostel '''{{w|Paulus von Tarsus}}''' (geboren vor 10, gestorben nach 60) war der bedeutendste Missionar des Urchristentums und kannte diesen Text offensichtlich. Im 17.&amp;nbsp;Kapitel der Apostelgeschichte des Lukas wird ihm ein Zitat aus dem Prolog des Lehrgedichts über die Abstammung der Menschen von Gott in den Mund gelegt.&lt;ref&gt;[https://www.die-bibel.de/bibel/NA28,EUE/ACT.17.28 Apostelgeschichte 17,28], Abschnitt: ''Paulus in Athen'', Novum Testamentum Graece und Einheitsübersetzung&lt;/ref&gt;

&lt;blockquote&gt;
Apostelgeschichte 17,28: '''Τοῦ γὰρ καὶ γένος ἐσμέν.'''
&lt;/blockquote&gt;

&lt;blockquote&gt;
Apostelgeschichte 17,28: '''Wir sind von seinem Geschlecht.'''
&lt;/blockquote&gt;

=== Zahlen in Religionen ===
Die '''Zwei''' steht oft für Gegensätze, wie zum Beispiel Tag und Nacht, Aufgang und Untergang, Sommerhalbjahr und Winterhalbjahr, zunehmender und abnehmender Mond oder obere und untere Kulmination. Eine solche Zweiteilung findet sich oft auch in gegensätzliche Kategorien wieder, die in vielen Disziplinen, insbesondere auch in der Ethik und in Religionen verwendet werden, wie beispielsweise gut und böse, oben und unten, Leben und Tod, Licht und Schatten, Wärme und Kälte oder Himmel und Hölle.

Interessant ist auch die frühgeschichtliche astronomische Auffassung von '''zwei''' mächtigen Gegenspielern, die sich im Sternenhimmel an zwei gegenüberliegenden Seiten befinden, der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|der Himmelsstier]] und der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsskorpion|der Himmelsskorpion]].

→ Siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwei|'''Zur Zwei''']].

Die astronomischen Zahlen '''Sieben''' und '''Zwölf''' werden als heilige Zahlen angesehen. Sie werden in vielfältigen Kontexten in religiösen Texten erwähnt und für viele religiöse Symbole verwendet. Ferner spielt auch die astronomische Zahl '''Vier''' in Religionen eine bedeutende Rolle, wo sie deswegen manchmal ebenfalls als heilige Zahlen angesehen wird:

* '''Vier''' Hauptsterne respektive Hauptsternbilder mit den '''vier''' Himmelsrichtungen und den '''vier''' Jahreszeiten: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Vier_in_Religionen|'''Bedeutung der Vier in Religionen''']].
* '''Sieben''' Wandelgestirne mit den die '''sieben''' Tagen einer Woche beziehungsweise eines Mondviertels: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Sieben_in_Religionen|'''Bedeutung der Sieben in Religionen''']].
* '''Zwölf''' Ekliptiksternbilder, '''zwölf''' Monate pro Jahr, '''zwölf''' Jahre Umlaufzeit des Planeten Jupiter, jeweils '''zwölf''' Stunden Tag und Nacht: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Zwölf_in_Religionen|'''Bedeutung der Zwölf in Religionen''']].

=== Altes Testament ===
In der Bibel wird in der Regel nicht zwischen Fixsternen und Planeten unterschieden. Eine Ausnahme gibt es im 2.&amp;nbsp;Buch der Könige, Kapitel&amp;nbsp;23, Vers&amp;nbsp;5 aus dem siebenten vorchristlichen Jahrhundert, wo in der deutschsprachigen Einheitsübersetzung von &quot;den Wandelsternen&quot; und in der Luther-Bibel von &quot;den Planeten&quot; die Rede ist. Die Vulgata schreibt hier allerdings von den &quot;duodecim signis&quot;, womit sicherlich die zwölf Sternzeichen der Ekliptik gemeint sind, durch die die sieben Wandelgestirne ziehen. Die Septuaginta spricht noch allgemeiner von den &quot;μαζουρωθ&quot; nach dem Hebräischen Wort &quot;מַזָּלָה&quot; (&quot;mazzaroth&quot;), womit vermutlich Sternkonstellationen und im engeren Sinne ebenfalls die zwölf Sternzeichen des Zodiaks gemeint sind:

&lt;blockquote&gt;
'''Septuaginta '''&lt;br/&gt;
5 καὶ κατέπαυσεν τοὺς χωμαριμ, οὓς ἔδωκαν βασιλεῖς Ιουδα καὶ ἐθυμίων ἐν τοῖς ὑψηλοῖς καὶ ἐν ταῖς πόλεσιν Ιουδα καὶ τοῖς περικύκλῳ Ιερουσαλημ, καὶ τοὺς θυμιῶντας τῷ Βααλ καὶ τῷ ἡλίῳ καὶ τῇ σελήνῃ καὶ τοῖς '''μαζουρωθ''' καὶ πάσῃ τῇ δυνάμει τοῦ οὐρανοῦ.&lt;br/&gt;
&lt;br/&gt;
'''Vulgata'''&lt;br/&gt;
5 Et delevit aedituos, quos posuerant reges Iudae ad sacrificandum in excelsis per civitates Iudae et in circuitu Ierusalem, et eos, qui adolebant Baal et soli et lunae et '''duodecim signis''' et omni militiae caeli.&lt;br/&gt;
&lt;br/&gt;
'''Einheitsübersetzung (2016)'''&lt;br/&gt;
5 Auch setzte er die Götzenpriester ab, die von den Königen von Juda bestellt worden waren und die auf den Kulthöhen, in den Städten Judas und in der Umgebung Jerusalems Opfer verbrannt sowie dem Baal, der Sonne, dem Mond, den '''Wandelsternen''' und dem ganzen Heer des Himmels geopfert hatten.&lt;br/&gt;
&lt;br/&gt;
'''Luther-Bibel (2017)'''&lt;br/&gt;
5 Und er setzte die Götzenpriester ab, die die Könige von Juda eingesetzt hatten, um auf den Höhen zu opfern in den Städten Judas und um Jerusalem her; auch die dem Baal geräuchert hatten, der Sonne und dem Mond und den '''Planeten''' und allem Heer am Himmel.&lt;br/&gt;
&lt;/blockquote&gt;

Der Prophet Habakuk erwähnt in seinem Psalm in Kapitel&amp;nbsp;3 aus dem siebenten vorchristlichen Jahrhundert das Konzept der Aufteilung der Ekliptik in Mondstationen respektive in Mondhäuser:

&lt;blockquote&gt;
10 Wenn sie dich sehen, erbeben die Berge,&lt;br/&gt;
das Tosen der Wasser rauscht vorüber; es erhebt die Urflut ihre Stimme,&lt;br/&gt;
hoch oben vergisst die Sonne ihre Strahlen.&lt;br/&gt;
11 '''Der Mond bleibt in der Behausung;'''&lt;br/&gt;
als Beleuchtung schwirren deine Pfeile,&lt;br/&gt;
als heller Schein das Blitzen deiner Lanze.
&lt;/blockquote&gt;

In den folgenden Bibelstellen aus dem Alten Testament spiegeln sich astronomische Vorstellungen in Bezug auf Gott wider:

'''Genesis 1:'''
&lt;blockquote&gt;
1 Im Anfang erschuf Gott '''Himmel''' und Erde.&lt;br/&gt;
2 Die '''Erde''' war wüst und wirr und '''Finsternis''' lag über der '''Urflut''' und Gottes Geist schwebte über dem '''Wasser'''.&lt;br/&gt;
3 Gott sprach: Es werde '''Licht'''. Und es wurde '''Licht'''.
...&lt;br/&gt;
5 Und Gott nannte das Licht '''Tag''' und die Finsternis nannte er '''Nacht'''. Es wurde '''Abend''' und es wurde '''Morgen''': erster Tag.&lt;br/&gt;
...&lt;br/&gt;
14 Dann sprach Gott: Lichter sollen am '''Himmelsgewölbe''' sein, um '''Tag''' und '''Nacht''' zu scheiden. Sie sollen als Zeichen für '''Festzeiten''', für '''Tage''' und '''Jahre''' dienen.&lt;br/&gt;
15 Sie sollen Lichter am Himmelsgewölbe sein, um über die Erde hin zu leuchten. Und so geschah es.&lt;br/&gt;
16 Gott machte '''die beiden großen Lichter''', das große zur Herrschaft über den '''Tag''', das kleine zur Herrschaft über die '''Nacht''', und die '''Sterne'''.
&lt;/blockquote&gt;

'''Psalm 8:'''
&lt;blockquote&gt;
4 Seh ich deine '''Himmel''', die Werke deiner Finger, '''Mond '''und '''Sterne''', die du befestigt.
&lt;/blockquote&gt;

[[Datei:Johannes.Kepler.Coeli.enarrant.gloriam.Dei.png|mini|rechts|Portrait des jungen Johannes Keplers mit dem Motto &quot;Coeli enarrant gloriam Dei.&quot; nach Psalm 19: &quot;Die Himmel erzählen die Herrlichkeit Gottes.&quot;]]

'''Psalm 19:'''
&lt;blockquote&gt;
2 Die '''Himmel''' erzählen die Herrlichkeit Gottes und das '''Firmament''' kündet das Werk seiner Hände.
&lt;/blockquote&gt;

'''Psalm 90:'''
&lt;blockquote&gt;
2 Ehe geboren wurden die Berge, ehe du unter Wehen hervorbrachtest '''Erde''' und '''Erdkreis''', bist du Gott von Ewigkeit zu Ewigkeit.
&lt;/blockquote&gt;

'''Psalm 102:'''
&lt;blockquote&gt;
26 Vorzeiten hast du der Erde Grund gelegt, die '''Himmel''' sind das Werk deiner Hände.
&lt;/blockquote&gt;

'''Psalm 103:'''
&lt;blockquote&gt;
19 Der HERR hat seinen Thron errichtet im '''Himmel''', seine königliche Macht beherrscht '''das All'''.
&lt;/blockquote&gt;

'''Psalm 104:'''
&lt;blockquote&gt;
19 Du machst den '''Mond''' zum Maß für die Zeiten, die '''Sonne''' weiß, wann sie untergeht.
&lt;/blockquote&gt;

'''Psalm 113:'''
&lt;blockquote&gt;
3 Vom '''Aufgang der Sonne''' bis zu ihrem '''Untergang''' sei gelobt der Name des HERRN.&lt;br/&gt;
4 Erhaben ist der HERR über alle Völker, über den '''Himmeln''' ist seine Herrlichkeit.
&lt;/blockquote&gt;

'''Psalm 136:'''
&lt;blockquote&gt;
3 Dankt dem Herrn der Herren, denn seine Huld währt ewig!&lt;br/&gt;
4 Ihm, der allein große Wunder tut, denn seine Huld währt ewig,&lt;br/&gt;
5 der den '''Himmel''' gemacht hat in Weisheit, denn seine Huld währt ewig,&lt;br/&gt;
6 der die Erde gefestigt hat über den Wassern, denn seine Huld währt ewig,&lt;br/&gt;
7 der '''die großen Leuchten''' gemacht hat, denn seine Huld währt ewig,&lt;br/&gt;
8 die '''Sonne''' zur Herrschaft über den '''Tag''', denn seine Huld währt ewig,&lt;br/&gt;
9 den '''Mond''' und die '''Sterne''' zur Herrschaft über die '''Nacht''', denn seine Huld währt ewig.
&lt;/blockquote&gt;

'''Psalm 147:'''
&lt;blockquote&gt;
4 Er bestimmt die Zahl der '''Sterne''' und ruft sie alle mit Namen.
&lt;/blockquote&gt;

'''Psalm 148:'''
&lt;blockquote&gt;
'''Lobpreis auf den Herrn, den König des Kosmos'''&lt;br/&gt;
1 Halleluja! Lobt den HERRN vom '''Himmel''' her, lobt ihn in den Höhen:&lt;br/&gt;
2 Lobt ihn, all seine Engel, lobt ihn, all seine Heerscharen,&lt;br/&gt;
3 lobt ihn, '''Sonne''' und '''Mond''', lobt ihn, all ihr leuchtenden '''Sterne''',&lt;br/&gt;
4 lobt ihn, ihr '''Himmel der Himmel''', ihr Wasser über dem '''Himmel'''!
&lt;/blockquote&gt;

Mit den &quot;Wassern über dem Himmel&quot; können nicht die Wolken unterhalb der Sternensphäre gemeint sein. Vielmehr dürfte es sich um eine Anspielung auf den Urozean beziehungsweise die Urflut handeln (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Urozean''']]). Diese Urflut existierte bereits vor der Erschaffung des Lichts und der Gestirne. Man erinnere sich an den Beginn der Schöpfungsgeschichte in den ersten drei Versen der Bibel (siehe oben).

'''Buch der Weisheit (Weisheit Salomos):'''
&lt;blockquote&gt;
'''Salomos Gebet um Weisheit'''&lt;br/&gt;
9,1 Gott der Väter und Herr des Erbarmens, du hast '''das All''' durch dein Wort gemacht.
&lt;/blockquote&gt;

'''Jesus Sirach 42:'''
&lt;blockquote&gt;
'''Lob Gottes in der Schöpfung'''&lt;br/&gt;
15 Nun will ich der Werke des Herrn gedenken, und was ich gesehen habe, werde ich erzählen: Durch die Worte des Herrn sind seine Werke und durch seinen Segen gab er ihnen ihre Bestimmung.&lt;br/&gt;
16 Die leuchtende '''Sonne''' blickt auf alles hernieder und von der Herrlichkeit des Herrn ist sein Werk erfüllt.&lt;br/&gt;
17 Der Herr gab es selbst den Heiligen nicht, all seine Wunder zu erzählen, der Herr der Herrscher über '''das All''', hat sie gegründet, sodass '''das All''' in seiner Herrlichkeit Bestand hat.&lt;br/&gt;
18 Abgrund und Herz hat er durchforscht und ihre Absichten hat er durchschaut; denn der Höchste kennt alles Wissen und er blickt auf die '''Zeichen der Zeiten'''.&lt;br/&gt;
19 Er tut das Vergangene und das Kommende kund und enthüllt die Spuren des Verborgenen.&lt;br/&gt;
20 Kein Gedanke entgeht ihm und kein einziges Wort bleibt ihm verborgen.&lt;br/&gt;
21 Die Großtaten seiner Weisheit hat er geordnet; wie er ist '''von Ewigkeit und in Ewigkeit'''. Ihm ist weder etwas hinzugefügt noch weggenommen worden und er hat keines Ratgebers bedurft.
&lt;/blockquote&gt;

Auch im nachfolgenden Kapitel lobt Jesus Sirach die Sonne, den Mond und die Sterne in den höchsten Tönen:

'''Jesus Sirach 43:'''
&lt;blockquote&gt;
1 Der Stolz der Höhe ist ein '''Firmament''' von Reinheit, die Gestalt des '''Himmels''' beim Anblick der Herrlichkeit.&lt;br/&gt;
2 Die '''Sonne''' verkündet durch ihr Erscheinen beim Aufgang, ein wunderbares Geschöpf, ein Werk des Höchsten!&lt;br/&gt;
3 Zur '''Mittagszeit''' trocknet sie den Boden aus, wer wird bestehen vor ihrer Glut?&lt;br/&gt;
4 Wer in einen Ofen bläst bei Arbeiten mit Glut - dreimal so stark versengt die '''Sonne''' Berge; sie atmet Feuerdämpfe aus und blendet mit gleißenden Strahlen die Augen.&lt;br/&gt;
5 Groß ist der Herr, der sie gemacht hat, mit seinen Worten beschleunigt er ihren Lauf.&lt;br/&gt;
6 Auch der '''Mond''' hält sich in allem an seinen Zeitpunkt, zur '''Festsetzung der Zeiten''' und als Zeichen auf Dauer.&lt;br/&gt;
7 Vom '''Mond''' geht das Zeichen für einen Festtag aus, ein Gestirn, das abnimmt bis zur Vollendung.&lt;br/&gt;
8 Der Name '''Monat''' kommt vom '''Neumond''', der wunderbar zunimmt beim Wechsel, ein Geschöpf des Heeres in der Höhe, das am '''Himmelsgewölbe''' leuchtet.&lt;br/&gt;
9 Die Schönheit des '''Himmels''' ist der Glanz der '''Sterne''', ein strahlender Schmuck in den Höhen des Herrn.&lt;br/&gt;
10 Durch die Worte des Heiligen stehen sie gemäß ihrer Bestimmung und sie ermüden nie bei ihrer Wache.&lt;br/&gt;
...&lt;br/&gt;
27 Vieles werden wir sagen, aber wir kommen nie an ein Ziel und das Ende der Worte ist: Er ist '''das All'''.
&lt;/blockquote&gt;

'''Jesaja 40:'''
&lt;blockquote&gt;
26 Hebt eure Augen in die Höhe und seht: Wer hat diese '''Gestirne''' erschaffen?&lt;br/&gt;
Der vollzählig herausführt ihr Heer, er ruft sie alle beim Namen.&lt;br/&gt;
Wegen seiner Fülle an Kraft und mächtiger Stärke fehlt kein einziges.
&lt;/blockquote&gt;

Das Buch Baruch gehört zu den späten Schriften des Alten Testaments. Im dritten Kapitel werden das Licht und die Sterne in Bezug auf Gott thematisiert:

'''Baruch 3:'''
&lt;blockquote&gt;
33 Er entsendet das '''Licht''' und es eilt dahin; er ruft es zurück und zitternd gehorcht es ihm.&lt;br/&gt;
34 Froh leuchten die '''Sterne''' auf ihren Posten.&lt;br/&gt;
35 Ruft er sie, so antworten sie: Hier sind wir. Sie leuchten mit Freude für ihren Schöpfer.&lt;br/&gt;
36 Das ist unser Gott; kein anderer gilt neben ihm.
&lt;/blockquote&gt;

Ein Lobpreis auf die Werke, Engel und Mächte Gottes am Gewölbe des Himmels findet sich im '''Buch Daniel''' im dritten Kapitel. Der Text macht inhaltlich eine ähnliche Aussage wie der Lobpreis auf den Herrn, den König des Kosmos in Psalm 148 (siehe oben):

'''Daniel 3:'''
&lt;blockquote&gt;
56 Gepriesen bist du am Gewölbe des '''Himmels''', gerühmt und verherrlicht in Ewigkeit.&lt;br/&gt;
57 Preist den HERRN, all ihr Werke des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
58 Preist den HERRN, ihr '''Himmel'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
59 Preist den HERRN, ihr Engel des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
60 Preist den HERRN, all ihr '''Wasser über dem Himmel'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
61 Preist den HERRN, all ihr Mächte des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
62 Preist den HERRN, '''Sonne und Mond'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
63 Preist den HERRN, ihr '''Sterne am Himmel'''; lobt und rühmt ihn in Ewigkeit!
&lt;/blockquote&gt;

=== Der Himmelsthron ===
Der '''Himmelsthron''' wir in vielen Texten des Alten Testaments als der Sitz Gottes genannt. Hier zunächst einige Erwähnungen in den Psalmen:

&lt;blockquote&gt;
11,4 Der HERR ist in seinem heiligen Tempel, der HERR hat seinen '''Thron im Himmel'''.&lt;br/&gt;
Seine Augen schauen herab, seine Blicke prüfen die Menschen.
&lt;/blockquote&gt;

&lt;blockquote&gt;
33,13 Der HERR blickt herab vom '''Himmel''', er sieht alle Menschen.&lt;br/&gt;
33,14 Von seinem '''Thronsitz''' schaut er nieder auf alle Bewohner der Erde.
&lt;/blockquote&gt;

&lt;blockquote&gt;
89,37 Sein Haus soll bleiben auf ewig, sein '''Thron''' habe Bestand vor mir wie die '''Sonne''';
&lt;/blockquote&gt;

&lt;blockquote&gt;
103,19 Der HERR hat seinen '''Thron''' errichtet im '''Himmel''', seine königliche Macht beherrscht '''das All'''.
&lt;/blockquote&gt;

Im Buch der Weisheit stehen die folgenden beiden Verse:

&lt;blockquote&gt;
9,9 Mit dir ist die Weisheit, die deine Werke kennt und die zugegen war, als du die Welt erschufst. Sie weiß, was wohlgefällig ist in deinen Augen und was recht ist nach deinen Geboten.&lt;br/&gt;
9,10 Sende sie vom heiligen '''Himmel''' und schick sie vom '''Thron''' deiner Herrlichkeit, damit sie bei mir sei und alle Mühe mit mir teile und ich erkenne, was wohlgefällig ist bei dir!
&lt;/blockquote&gt;

Diese Bild von Gottes Thron im Himmel wir auch im Neuen Testament aufgegriffen, wie beispielsweise beim Evangelisten Matthäus (Kapitel 5, Vers 34) oder in der Offenbarung des Johannes, wo im vierten Kapitel die eröffnende Himmelsvision mit dem Abschnitt über &quot;Die Huldigung vor dem Thron Gottes&quot; beginnt:

&lt;blockquote&gt;
1 Danach sah ich und siehe, eine Tür war geöffnet am '''Himmel'''; und die erste Stimme, die ich gleich einer Posaune mit mir reden gehört hatte, sagte: Komm herauf und ich werde dir zeigen, was dann geschehen muss.&lt;br/&gt;
2 Sogleich wurde ich vom Geist ergriffen. Und siehe, '''ein Thron stand im Himmel'''; auf dem Thron saß einer,&lt;br/&gt;
3 der wie ein Jaspis und ein Karneol aussah. Und über dem '''Thron''' wölbte sich ein Regenbogen, der wie ein Smaragd aussah.&lt;br/&gt;
4 Und rings um den '''Thron standen vierundzwanzig Throne''' und auf den Thronen saßen vierundzwanzig Älteste, in weiße Gewänder gekleidet und mit goldenen Kränzen auf dem Haupt.&lt;br/&gt;
5 Von dem Thron gingen Blitze, Stimmen und Donner aus. Und '''sieben lodernde Fackeln brannten vor dem Thron; das sind die sieben Geister Gottes'''.&lt;br/&gt;
6 Und vor dem Thron war etwas wie ein gläsernes Meer, gleich Kristall. Und in der Mitte des Thrones und rings um den Thron waren '''vier Lebewesen''' voller Augen, vorn und hinten.&lt;br/&gt;
7 Das erste Lebewesen glich einem '''Löwen''', das zweite einem '''Stier''', das dritte sah aus wie ein '''Mensch''', das vierte glich einem '''fliegenden Adler'''.&lt;br/&gt;
&lt;/blockquote&gt;

Der achtstrophige Adventshymnus ''Veni redemptor gentium'' (die deutschsprachige Kontrafaktur heißt &quot;Nun komm, der Heiden Heiland&quot;) wird dem Kirchenvater Ambrosius von Mailand (339–397) zugeschrieben. In der fünften Strophe wird mit Bezug auf die Himmelfahrt des Messias der Sitz Gottes erwähnt:

&lt;blockquote&gt;
5,1 Egressus eius a Patre,&lt;br/&gt;
5,2 Regressus eius ad Patrem;&lt;br/&gt;
5,3 Excursus usque ad inferos,&lt;br/&gt;
5,4 Recursus ad '''sedem Dei'''.
&lt;/blockquote&gt;

&lt;blockquote&gt;
5,1 Sein Ausgang ist vom Vater,&lt;br/&gt;
5,2 Seine Rückkehr ist beim Vater;&lt;br/&gt;
5,3 Hinausgelaufen bis zu den Toten,&lt;br/&gt;
5,4 Zurückgelaufen bis zum '''Sitz Gottes'''.
&lt;/blockquote&gt;

Es ist nicht viel Phantasie erforderlich, um den Thron Gottes im '''Himmelsstier''' wiederzuerkennen. Die vierundzwanzig Throne, die sich entlang der '''Ekliptik''' um diesen Thron herum aufreihen, stehen für die vierundzwanzig Stunden eines Tages, und sie sind je zwei für jedes der zwölf Lebewesenkreiszeichen des '''Zodiaks'''. Die als sieben lodernde Fackeln vor dem Thron sind die sieben '''Wandelgestirne''', die als die '''sieben Geister Gottes''' immer wieder durch das '''Goldene Tor der Ekliptik''' in der Sitzfläche des Thrones ziehen. Die '''vier besonderen Lebewesen''' sind die vier Evangelistensymbole bei den vier zoroastrischen '''Königssternen'''.

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|'''Himmelsstier''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Die_Ekliptik|'''Ekliptik''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|'''Zodiak''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|'''Goldenes Tor der Ekliptik''']].

→ Siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Vier_in_Religionen|'''Bedeutung der Vier in Religionen''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Königssterne|'''Königssterne''']].

&lt;gallery caption=&quot;Throne&quot; widths=640 heights=480 perrow=3&gt;
StatueOfEl.png|Rekonstruktion der 1988 in Ugarit ausgegrabenen und auf einem Thron sitzenden Statue vom höchsten ugaritischen Gott El, der als Erschaffer der Welt angebetet wurde.
Aachen_Cathedral_Karlsthron_02.jpg|Thron Karls des Großen aus den 790er Jahren im Aachener Dom.
Himmelsthron.Taurus.Aries.png|Himmelsthron in den Sternbildern Stier (Taurus) und Widder (Aries) vor dem Untergang in Richtung Westen.
&lt;/gallery&gt;

=== Das Lamm ===
Im ersten Kapitel des Evangeliums nach Johannes wird Jesus von Nazareth explizit als &quot;Lamm Gottes&quot; bezeichnet:&lt;ref&gt;[https://www.bibleserver.com/EU/Johannes1%2C29 Johannes 1,29], bibleserver.com, Einheitsübersetzung (2016)&lt;/ref&gt;

&lt;blockquote&gt;
29b Seht, das '''Lamm Gottes''', das die Sünde der Welt hinwegnimmt!&lt;br/&gt;
...&lt;br/&gt;
36b Seht, das '''Lamm Gottes'''!
&lt;/blockquote&gt;

Es handelt sich beim „Lamm Gottes“ (Kirchenlatein: „Agnus Dei“) um ein seit ältester Zeit verbreitetes Symbol für Jesus Christus. Es wird auch als das Osterlamm bezeichnet, das am Ostertag, also kurz nach der Tag-und-Nacht-Gleiche im Frühjahr auferstanden ist. Nach dem Evangelisten Markus wurde die Auferstehung „... am ersten Tag der Woche, früh am Morgen, als eben die Sonne aufging“, also am Ostersonntag während der Morgenröte im Osten entdeckt.&lt;ref&gt;[https://www.bibleserver.com/LUT/Markus16%2C2 Markus 16,2], Einheitsübersetzung, 2016&lt;/ref&gt; Am 40.&amp;nbsp;Tag ist Jesus Christus nach dem Zeugnis der Evangelisten Markus und Lukas in den Himmel aufgefahren. Zu Beginn der Apostelgeschichte wird dieses Ereignis folgendermaßen beschrieben:&lt;ref&gt;[https://www.bibleserver.com/EU/Apostelgeschichte1 Apostelgeschichte 1], Einheitsübersetzung, 2016&lt;/ref&gt;

&lt;blockquote&gt;
7 Er sagte zu ihnen: Euch steht es nicht zu, Zeiten und Fristen zu erfahren, die der Vater in seiner Macht festgesetzt hat.&lt;br/&gt;
8 Aber ihr werdet Kraft empfangen, wenn der Heilige Geist auf euch herabkommen wird; und ihr werdet meine Zeugen sein in Jerusalem und in ganz Judäa und Samarien und bis an die Grenzen der Erde.&lt;br/&gt;
9 Als er das gesagt hatte, wurde er vor ihren Augen emporgehoben und eine Wolke nahm ihn auf und entzog ihn ihren Blicken.&lt;br/&gt;
&lt;/blockquote&gt;

Im altrömischen Glaubensbekenntnis gibt es die Textstelle:

&lt;blockquote&gt;
„ascendit in caelis, sedet ad dexteram Patris“
&lt;/blockquote&gt;

Zu Deutsch:

&lt;blockquote&gt;
„aufgefahren in den Himmel, er sitzt zur Rechten des Vaters“
&lt;/blockquote&gt;

Das '''Lamm''' (astronomisch Widder) befindet sich am nördlichen Sternenhimmel '''zur Rechten''' des Stieres (Taurus). Sowohl der mesopotamische Himmelsstier als auch das altarabische Sternbild Thuraya verbinden diese beiden neuzeitlichen Sternbilder zu einer Einheit. Der Hauptstern im Sternbild Widder (Aries) heißt Hamal, und das arabische Wort &quot;hamal&quot; steht für ein einjähriges Lamm.&lt;ref name=&quot;Adams&quot;&gt;Danielle Adams: [http://onesky.arizona.edu/arab-star-names/the-lamb/ The Lamb – A folkloric celestial complex], Two Deserts, one Sky – Arab Star Calendars&lt;/ref&gt; Der fette Schwanz des Lammes wird durch die '''Plejaden (Siebengestirn)''' markiert.&lt;ref name=&quot;Adams&quot; /&gt; Die Augen des Stieres sind die Sterne '''Aldebaran''' und '''Ain'''. Zwischen dem Kopf des Stieres und den '''Plejaden''' befindet sich das '''Goldene Tor der Ekliptik''', durch das alle Wandelgestirne regelmäßig hindurchziehen.

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Bibelstellen|'''Bibelstellen zum Siebengestirn''']].

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|'''Goldenes Tor der Ekliptik''']].

Der Frühlingspunkt der Sonne, also deren Ort auf der Ekliptiklinie zur Tag-und-Nacht-Gleiche im Frühjahr, ist von der monotheistischen Schöpfung bis zur Geburt des christlichen Gottessohns vom Kopf des Stiers (bei den Sternen '''Aldebaran''' und '''Ain''' im Goldenen Tor der Ekliptik) im heutigen Sternbild Stier (Taurus) bis zum Kopf des Lammes (beim Stern '''Hamal''') im heutigen Sternbild Widder (Aries) nach Westen gewandert. Heute befindet sich der Frühlingspunkt bereits am westlichen Ende des Sternbilds Fische (Pisces), das sich westlich an das Sternbild Widder anschließt.

==== Offenbarung des Johannes ====
In der Offenbarung des Johannes heißt es im 7.&amp;nbsp;Kapitel:

&lt;blockquote&gt;
10b Die Rettung kommt von unserem '''Gott''', der auf dem '''Thron''' sitzt, und von dem '''Lamm'''.&lt;br/&gt;
17a Denn das Lamm in der Mitte vor dem Thron wird sie weiden und zu den Quellen führen, aus denen das '''Wasser des Lebens''' strömt.
&lt;/blockquote&gt;

Wird der '''Thron Gottes''' mit dem Himmelsstier identifiziert (siehe oben), dann sitzt das '''Lamm''' (Aries, Sternbild Widder) westlich und somit rechts vor diesem Thron. Im weiteren Verlauf der Ekliptik nach Westen befinden sich die zusammenhängenden '''Wassersternbilder''' des Urozeans, dem Urquell des Lebens. Es handelt ich um die heutigen Sternbilder Fluss Eridanus, Walfisch (Cetus), Fische (Pisces), Wassermann (Aquarius), Südlicher Fisch (Piscis Austrinus) und Delphin (Delphinus) sowie Steinbock (Capricornus, früher Ziegenfisch).

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Urozean''']].

&lt;gallery caption=&quot;Das Lamm zur Rechten des Stieres&quot; mode=packed widths=800 heights=600&gt;
Himmelsstier.P1117152.jpg|Astrophotographie vom Asterismus Himmelsstier
Himmelsstier.Sternbilder.P1117152.png|Beschriftete Astrophotographie vom Himmelsstier am winterlichen Abendhimmel in Richtung südlicher Meridian. Die Ekliptiklinie verläuft horizontal etwas unterhalb der Bildmitte.
Haende.der.Thuraya.Vollmond.Sterne.P1079912.jpg|Astrophotographie der Himmelsregion mit dem beduinischen Sternbild &quot;Hände der Thuraya&quot; (grüne durchgezogene Linien, Ekliptik rot gepunktete Linie) mit arabisch bezeichneten Sternen. Der Vollmond befindet sich zwischen den Sternbildern Taurus, Aries und Cetus.
Urozean.Wassersternbilder.png|Die zusammenhängenden Wassersternbilder des Urozeans am Sternenhimmel: Fluss Eridanus, Walfisch (Cetus), Fische (Pisces), Wassermann (Aquarius), Südlicher Fisch (Piscis Austrinus), Delphin (Delphinus) sowie Ziegenfisch (Steinbock, Capricornus).
&lt;/gallery&gt;

Interpretiert man das Sternbild &quot;Lamm&quot; (Widder / Aries) als Mittler auf dem ekliptischen Weg vom finsteren kosmischen Urozean im Westen (rechts) zum strahlenden majestätischen Sternbild Stier (Taurus) im Osten (links), ergeben auch andere Bibelstellen in Bezug auf den Sternenhimmel einen tiefen symbolischen Sinn, die in den folgenden Abschnitten aufgeführt sind.

==== Evangelium nach Johannes ====
Die Rede von Jesus an den Jünger Thomas aus dem 14.&amp;nbsp;Kapitel des Evangeliums nach Johannes ist in diesem Zusammenhang interessant:

&lt;blockquote&gt;
6 Jesus sagte zu ihm: Ich bin der Weg und die Wahrheit und das Leben; niemand kommt zum Vater außer durch mich.&lt;br/&gt;
7 Wenn ihr mich erkannt habt, werdet ihr auch meinen Vater erkennen. Schon jetzt kennt ihr ihn und habt ihn gesehen.
&lt;/blockquote&gt;

Alle Wandelgestirne bewegen sich entlang der Ekliptiklinie (Weg) durch das heutige Sternbild Widder (das altarabische Sternbild &quot;Lamm&quot;) im Westen zum [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der-Ekliptik|Goldenen Tor der Ekliptik]] nach Osten im großen Himmelsstier (Vater / Thron).

==== Evangelium nach Markus ====
Im Evangelium nach Markus heißt es:

&lt;blockquote&gt;
14,62 Jesus sagte: Ich bin es. Und ihr werdet den Menschensohn '''zur Rechten der Macht''' sitzen und mit den Wolken des '''Himmels''' kommen sehen.
&lt;/blockquote&gt;

&lt;blockquote&gt;
16,19 Nachdem Jesus, der Herr, dies zu ihnen gesagt hatte, wurde er in den '''Himmel''' aufgenommen und setzte sich '''zur Rechten Gottes'''.
&lt;/blockquote&gt;

==== Evangelium nach Lukas ====
Im Evangelium nach Lukas ist es folgendermaßen formuliert:

&lt;blockquote&gt;
22,69 Von nun an wird der Menschensohn '''zur Rechten der Macht Gottes''' sitzen.
&lt;/blockquote&gt;

==== Evangelium nach Matthäus ====
Auch im Evangelium nach Matthäus findet sich eine entsprechende Stelle:

&lt;blockquote&gt;
26,64 Jesus antwortete: Du hast es gesagt. Doch ich erkläre euch: Von nun an werdet ihr den Menschensohn '''zur Rechten der Macht''' sitzen und auf den Wolken des '''Himmels''' kommen sehen.
&lt;/blockquote&gt;

==== Brief an die Hebräer ====
Im Brief an die Hebräer, dessen Autor unbekannt ist, gibt es etliche entsprechende Stellen:

&lt;blockquote&gt;
'''Gottes Rede in seinem Sohn'''&lt;br/&gt;
1,3 er ist der Abglanz seiner Herrlichkeit und das Abbild seines Wesens; er trägt '''das All''' durch sein machtvolles Wort, hat die Reinigung von den Sünden bewirkt und sich dann '''zur Rechten der Majestät in der Höhe''' gesetzt;&lt;br/&gt;
1,10 Und: Du, Herr, hast vorzeiten der Erde Grund gelegt, die '''Himmel''' sind das Werk deiner Hände.&lt;br/&gt;
1,11 Sie werden vergehen, '''du aber bleibst'''; sie alle veralten wie ein Gewand;&lt;br/&gt;
1,12 du rollst sie zusammen wie einen Mantel und wie ein Gewand werden sie gewechselt. Du aber bleibst, der du bist, und '''deine Jahre enden nie'''.&lt;br/&gt;
1,13 Zu welchem Engel hat er jemals gesagt: Setze dich mir '''zur Rechten''' und ich lege dir deine Feinde als Schemel unter die Füße?
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Die Liturgie des neuen Bundes'''&lt;br/&gt;
8,1 Die Hauptsache bei dem Gesagten aber ist: Wir haben einen solchen Hohepriester, der sich '''zur Rechten des Thrones der Majestät im Himmel''' gesetzt hat,&lt;br/&gt;
8,2 als Diener des Heiligtums und des '''wahren Zeltes''', das der Herr selbst aufgeschlagen hat, nicht ein Mensch.
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Christus als Mittler des neuen Bundes'''&lt;br/&gt;
9,24 Denn Christus ist nicht in ein von Menschenhand gemachtes Heiligtum hineingegangen, in ein Abbild des wirklichen, sondern '''in den Himmel selbst''', um jetzt '''vor Gottes Angesicht''' zu erscheinen für uns;
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Das Opfer Jesu Christi als endgültige Versöhnung mit Gott'''&lt;br/&gt;
10,12 Dieser aber hat nur ein einziges Opfer für die Sünden dargebracht und sich dann '''für immer zur Rechten Gottes''' gesetzt;
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Das Beispiel Jesu Christi'''&lt;br/&gt;
12,2 und dabei auf Jesus blicken, den Urheber und Vollender des Glaubens; er hat angesichts der vor ihm liegenden Freude das Kreuz auf sich genommen, ohne auf die Schande zu achten, und sich '''zur Rechten von Gottes Thron''' gesetzt.
&lt;/blockquote&gt;

==== Erster Brief des Petrus ====
Der erste Brief des Petrus zählt zu den katholischen Briefen des Neuen Testaments. Dort heißt es im letzten Satz über Jesus Christus:

&lt;blockquote&gt;
22 der in den '''Himmel''' gegangen ist; dort ist er '''zur Rechten''' Gottes und Engel, Gewalten und Mächte sind ihm unterworfen.
&lt;/blockquote&gt;

==== Apostelgeschichte ====
Die Apostelgeschichte schließt an das Evangelium nach Lukas an und wird ebenfalls diesem zugeschrieben. Hier kommen der erste bekennende sowie erste berufene Apostel Petrus und der erste christliche Märtyrer Stephanus zu Wort:

&lt;blockquote&gt;
'''Die Pfingstpredigt des Petrus'''&lt;br/&gt;
2,33 '''Zur Rechten Gottes''' erhöht, hat er vom Vater den verheißenen Heiligen Geist empfangen und ihn ausgegossen, wie ihr seht und hört.
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Steinigung des Stephanus'''&lt;br/&gt;
7,55 Er aber, erfüllt vom Heiligen Geist, blickte zum '''Himmel''' empor, sah die Herrlichkeit Gottes und Jesus '''zur Rechten Gottes''' stehen&lt;br/&gt;
7,56 und rief: Siehe, ich sehe den Himmel offen und den Menschensohn '''zur Rechten Gottes''' stehen.
&lt;/blockquote&gt;

=== Himmelspforte ===
Das Sternbild Widder (Aries) repräsentiert als das Lamm Gottes den nördlichen Pfeiler des Goldenen Tors der Ekliptik. Der fette Schwanz des Lammes wird nach altarabischer Tradition durch das Siebengestirn (Plejaden) gebildet, das heute zu Sternbild '''Stier''' (Taurus) gezählt wird. Der südliche Pfeiler des Goldenen Tors der Ekliptik wird durch die Hyaden und den Stern Menkar im Sternbild Walfisch (Cetus) gebildet. Das Goldene Tor der Ekliptik stellt mit diesen beiden Pfeilern somit eine '''Himmelspforte''' dar, durch die alle Wandelgestirne regelmäßig von Westen aus dem dunklen Urozean der winterlichen Wassersternbilder sowie der Richtung des Sonnenuntergangs nach Osten in das helle Gebiet des Sternenhimmels mit den Frühlings- und Sommersternbildern sowie die Richtung des Sonnenaufgangs treten.

[[Datei:Mars.im.Goldenen.Tor.der.Ekliptik.P1091607.jpg|mini|hochkant=3|zentriert|Der am nordwestlichen Horizont in der Nähe der Ekliptiklinie und im Goldenen Tor der Ekliptik untergehende Mars (rote Scheibe unten halb rechts) drei Tage vor dem Durchqueren der '''Himmelspforte''' zwischen dem Kopf des Himmelsstieres mit dem Sternhaufen der Hyaden (unten links) und den Plejaden nördlich der Ekliptik (rechts unten).]]

Die Genesis berichtet im 28.&amp;nbsp;Kapitel unter der Überschrift &quot;Jakob in Bet-El&quot; (hebräisch בֵּית אֵל „Haus des El“ oder „Haus Gottes“) über einen Traum von Jakob, in dem er eine Treppe zum Himmel (die Himmelsleiter oder Jakobsleiter) sieht, an dessen oberen Ende sich das Tor des Himmels (die Himmelspforte) befindet:

&lt;blockquote&gt;
10 Jakob zog aus Beerscheba weg und ging nach Haran.&lt;br/&gt;
11 Er kam an einen bestimmten Ort und übernachtete dort, denn die Sonne war untergegangen. Er nahm einen von den Steinen dieses Ortes, legte ihn unter seinen Kopf und schlief dort ein.&lt;br/&gt;
12 Da hatte er einen Traum: Siehe, eine Treppe stand auf der Erde, ihre Spitze reichte bis zum '''Himmel'''. Und siehe: Auf ihr stiegen Engel Gottes auf und nieder.&lt;br/&gt;
13 Und siehe, der HERR stand vor ihm und sprach: Ich bin der HERR, der Gott deines Vaters Abraham und der Gott Isaaks. Das Land, auf dem du liegst, will ich dir und deinen Nachkommen geben.&lt;br/&gt;
14 Deine Nachkommen werden zahlreich sein wie der Staub auf der Erde. Du wirst dich '''nach Westen und Osten, nach Norden und Süden''' ausbreiten und durch dich und deine Nachkommen werden alle Sippen der Erde Segen erlangen.&lt;br/&gt;
15 Siehe, ich bin mit dir, ich behüte dich, wohin du auch gehst, und bringe dich zurück in dieses Land. Denn ich verlasse dich nicht, bis ich vollbringe, was ich dir versprochen habe.&lt;br/&gt;
16 Jakob erwachte aus seinem Schlaf und sagte: Wirklich, der HERR ist an diesem Ort und ich wusste es nicht.&lt;br/&gt;
17 Er fürchtete sich und sagte: Wie Ehrfurcht gebietend ist doch dieser Ort! Er ist nichts anderes als das Haus Gottes und das '''Tor des Himmels'''.&lt;br/&gt;
&lt;/blockquote&gt;

El war für die semitischen Ugariter im zweiten vorchristlichen Jahrtausend der Name ihres höchsten Gottes. Ihm wurden die Beinamen „König“, „Freundlicher“ und „'''Stier'''“ verliehen. Diese Symbolik weist auf den Himmelsstier hin. Der Name El wurde von den Israeliten übernommen, und dieser Gott wurde von ihnen mit ihrem einzigen Gott gleichgesetzt.

Jakob war der der erste der drei Erzväter des Volkes Israel und der älteste Sohn des ältesten Sohnes Isaak von Abraham. Abraham war aus dem mesopotamischen Ur über Haran nach Bet-El gezogen, und Jakob ging in dieser Schilderung aus Beerscheba in der Nähe des Ortes Bet-El nach Haran zurück.

Der Apostel Paulus schreibt in seinem zweiten Brief an die Bewohner der griechischen Hafenstadt Korinth zu Beginn des 5.&amp;nbsp;Kapitels mit der Überschrift &quot;Die Hoffnung des Apostels&quot; über das Gebäude hinter der Pforte zum Himmel:

&lt;blockquote&gt;
1 Wir wissen: Wenn unser irdisches Zelt abgebrochen wird, dann haben wir eine Wohnung von Gott, ein nicht von Menschenhand errichtetes '''ewiges Haus im Himmel'''.
&lt;/blockquote&gt;

=== Gedanken zur wundersamen Brotvermehrung ===
==== Evangelien ====
[[Datei:Face de chapiteau figurant la Multiplication des pains, choeur de l'église de Saint-Nectaire, Puy-de-Dôme.jpg|mini|rechts|hochkant=2|Jesus mit vier seiner Jünger mit fünf Broten und zwei Fischen an einem Säulenkapitell in der romanischen Wallfahrtskirche Saint Nectaire auf dem Mont Cornadore in Saint-Nectaire in Frankreich (Département Puy-de-Dôme in der Region Auvergne-Rhône-Alpes).]]

Die wundersame Speisung der mehreren Tausend mit wenigen Broten und Fischen wird in aller vier Evangelien der Bibel erwähnt. Das Ereignis fand auf einem Berg am Ufer des Sees von Galiläa (auch als &quot;See von Tiberias&quot;, &quot;See Genezareth&quot; oder &quot;Galiläisches Meer&quot; bekannt) statt. In der abgelegenen Gegend gab es damals sehr wenig künstliche Lichtquellen, so dass ein ungestörter Anblick des Sternenhimmels möglich war.

===== Evangelium nach Johannes =====
Im sechsten Kapitel des Evangeliums nach '''Johannes''' tauchen bei der Beschreibung der Brotvermehrung durch Jesus zum jüdischen Pessachfest neben einigen weiteren Symbolen mit astronomischer Deutungsmöglichkeit auch die expliziten Zahlen Zwei, Fünf und Zwölf auf:

&lt;blockquote&gt;
9 Hier ist ein kleiner Junge, der hat '''fünf Gerstenbrote''' und '''zwei Fische'''; doch was ist das für so viele?&lt;br/&gt;
10 Jesus sagte: Lasst die Leute sich setzen! Es gab dort nämlich viel Gras. Da setzten sie sich; es waren etwa '''fünftausend''' Männer.&lt;br/&gt;
11 Dann nahm Jesus die '''Brote''', sprach das Dankgebet und teilte an die Leute aus, so viel sie wollten; ebenso machte er es mit den '''Fischen'''.&lt;br/&gt;
12 Als die Menge satt geworden war, sagte er zu seinen Jüngern: Sammelt die übrig gebliebenen Brocken, damit nichts verdirbt!&lt;br/&gt;
13 Sie sammelten und füllten '''zwölf Körbe''' mit den Brocken, die von den '''fünf Gerstenbroten''' nach dem Essen übrig waren.&lt;br/&gt;
...&lt;br/&gt;
31 Unsere Väter haben das '''Manna''' in der Wüste gegessen, wie es in der Schrift heißt: '''Brot vom Himmel''' gab er ihnen zu essen.&lt;br/&gt;
32 Jesus sagte zu ihnen: Amen, amen, ich sage euch: Nicht Mose hat euch das '''Brot vom Himmel''' gegeben, sondern mein Vater gibt euch das wahre '''Brot vom Himmel'''.&lt;br/&gt;
33 Denn das '''Brot''', das Gott gibt, kommt vom '''Himmel''' herab und gibt der Welt das Leben.&lt;br/&gt;
34 Da baten sie ihn: Herr, gib uns immer dieses '''Brot'''!&lt;br/&gt;
35 Jesus antwortete ihnen: Ich bin das '''Brot des Lebens'''; wer zu mir kommt, wird nie mehr hungern, und wer an mich glaubt, wird nie mehr Durst haben.&lt;br/&gt;
...&lt;br/&gt;
48 Ich bin das '''Brot des Lebens'''.&lt;br/&gt;
49 Eure Väter haben in der Wüste das '''Manna''' gegessen und sind gestorben.&lt;br/&gt;
50 So aber ist es mit dem '''Brot''', das vom '''Himmel''' herabkommt: Wenn jemand davon isst, wird er nicht sterben.&lt;br/&gt;
51 Ich bin das '''lebendige Brot''', das vom '''Himmel''' herabgekommen ist. Wer von diesem '''Brot''' isst, wird in Ewigkeit leben. Das '''Brot''', das ich geben werde, ist mein Fleisch für das Leben der Welt.
&lt;/blockquote&gt;

===== Evangelium nach Markus =====
Eine ähnliche Schilderung befindet sich im sechsten Kapitel des Evangeliums nach '''Markus''', wo das Ereignis an einem abgelegenen und einsamen Ort stattgefunden hat:

&lt;blockquote&gt;
38 Er sagte zu ihnen: Wie viele '''Brote''' habt ihr? Geht und seht nach! Sie sahen nach und berichteten: '''Fünf Brote''' und außerdem '''zwei Fische'''.&lt;br/&gt;
39 Dann befahl er ihnen, sie sollten sich in Mahlgemeinschaften im grünen Gras lagern.&lt;br/&gt;
40 Und sie ließen sich in Gruppen zu hundert und zu fünfzig nieder.&lt;br/&gt;
41 Darauf nahm er die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis, brach die '''Brote''' und gab sie den Jüngern, damit sie diese an die Leute austeilten. Auch die '''zwei Fische''' ließ er unter allen verteilen.&lt;br/&gt;
42 Und alle aßen und wurden satt.&lt;br/&gt;
43 Und sie hoben Brocken auf, '''zwölf Körbe''' voll, und Reste von den '''Fischen'''.&lt;br/&gt;
44 Es waren '''fünftausend''' Männer, die von den '''Broten''' gegessen hatten.
&lt;/blockquote&gt;

Die Brotvermehrung auch ein weiteres Mal im achten Kapitel des Evangeliums nach '''Markus''' erwähnt:

&lt;blockquote&gt;
5 Er fragte sie: Wie viele '''Brote''' habt ihr? Sie antworteten: '''Sieben'''.&lt;br/&gt;
6 Da forderte er die Leute auf, sich auf den Boden zu setzen. Dann nahm er die sieben '''Brote''', sprach das Dankgebet, brach die '''Brote''' und gab sie seinen Jüngern zum Verteilen; und die Jünger teilten sie an die Leute aus.&lt;br/&gt;
7 Sie hatten auch noch ein paar '''Fische''' bei sich. Jesus segnete sie und ließ auch sie austeilen.&lt;br/&gt;
8 Die Leute aßen und wurden satt. Und sie hoben die Überreste der '''Brotstücke''' auf, '''sieben Körbe''' voll.&lt;br/&gt;
9 Es waren etwa '''viertausend''' Menschen beisammen. Danach schickte er sie nach Hause.&lt;br/&gt;
...&lt;br/&gt;
19 Als ich die '''fünf Brote''' für die '''Fünftausend''' brach, wie viele '''Körbe voll Brotstücke''' habt ihr da aufgehoben? Sie antworteten ihm: '''Zwölf'''.&lt;br/&gt;
20 Und als ich die '''sieben Brote''' für die '''Viertausend''' brach, wie viele '''Körbe''' voll habt ihr da aufgehoben? Sie antworteten: '''Sieben'''.&lt;br/&gt;
21 Da sagte er zu ihnen: Versteht ihr immer noch nicht?
&lt;/blockquote&gt;

===== Evangelium nach Lukas =====
Ebenso verhält es sich im neunten Kapitel des Evangeliums nach '''Lukas''', wo das Ereignis dem Ort Betsaida (zu Deutsch: „Haus des Fisches“) am See Genezareth zugeordnet ist:

&lt;blockquote&gt;
12 Als der Tag zur Neige ging, kamen '''die Zwölf''' und sagten zu ihm: Schick die Leute weg, damit sie in die umliegenden Dörfer und Gehöfte gehen, dort Unterkunft finden und etwas zu essen bekommen; denn wir sind hier an einem abgelegenen Ort.&lt;br/&gt;
13 Er antwortete ihnen: Gebt ihr ihnen zu essen! Sie sagten: Wir haben nicht mehr als '''fünf Brote''' und '''zwei Fische'''; wir müssten erst weggehen und für dieses ganze Volk etwas zu essen kaufen.&lt;br/&gt;
14 Es waren nämlich etwa '''fünftausend''' Männer. Er aber sagte zu seinen Jüngern: Lasst sie sich in Gruppen zu ungefähr fünfzig lagern!&lt;br/&gt;
15 Die Jünger taten so und veranlassten, dass sich alle lagerten.&lt;br/&gt;
16 Jesus aber nahm die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis und brach sie; dann gab er sie den Jüngern, damit sie diese an die Leute austeilten.&lt;br/&gt;
17 Und alle aßen und wurden satt. Als man die übrig gebliebenen Brotstücke einsammelte, waren es '''zwölf Körbe''' voll.
&lt;/blockquote&gt;

===== Evangelium nach Matthäus =====
Auch im vierzehnten Kapitel des Evangeliums nach '''Matthäus''' ist von einem abgelegenen Ort in einer einsamen Gegend die Rede:

&lt;blockquote&gt;
17 Sie sagten zu ihm: Wir haben nur '''fünf Brote''' und '''zwei Fische''' hier.&lt;br/&gt;
18 Er antwortete: Bringt sie mir her!&lt;br/&gt;
19 Dann ordnete er an, die Leute sollten sich ins Gras setzen. Und er nahm die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis, brach die Brote und gab sie den Jüngern; die Jünger aber gaben sie den Leuten&lt;br/&gt;
20 und alle aßen und wurden satt. Und sie sammelten die übrig gebliebenen Brotstücke ein, '''zwölf Körbe''' voll.&lt;br/&gt;
21 Es waren etwa '''fünftausend''' Männer, die gegessen hatten, dazu noch Frauen und Kinder.
&lt;/blockquote&gt;

Etwas abgewandelt taucht die Brotvermehrung mit '''sieben Körben''' auch im fünfzehnten Kapitel des Evangeliums nach '''Matthäus''' auf:

&lt;blockquote&gt;
34 Jesus sagte zu ihnen: Wie viele '''Brote''' habt ihr? Sie antworteten: '''Sieben''' - und ein paar '''Fische'''.&lt;br/&gt;
35 Da forderte er die Leute auf, sich auf den Boden zu setzen.&lt;br/&gt;
36 Und er nahm die '''sieben Brote''' und die '''Fische''', sprach das Dankgebet, brach sie und gab sie den Jüngern und die Jünger gaben sie den Menschen.&lt;br/&gt;
37 Und alle aßen und wurden satt. Und sie sammelten die übrig gebliebenen Stücke ein, '''sieben Körbe''' voll.&lt;br/&gt;
38 Es waren '''viertausend''' Männer, die gegessen hatten, dazu noch Frauen und Kinder.&lt;br/&gt;
39 Danach schickte er die Menge nach Hause, stieg ins Boot und fuhr in die Gegend von Magadan.
&lt;/blockquote&gt;

Der Ort Magadan ist möglicherweise mit dem heutigen Ort Migdal (aramäisch: Magdala) am westlichen Ufer des Sees Genezareth gleichzusetzen.

==== Astronomische Bezüge ====
[[Datei:Sternenhimmel.Pessach.25.3.23.png|mini|rechts|hochkant=2|Sternenhimmel am jüdischen Pessachfest im Jahr 25 nach Christus. Der Vollmond stand hoch über dem Horizont im Süden im Herbstpunkt beim Stern Spica (= &quot;Kornähre&quot;) im Sternbild Jungfrau (Virgo). Gleichzeitig befand sich die Sonne tief unter dem Horizont im Norden in der Nähe des Frühlingspunktes im Sternbild Fische (Pisces).]]
[[Datei:Dendera.09.Jungfrau.Loewe.jpg|mini|rechts|hochkant=2|Das Sternbild Jungfrau (links) mit der Kornähre in der Hand und das Sternbild Löwe (rechts) im ägyptischen Zodiak von Dendera aus der Zeit kurz vor Christi Geburt.]]
[[Datei:Dendera.03.Fische.Wassermann.jpg|mini|rechts|hochkant=2|Das Sternbild Fische (links) und das Sternbild Wassermann (rechts unten) im ägyptischen Zodiak von Dendera aus der Zeit kurz vor Christi Geburt.]]

Zu diesen Bibelstellen sind im Folgenden einige Hinweise mit astronomischen Bezügen aufgeführt. Die [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|Bezugspunkte]] liegen hierbei in der Nähe der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Die_Ekliptik|Ekliptik]]:

* In den Versen im Evangelium nach Johannes ist mehrfach vom '''Brot, das vom Himmel herabkommt''' die Rede.
* Das zur Herstellung von Brot erforderliche Getreide kann durch eine '''Kornähre''' symbolisiert werden. Am Sternenhimmel wird die Kornähre durch den hellen, ekliptiknahen Stern '''Spica''' (α Virginis) im Sternbild '''Jungfrau''' (Virgo) repräsentiert. Der Vollmond stand zum jüdischen Pessachfest beim Stern Spica.
* Alle Pflanzen benötigen für das Gedeihen '''Wasser'''. Das '''Wasser''' wird am Himmel durch die drei Wassersternbilder der Ekliptik '''Fische''' (Pisces), '''Wassermann''' (Aquarius), und '''Ziegenfisch''' (Steinbock, Capricornus) westlich des [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Frühlingspunkt|Frühlingspunktes]] repräsentiert. Diese Sternbilder bilden mit einigen weiteren angrenzenden Wassersternbildern den [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|Urozean am Himmel]] (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Trichter_der_Thuraya|Der Trichter der Thuraya]]). Die Wassersternbilder waren zum Pessachfest in den drei Monaten unmittelbar zuvor von der Sonne durchlaufen worden und befanden sich beim Sonnenuntergang deshalb bereits unterhalb des westlichen Horizonts.
* Das Sternbild '''Fische''' (Pisces) besteht seit der Antike aus '''zwei Fischen'''.
* Zu Lebzeiten von Jesus von Nazareth war der '''Frühlingspunkt''' vom Sternbild Widder (Aries, ursprünglich das Hinterteil des großen Sternbilds [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|Himmelsstier (Taurus caeli)]]) in das Sternbild '''Fische''' (Pisces) gewandert. Inzwischen ist er innerhalb dieses Sternbilds noch weiter nach Westen gewandert. Die Sonne und der Neumond standen zu Beginn des jüdischen Monats Nisan, also dem Monat des jüdischen Pessachfestes, im Sternbild '''Fische'''. Der erste Monat des Jahres Nisan hieß bereits in der mesopotamischen Tradition, als sich der Frühlingspunkt noch im Sternbild Widder (Aries) befand, auf Akkadisch &quot;nisannu&quot; (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|Plejaden-Schaltregeln]]). In der alten jüdischen Tradition war der Nisan deswegen mit dem Sternbild Widder verbunden. Ferner wurde der Widder dem israelitischen Stamm Juda zugeordnet.
* Zu Lebzeiten von Jesus von Nazareth war der '''Herbstpunkt''' vom Sternbild Waage (Libra, ursprünglich die Scheren des großen Sternbilds [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsskorpion|Himmelsskorpion (Scorpio caeli)]]) in das Sternbild Jungfrau (Virgo) gewandert. Inzwischen ist er innerhalb dieses Sternbilds noch weiter nach Westen gewandert. Um 285 nach Christi erreichte der '''Herbstpunkt''' dann die ekliptikale Länge des Sterns '''Spica''' (α Virginis).
* Der '''Frühlingspunkt''' –&amp;nbsp;damals im Sternbild Fische&amp;nbsp;– und der '''Herbstpunkt''' –&amp;nbsp;damals im Sternbild Jungfrau (Virgo) beim Stern Spica&amp;nbsp;– befinden sich immer in genau gegenüber liegenden Punkten auf der Ekliptik. Auf diese Weise umfassen diese beiden ausgezeichneten Punkte den Lebewesenkreis (Zodiak) mit seinen '''zwölf''' Sternbildern sowie die Bahnen aller '''sieben''' Wandelgestirne. Diese beiden Punkte teilten die Ekliptik in '''zwei''' gleichgroße Teile, das Sommerhalbjahr und das Winterhalbjahr. Siehe hierzu auch &quot;[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|Beobachtungen in der Nähe der Ekliptik]]&quot;.
** Die '''fünf Brote''' können also mit den fünf mit bloßem Auge sichtbaren Wandelgestirnen (Planeten) '''Merkur''', '''Venus''', '''Mars''', '''Jupiter '''und '''Saturn''' gleichgesetzt werden.&lt;br/&gt;'''''Anmerkung''': In der Bibel wird in der Regel nicht zwischen Fixsternen und Planeten unterschieden. Für eine Ausnahme siehe 2.&amp;nbsp;Buch der Könige, Kapitel 23, Vers 5 aus dem siebenten vorchristlichen Jahrhundert, wo in der Einheitsübersetzung explizit von &quot;den Wandelsternen&quot; und in der Luther-Bibel von &quot;den Planeten&quot; die Rede ist.&lt;ref&gt;[https://www.bibleserver.com/EU/2.K%C3%B6nige23%2C5 2.&amp;nbsp;Buch der Könige, Kapitel 23, Vers 5], bibleserver.com, Einheitsübersetzung 2016&lt;/ref&gt; Die Vulgata schreibt hier allerdings von den &quot;duodecim signis&quot; (zu Deutsch: &quot;'''zwölf''' Zeichen&quot;), womit die '''zwölf''' Sternzeichen der Ekliptik gemeint sind, durch die die '''sieben''' Wandelgestirne ziehen. Die Septuaginta spricht noch allgemeiner von den &quot;μαζουρωθ&quot; (&quot;mazuroth&quot;) nach dem Hebräischen Wort &quot;מַזָּלָה&quot; (&quot;mazzaroth&quot;), womit allgemein eher Sternkonstellationen und nur im engeren Sinne die Sternzeichen des Zodiaks gemeint sind.''
** Die '''zwei Fische''' können also mit den beiden flächenhaft wahrnehmbaren Wandelgestirnen '''Sonne''' und '''Mond '''gleichgesetzt werden.
** Die Summe der '''fünf Brote''' und der '''zwei Fische''' respektive die '''sieben Brote''' (oder die '''sieben Körbe''') entsprechen der Anzahl der freiäugig sichtbaren '''sieben Wandelgestirne''', die sich entlang der Ekliptiklinie stetig gegenüber dem Fixsternhimmel bewegen. Siehe hierzu auch &quot;[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Zusammenhang_mit_dem_Stier|Zu den Etyma und den Kognaten von &quot;Sieben&quot;, &quot;Stier&quot;, &quot;Gestirn&quot; und &quot;Stern&quot;]]&quot;.
** Die ausgeteilten '''Brote''' und '''Fische''' durchmaßen die gesamte versammelte Menschenmenge, die durch den vollständigen [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|Lebewesenkreis (Zodiak)]] mit den '''zwölf Lebewesenkreiszeichen''' beziehungsweise durch die '''zwölf Körbe''' symbolisiert wird. Der Planet Jupiter, der den Zodiak in zwölf Jahren einmal durchläuft, wurde in Babylonien mit dem babylonischen Hauptgott Marduk gleichgesetzt.
* Insgesamt gibt es am Fixsternhimmel gut 2800&amp;nbsp;Sterne bis zur scheinbaren Helligkeit 5,5&lt;sup&gt;m&lt;/sup&gt; und knapp 8800&amp;nbsp;Sterne bis zur scheinbaren Helligkeit&amp;nbsp;6,5&lt;sup&gt;m&lt;/sup&gt;, die ohne Lichtverschmutzung mit bloßem Auge als einzelne Lichtpunkte gesehen werden können. Diese verteilen sich allerdings in der gesamten Himmelssphäre, so dass von einem Punkt auf der Erdoberfläche aus zu jedem Zeitpunkt immer nur ungefähr die Hälfte davon über dem Horizont steht. An den beiden Polen sind stets nur die Sterne der jeweiligen nördlichen oder südlichen Hemisphäre zu sehen, und am Äquator können im Laufe eines Jahres alle Sterne gesehen werden. Je nach Breitengrad und Zeitpunkt können bei Neumond (kein Streulicht) innerhalb einer wolkenlosen Nacht viertausend bis zu fast siebentausend Sterne beobachtet werden.&lt;ref&gt;Bob King: [https://skyandtelescope.org/astronomy-blogs/how-many-stars-night-sky-09172014/ 9,096 Stars in the Sky—Is that all? How many stars in the sky can you see?], skyandtelescope.org - The essential Guide to Astronomy, 17. September 2014&lt;/ref&gt; Diese Spanne entspricht der Angabe der bei der Brotvermehrung versammelten Menschen, deren Anzahl in den Evangelien mit '''viertausend''' beziehungsweise '''fünftausend''' angegeben ist.
** Im ersten Buch des Alten Testaments ('''Genesis''') wird Abram aus Ur in Mesopotamien bereits das Folgende prophezeit:
&lt;blockquote&gt;
15,5 ''Sieh doch zum Himmel hinauf und zähl die Sterne, wenn du sie zählen kannst! Und er sprach zu ihm: So zahlreich werden deine Nachkommen sein''&lt;br/&gt;
...&lt;br/&gt;
17,5 ''Man wird dich nicht mehr Abram nennen. Abraham, Vater der Menge, wird dein Name sein; denn zum Stammvater einer Menge von Völkern habe ich dich bestimmt.''
&lt;/blockquote&gt;
* Die Gruppen von (ungefähr) '''fünfzig''' oder '''hundert Männern''' entsprechen den Sternbildern, die über den gesamten Himmel verteilt sind. Nach der Festlegung der Internationalen Astronomischen Union (IAU) von 1930 gibt es heute 88&amp;nbsp;Sternbilder, die den Himmel vollständig abdecken. Mit den maximal fast 8800&amp;nbsp;freiäugig sichtbaren Sternen entspricht dies im Mittel also 100&amp;nbsp;Sternen pro Sternbild. Bei 4400&amp;nbsp;freiäugig sichtbaren Sternen wären es 50&amp;nbsp;Sterne pro Sternbild. Dies entspricht genau der Spanne der Gruppenstärke, die im Neuen Testament angegeben sind.
* Das '''Brot''' und der '''Wein''' werden nach der christlichen Lehre bei der Transsubstantiation in den Leib und das Blut des vom '''Himmel''' herabgekommenen &quot;Brot des Lebens&quot; (vergleiche die Rede über das Himmelsbrot von Jesus in der Synagoge von Kafarnaum in Evangelium nach Johannes 6,48–58) gewandelt, das die kosmische Ewigkeit verheißt.

Die Zahlen '''Zwei''', '''Fünf''', '''Sieben''' und '''Zwölf''' stehen in einem einfachen arithmetischen Zusammenhang, bei dem die beiden jeweils vorhergehenden Zahlen der Folge addiert werden:

{| class=&quot;wikitable&quot;
|+
|'''Zahl'''
|'''Summe'''
|'''Anmerkung'''
|-
|'''2'''
|
|Anzahl der freiäugig als '''flächenhaft wahrnehmbaren Wandelgestirne''' ('''Sonne''' und '''Mond'''), siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwei|Zur Zwei]]
|-
|'''5'''
|
|Anzahl der freiäugig als '''punktförmig wahrnehmbaren Wandelgestirne''' '''Merkur''', '''Venus''', '''Mars''', '''Jupiter''', '''Saturn'''
|-
|'''7'''
|= 2 + 5
|Anzahl der freiäugig wahrnehmbaren '''Wandelgestirne''' sowie der '''Tage in der Woche''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Sieben|Zur Sieben]]
|-
|'''12'''
|= 5 + 7
|Anzahl der '''Monate im Jahr''', der '''Lebewesenkreiszeichen des Zodiaks''' sowie der '''Erdenjahre pro Jupiterjahr''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwölf|Zur Zwölf]], vergleiche hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|Der Zodiak]]
|-
|'''19'''
|= 7 + 12
|Anzahl der '''Jahre''' mit '''zwölf Monaten''' und '''sieben Schaltmonaten''' einer '''Meton-Periode''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Neunzehn|Zur Neunzehn]], vergleiche hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|Die Plejaden-Schaltregeln]] und [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Mondzyklen#Der_Meton-Zyklus|Der Meton-Zyklus]]
|}

=== Weitere Bezüge ===
Weitere Bezüge von der Astronomie zur Theologie ergeben sich bei den folgenden Sachverhalten:

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Biblische_Erwähnungen|'''biblische Erwähnungen von Konstellationen''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Der_Stern_von_Bethlehem|'''Der Stern von Bethlehem''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Ochs_und_Esel|'''Ochs und Esel / Krippe / „Ich bin das Alpha und das Omega“''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Biblische_Bezüge|'''Biblische Bezüge zu den Mondhäusern / Mondstationen''']].

== Zur Kosmologie ==
[[Datei:Kosmologisches.Modell.Schwarze.Schale.Rotverschiebung.png|mini|rechts|hochkant=2.5|Ein kosmologisches Modell unseres im Zentrum isotropen und inhomogenen Universums, das von einer undurchsichtigen und massereichen schwarzen Kugelschale umgeben ist. Von der äußeren Region aus betrachtet, ist unser Universum ein gigantisches Schwarzes Loch. Zwischen dem inneren und dem äußeren Bereich der schwarzen Kugelschale ist kein Informationsaustausch möglich. Jegliche Materie, die von innen oder außen in die schwarze Kugelschale gelangt, ist von innen und von außen nicht mehr sichtbar. Sowohl die innere als auch die äußere Grenze der schwarzen Kugelschale stellen demzufolge einen Ereignishorizont dar.]]

Die '''Kosmologie''' beschäftigt sich mit der Struktur, dem Ursprung und der Entwicklung des Universums. Dadurch ergeben sich zahlreiche Bezüge zur beobachtenden '''Astronomie''' und zur '''Astrophysik''', aber auch zur '''Quantenphysik'''.

In der Antike gingen die Menschen noch davon aus, dass sich die Erde im Mittelpunkt der Welt und somit auch in der Mitte des sichtbaren Universums befindet. Dieses geozentrische Weltbild wurde seit dem 16.&amp;nbsp;Jahrhundert, ausgelöst durch die kopernikanische Wende, zunehmend verworfen und durch ein heliozentrisches Weltbild ersetzt. Durch die Erfindung und Verwendung von Fernrohren konnten seit dem Beginn des 17.&amp;nbsp;Jahrhunderts immer mehr Details im Sternenhimmel entdeckt werden. Durch astronomische Beobachtungen ergaben sich immer mehr Indizien für die Tatsache, dass die Erde einmal pro Jahr auf einer Ellipsenbahn die Sonne umrundet und nicht die Sonne die Erde umkreist. Der Philosoph Immanuel Kant (1724–1804) erkannte bereits 1755 in seiner Allgemeinen Naturgeschichte und Theorie des Himmels das innere Wesen unserer Milchstraße. Mit der ersten zuverlässigen Messung der Parallaxe von unserer Erde zum benachbarten Fixstern 61&amp;nbsp;Cygni (&quot;Bessel's Stern&quot;) durch Friedrich Wilhelm Bessel (1784–1846) in Königsberg und der daraus folgenden Berechnung von dessen Entfernung von gut zehn Lichtjahren im Jahr 1838 war die Tatsache, dass die Erde um die Sonne läuft, endgültig bewiesen.

Die Auswertung der astronomischen Beobachtungen hat zu der heute allgemein geteilten Auffassung geführt, dass unser Universum bei einem Urknall entstanden ist und seitdem expandiert. Die Berücksichtigung des Äquivalenzprinzips zwischen schwerer und träger Masse, das zu der von '''Albert Einstein''' (1879–1955) formulierten Allgemeinen Relativitätstheorie führt, brachte '''Alexander Friedmann''' (1888–1925) 1922 zu der theoretischen Vorhersage eines dynamischen Universums. Fünf Jahre später schlussfolgerte der belgische Astronom '''Georges Lemaître''' (1894–1966) aus den von '''Vesto Slipher''' (1875–1969) beobachteten Rotverschiebungen von fernen Galaxien und den von '''Edwin Hubble''' (1889–1953) ermittelten Entfernungen dieser Galaxien, dass das Universum expandiert. Aufgrund dieser Erkenntnis ergibt sich, dass das Universum einen Ursprung mit sehr kleinem Radius gehabt haben muss. Diesen Zustand nannte er &quot;primordiales Atom&quot; beziehungsweise &quot;Uratom&quot;. In der Folgezeit etablierte sich für diesen initialen Vorgang der Begriff &quot;'''Urknall'''&quot; (im Englischen: &quot;'''Big Bang'''&quot;).&lt;ref&gt;Markus Bautsch: ''[https://en.wikibooks.org/wiki/Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell/Brief_historical_review Moving objects in retarded gravitational potentials of an expanding spherical shell / Brief historical review], Wikibook (englisch), 2024, abgerufen am 28. Februar 2026&lt;/ref&gt;

Viele Astrophysiker versuchen heute mit dem sogenannten '''Standardmodell der Kosmologie''' (auch '''ΛCDM-Modell''' beziehungsweise Lambda-CDM-Modell, wobei &quot;CDM&quot; für &quot;cold dark matter&quot; steht, also für &quot;kalte, dunkle Materie&quot;) die Entwicklung des Universums nachzubilden. Hierfür wenden sie das kosmologische Prinzip an, das von zwei grundlegenden Annahmen ausgeht:&lt;ref&gt;Markus Bautsch: ''[https://en.wikibooks.org/wiki/Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell/Preface Moving objects in retarded gravitational potentials of an expanding spherical shell / Preface], Wikibook (englisch), 2024, abgerufen am 28. Februar 2026&lt;/ref&gt;

# Das Weltall sei '''homogen''', was bedeutet, dass es in groben Zügen von jedem Punkt aus gleich aussieht.
# Das Weltall sei '''isotrop''', was besagt, dass es in groben Zügen in jede Richtung gleich aussieht.

Mit diesen Annahmen kann das Modell berechnet werden, und mit diversen zusätzlichen Annahmen stimmt es in vielerlei Hinsicht mit den astronomischen Beobachtungen überein. Zu den zusätzlichen Annahmen gehören die folgenden beiden hypothetischen Größen:

* '''Kalte, dunkle Materie''', die zwar der Gravitation unterläge, aber keine Wechselwirkung mit elektromagnetischer Strahlung zeigt.
* Eine '''kosmologische Konstante''' Λ, die eine '''dunkle Energie''' beschreibt und für die beschleunigte Expansion des Universums verantwortlich sei.

Weder für die Homogenität noch für die Isotropie des Kosmos konnten bislang Belege gefunden werden, und auch für die kalte dunkle Materie und die dunkle Energie konnte bislang keine physikalische Interpretation geliefert werden.

Ferner ist auch die Annahme, dass die Naturkonstanten unveränderliche Werte haben, nicht begründbar. Auf kosmischen Zeitskalen kann es durchaus Änderungen geben, die wir derzeit nicht messen können. Die gilt insbesondere für die Hubble-Konstante, die die Expansionsrate des Universums beschreibt, für die Gravitationskonstante, die die Anziehung zweier Massen beschreibt, oder für die kosmologische Konstante, die die beschleunigte Expansion des Universums beschreibt. In diesem Kontext sei darauf hingewiesen, dass unser Universum genauso groß ist wie ein Schwarzes Loch mit der Masse unseres Universums. Deshalb gehen einige Kosmologen davon aus, dass wir innerhalb eines Schwarzen Loches der Größe und Masse unseres Universums leben könnten.

Siehe hierzu auch: [[:en:Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell|'''Moving objects in retarded gravitational potentials of an expanding spherical shell''']].

Darüber hinaus mehren sich Anzeichen und Hinweise, die gegen die Ergebnisse des Standardmodells der Kosmologie sprechen, beziehungsweise durch weitere Hypothesen, die physikalisch nicht begründet werden können, im Standardmodell berücksichtigt werden müssen. Die folgende unvollständige Liste soll hierzu einige Anhaltspunkte liefern:

* Präzise astronomische Beobachtungen zeigen, dass das Weltall auch auf großen Längenskalen '''nicht homogen''' ist, sondern Strukturen zeigt.
* Präzise astronomische Beobachtungen zeigen, dass das Weltall auch auf großen Längenskalen '''nicht isotrop''' ist (Asymmetrie der kosmischen Hintergrundstrahlung).
* Die Hubble-Konstante hat heute einen anderen Wert als früher (&quot;'''Hubble tension'''&quot;), was mit dem Standardmodell nicht im Einklang steht.
* Das beobachtete Vorkommen des dritten Elements im Periodensystem, also des Alkalimetalls '''Lithium''', ist mindestens dreimal geringer als vom Standardmodell vorhergesagt.
* Die '''Rotverschiebung von fernen Galaxien''' ist deutlich größer als es nach dem Standardmodell möglich wäre.
* Die beobachteten '''Rotationskurven von Spiralgalaxien''' stehen im Widerspruch zu den Ergebnissen des Standardmodells.
* Das Standardmodell ist nicht in der Lage, die Abwesenheit von '''Antimaterie''' im sichtbaren Teil des Universums zu erklären.
* Die im frühen Universum beobachteten '''primordialen Schwarzen Löcher und Galaxien''' mit explodierende '''Supernovae''' sowie dem Vorkommen von '''Sauerstoff''' stehen im Widerspruch zu den Ergebnissen des Standardmodells.

== Zur Astrologie ==
Eine Sonderstellung nimmt die '''{{w|Astrologie}}''' (zusammengesetzt mit dem altgriechischen ἄστρον (&quot;astron&quot;), zu Deutsch „Sternenlehre“) ein. Sie ist ein weiteres Beispiel für eine Disziplin, bei der grundlegende Kenntnisse über die Astronomie eine Voraussetzung sind. Sie versucht, Zusammenhänge zwischen den Konstellationen der Wandelgestirne oder astronomischen Ereignissen am Sternenhimmel mit irdischen Geschehnissen oder Veränderungen herzustellen, insbesondere was bestimmte Konjunktionen und daraus abgeleitete Prophezeiungen betrifft. Sie wurde bereits in Mesopotamien und in anderen alten Kulturkreisen von Astronomen ausgeübt. Noch der Astronom '''{{w|Johannes Kepler}}''' (1571–1630) hat als einer der letzten Astronomen einen wesentlichen Teil seiner Einkünfte durch die Erstellung von Horoskopen bestritten. Aber schon Aristoteles hatte festgestellt und beschrieben, dass die bei bestimmten Konstellationen am Himmel vorhergesagten Ereignisse nicht eingetreten waren.

Vor der Aufklärung haben astrologische Prophezeiungen noch eine große und weitreichende gesellschaftliche Bedeutung gehabt. Als Beispiel seien die Behauptungen des ersten im Kurfürstentum Brandenburg tätigen Astrologen '''{{w|Johannes Carion}}''' (1499–1537) genannt, der für 1524 eine Sintflut vorhersagte, die nicht eingetroffen ist.&lt;ref&gt;{{Literatur |Autor=Markus Bautsch, Friedhelm Pedde |Titel=Vor 500 Jahren: Die Sintflut von 1524 die nicht stattfand |Online=https://wfs.berlin/wp-content/uploads/2024/05/A19-BROplanetA4_40s-feb2024ff_www-rz.pdf |Sammelwerk=Dem Himmel nahe. |WerkErg=Mitteilungen der Wilhelm-Foerster-Sternwarte e.V.|Nummer=19 |Hrsg=Wilhelm-Foerster-Sternwarte e.V. / Zeiss-Planetarium am Insulaner |Ort=Berlin |Datum=2024-02 |Seiten=16–19 |Sprache=de |Abruf=2025-08-03|ISSN=2940-9330}}&lt;/ref&gt; Der Wiener Hofastronom '''{{w|Georg Tannstetter}}''' (1482–1535) sah sich 1523 bemüßigt, die schon lange im Voraus erhitzten und besorgten Gemüter zu beruhigen:&lt;ref&gt;Georg Tannstetter: ''Libellus consolatorius contra opiniones de diluvio et aliis horrendis periculis anni 1523''&lt;/ref&gt;

&lt;blockquote&gt;
Nun hat sich überall, in allen Köpfen, in allen Seelen das Gerücht eingeschlichen:&lt;br/&gt;
die Gelehrten und Weisen sind in ständigem Streitgespräch, andere hingegen sind derart verstört, dass sie ihren Geschäften nicht mehr nachgehen können; sie verkaufen ihre Anwesen, ihre Felder und Besitztümer oder lassen davon ab, Güter zu kaufen, in der Hoffnung, ihr Geld leichter in die sicheren Berge transportieren zu können. Andere wiederum verschieben ihr Heiratsversprechen, kündigen ohne scheinbaren Grund Verträge auf, entziehen sich ihren christlichen Gelübden, arbeiten faul und missmutig auf dem Land und fragen sich, was es denn nütze, Geld und Gut anzuhäufen, wenn doch in kürzester Zeit niemand mehr davon Nutzen ziehen könne.
&lt;/blockquote&gt;

'''→ Siehe auch:'''

* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Definition|'''Konjunktionen''', Abschnitt '''Definition''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Historische_Konjunktionen|'''Historische Konjunktionen''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|'''Beobachtungen in der Nähe der Ekliptik''']].
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

== Einzelnachweise ==
&lt;references&gt;&lt;/references&gt;</text>
      <sha1>4ozq6j1rsvtxvp04cglgzxjwm6siyzk</sha1>
    </revision>
    <revision>
      <id>1088605</id>
      <parentid>1088602</parentid>
      <timestamp>2026-07-04T11:07:20Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <comment>/* Himmelspforte */ ugaritischer Baal-Zyklus</comment>
      <origin>1088605</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="89193" sha1="6k4pu9x4rtl2l6btwot7sflwwb30h34" xml:space="preserve">Viele Bezeichnungen für verschiedene Lehren werden mit der aus dem Altgriechischen stammenden Endung &quot;-logie&quot; (altgriechisch λόγος (&quot;logos&quot;), zu Deutsch „Lehre“) gebildet. Die folgenden Disziplinen sind in diesem Kontext hervorzuheben, da sie insbesondere für die '''{{w|Archäoastronomie}}''' wertvolle wissenschaftliche Ergänzungen zur '''{{w|Astronomie}}''' (aus den altgriechischen Wörtern ἄστρον (&quot;ástron&quot;, zu Deutsch „Stern“) und νόμος (&quot;nómos, zu Deutsch „Gesetz“) zusammengesetzt also „Sterngesetz“) liefern:

* Die '''{{w|Archäologie}}''' (zusammengesetzt mit dem altgriechischen Wort ἀρχαῖος (&quot;archaios&quot;), zu Deutsch „Altertumslehre“) beschäftigt sich mit der kulturellen Entwicklung der Menschheit.
* Die '''{{w|Etymologie}}''' (zusammengesetzt mit dem altgriechischen Wort ἔτυμος (&quot;etymos&quot;), zu Deutsch „Wortherkunftslehre“) untersucht die geschichtliche Herkunft von Wörtern.
* Die '''{{w|Mythologie}}''' (zusammengesetzt mit dem altgriechischen Wort μῦθος (&quot;mythos&quot;), zu Deutsch „Erzählungslehre“), die sich wissenschaftlich mit der Sagenwelt beschäftigt.
* Die '''{{w|Theologie}}''' (zusammengesetzt mit dem altgriechischen Wort θεός (&quot;theós&quot;), zu Deutsch „Gotteslehre“) mit ihren Lehren zum religiösen Glauben und dessen Glaubensdokumenten.
* Die '''{{w|Kosmologie}}''' (zusammengesetzt mit dem altgriechischen Wort κόσμος (&quot;kósmos&quot;), zu Deutsch „Weltenlehre“) ist hingegen eine Lehre, die sich im Laufe der Jahrtausende deutlich verändert hat und sich auch heute noch erheblich weiterentwickelt, da es in der modernen Astronomie und Astrophysik mit zunehmend hohem technischem Aufwand immer wieder zu neuen Erkenntnissen kommt.
* Die '''{{w|Numerologie}}''' (zusammengesetzt mit dem lateinischen Wort numerus, zu Deutsch „Zahlenlehre“) mit ihren mystischen Lehren über die symbolische Zuweisung von Bedeutungen an Zahlen.

Von der Antike bis ins Mittelalter galt die Beherrschung der '''{{w|sieben freien Künste}}''' als Voraussetzung für das Betreiben von Philosophie. Zu den drei &quot;trivialen&quot; Künsten der {{w|Grammatik}}, der {{w|Rhetorik}} und der {{w|Dialektik}} des '''{{w|Trivium|Triviums}}''' wurden die vier Künste der {{w|Musiktheorie}}, der {{w|Arithmetik}}, der {{w|Geometrie}} und der {{w|Astronomie}} zu den Künsten des '''{{w|Quadrivium|Quadriviums}}''' gezählt → siehe hierzu auch [[Quadriviale_Kuriositäten|'''Wikibook ''Quadriviale Kuriositäten''''']].

== Zur Etymologie ==
Die Genesis aus dem Alten Testament greift die Thematik der Verwirrung der einheitlichen Sprache in ihrem elften Kapitel auf, und beschreibt, wie die bereits sternenkundigen Menschen im Norden Mesopotamiens übermütig geworden waren und in Babel einen Turm mit einer Spitze '''bis in den Himmel''' errichten wollten:&lt;ref&gt;[https://www.bibleserver.com/EU/1.Mose11 Genesis 11], Genesis, Kapitel 11, Einheitsübersetzung&lt;/ref&gt;

&lt;blockquote&gt;
1 Die ganze Erde hatte eine Sprache und ein und dieselben Worte.&lt;br/&gt;
2 Als sie ostwärts aufbrachen, fanden sie eine Ebene im Land Schinar und siedelten sich dort an.&lt;br/&gt;
3 Sie sagten zueinander: Auf, formen wir Lehmziegel und brennen wir sie zu Backsteinen. So dienten ihnen gebrannte Ziegel als Steine und Erdpech als Mörtel.&lt;br/&gt;
4 Dann sagten sie: Auf, bauen wir uns eine Stadt und einen Turm mit einer Spitze '''bis in den Himmel'''! So wollen wir uns einen Namen machen, damit wir uns nicht über die ganze Erde zerstreuen.&lt;br/&gt;
5 Da stieg der HERR herab, um sich Stadt und Turm anzusehen, die die Menschenkinder bauten.&lt;br/&gt;
6 Und der HERR sprach: Siehe, ein Volk sind sie und eine Sprache haben sie alle. Und das ist erst der Anfang ihres Tuns. Jetzt wird ihnen nichts mehr unerreichbar sein, wenn sie es sich zu tun vornehmen.&lt;br/&gt;
7 Auf, steigen wir hinab und verwirren wir dort ihre Sprache, sodass keiner mehr die Sprache des anderen versteht.&lt;br/&gt;
8 Der HERR zerstreute sie von dort aus über die ganze Erde und sie hörten auf, an der Stadt zu bauen.&lt;br/&gt;
9 Darum gab man der Stadt den Namen Babel, Wirrsal, denn dort hat der HERR die Sprache der ganzen Erde verwirrt und von dort aus hat er die Menschen über die ganze Erde zerstreut.
&lt;/blockquote&gt;

Es mag weniger verwunderlich sein, dass Schöpfungsmythen oder Berichte über Katastrophen nicht nur einen astronomischen Hintergrund haben, sondern in völlig verschiedenen Kulturen sehr ähnliche Merkmale zeigen, wenn man sich das Folgende bewusst macht: Einige Indizien deuten auf einen für viele Kulturen gemeinsamen Ursprung hin, der auf eine tiefsinnige Betrachtung und Beobachtung des Himmelsgeschehens hindeutet.

Bei bestimmten Wörtern sind die Ähnlichkeiten in vielen lebenden und toten Sprachen so auffällig, dass sie ein gemeinsames Ursprungswort (Etymon) haben und somit Kognaten sein dürften. 

=== &quot;Stern&quot; ===
Bei den Wörtern „Gestirn“ beziehungsweise „Stern“ sind die Ähnlichkeiten in vielen lebenden und toten Sprachen sehr auffällig, und diese Verwandtschaften mögen durch die Wörter für &quot;Stern&quot; in den folgenden Sprachen belegt werden:

* Akkadisch &quot;istar&quot;
* Indogermanisch &quot;ster&quot;
* Griechisch &quot;astro&quot; / &quot;asteri&quot;
* Lateinisch &quot;astrum&quot; / &quot;stella&quot;
* Althochdeutsch &quot;stern(o)&quot;
* Jiddisch &quot;shtern&quot;
* Katalanisch und Spanisch &quot;estrella&quot;
* Portugiesisch &quot;estrela&quot;
* Englisch &quot;star&quot;
* Niederländisch &quot;ster&quot;
* Westfriesisch &quot;stjer&quot;
* Italienisch und Korsisch &quot;stella&quot;
* Rumänisch &quot;stea&quot;
* Sardisch &quot;istedda&quot;
* Maltesisch &quot;stilla&quot;
* Französisch &quot;étoile&quot; aus Altfranzösisch &quot;estoile&quot;
* Galicisch &quot;estrela&quot;
* Walisisch &quot;seren&quot;
* Dänisch und Norwegisch &quot;stjerne&quot;
* Schwedisch &quot;stjärna&quot;
* Isländisch &quot;stjarna&quot;
* Kurdisch &quot;stêrk&quot;
* Gujarati &quot;Tārō&quot;
* Hindi &quot;तारा&quot; (taara)
* Marathi &quot;तारा&quot; (Tārā)
* Nepalesisch &quot;तारा&quot; (Tārā)
* Punjabi &quot;ਤਾਰਾ&quot; (Tārā)
* Singhalesisch &quot;තරුව&quot; (taruva)
* Khmer &quot;តារា&quot; (tara)
* Armenisch &quot;աստղ&quot; (astgh)
* Tadschikisch &quot;ситора&quot; (sitora)
* Hausa &quot;tauraro&quot;
* Krio &quot;sta&quot;

=== &quot;Stier&quot; ===
Eine starke Ähnlichkeit gibt es in vielen Sprachen auch zwischen den Wörtern „Stern“ und „Stier“. Der Stier bezeichnet zudem auch ein bedeutendes und eines der ältesten Sternbilder überhaupt:

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|'''Himmelsstier''']].

* Akkadisch und Assyrisch &quot;šūru&quot;
* Aramäisch &quot;tōra&quot;
* Hebräisch &quot;šǒr&quot;
* Ugaritisch &quot;twr&quot;
* Arabisch &quot;ثور&quot; (&quot;thawr&quot;)
* Griechisch &quot;ταύρος&quot; (&quot;tauros&quot;)
* Lateinisch &quot;taurus&quot;
* Althochdeutsch &quot;stior&quot;
* Italienisch, Katalanisch und Spanisch &quot;toro&quot;
* Galicisch &quot;touro&quot;
* Gallisch &quot;tarvos&quot;
* Französisch &quot;taureau&quot;
* Schwedisch &quot;tjur&quot;
* Dänisch &quot;tyr&quot;
* Irisch und Gälisch &quot;tarbh&quot;
* Wallisisch &quot;tarw&quot;

=== &quot;Horn&quot; ===
Auch die Hörner des Stieres betreffend setzen sich die vielen Ähnlichkeiten fort:

* Akkadisch &quot;carnu&quot;
* Aramäisch &quot;qeren&quot;
* Griechisch &quot;κόρνο&quot; (&quot;korno&quot;)
* Lateinisch &quot;cornu&quot;
* Maltesisch &quot;qrun&quot;*
* Arabisch &quot;قرون&quot; (&quot;qurun&quot;)
* Französisch &quot;corne&quot;
* Italienisch &quot;corne&quot;
* Rumänisch &quot;corn&quot;
* Haitianisch &quot;kòn&quot;

=== &quot;Sieben&quot; ===
Die in vielen Kulturen als heilig angesehene Zahl Sieben taucht im Zusammenhang mit der Astronomie als Anzahl der mit bloßem Auge sichtbaren Wandelgestirne und als Zahl der Hauptsterne in vielen Asterismen auf:

* Sieben Wandelgestirne: Sonne Mond, Merkur, Venus, Mars, Jupiter, Saturn
* Siebengestirn im Himmelsstier: Alkione, Atlas, Electra, Maia, Merope, Taygeta, Pleione
* Sternbild Orion: Beteigeuze, Rigel, Bellatrix, Alnilam, Alnitak, Saiph, Mintaka
* Asterismus Großer Wagen: Alioth, Dubhe, Alkaid, Mizar, Merak, Phekda, Megrez

→ Siehe auch:

* [[Quadriviale_Kuriositäten/_Zahlen#Zur_Sieben|'''Zur Sieben''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Der_Fixsternhimmel#Die_sieben_hellsten_Objekte_der_Ekliptik|'''Die sieben hellsten Objekte der Ekliptik''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Kalenderführung#Die_Siebentagewoche|'''Die Siebentagewoche''']].

Wegen der hohen kulturellen, rituellen oder mythischen Bedeutung gibt es in vielen Kulturen und Sprachen etymologische Übereinstimmungen:

* Akkadisch &quot;sebe&quot;
* Proto-Indoeuropäisch &quot;septḿ̥&quot;
* Hetitisch &quot;sipta&quot;
* Proto-Germanisch &quot;*sebun&quot;
* Althochdeutsch &quot;sibun&quot;
* Hebräisch &quot;sajin&quot; (Buchstabe) oder &quot;scheva&quot; (Wort)
* Etruskisch &quot;semph&quot;
* Maltesisch &quot;sebgħa&quot;
* Arabisch &quot;sabʿa&quot;
* Griechisch &quot;επτά&quot; (&quot;(h)epta&quot;)
* Lateinisch &quot;septem&quot;
* Ungarisch &quot;het&quot;
* Proto-Balto-slawisch &quot;septin&quot;
* Proto-Indo-Iranisch &quot;saptá&quot;
* Katalanisch &quot;set&quot;
* Spanisch &quot;siete&quot;
* Galicisch &quot;sete&quot;
* Lettisch &quot;septiņi&quot;
* Italienisch &quot;sette&quot;
* Französisch &quot;sept&quot;
* Englisch &quot;seven&quot;
* Wallisisch &quot;saith&quot;
* Bosnisch / Kroatisch &quot;sedam&quot;
* Rumänisch &quot;șapte&quot;
* Irisch &quot;seacht&quot;
* Swahili &quot;saba&quot;
* Haitianisch &quot;sèt&quot;

== Zur Mythologie ==
Seit Jahrtausenden blicken Menschen in den Nachthimmel und versuchen, die unzähligen Lichter am Firmament zu deuten. Schon früh begannen sie, die von ihnen erfundenen Sternbilder und die unablässig durch den Himmel ziehenden Wandelgestirne durch Geschichten über Götter, Helden oder andere Wesen zu interpretieren, zu erzählen und zum Teil über Jahrhunderte hinweg zu tradieren. Die '''Mythologie''' spielte dabei eine zentrale Rolle: Sie half nicht nur, eine symbolische Ordnung in den geheimnisvollen Kosmos zu bringen, sondern prägte auch viele der Bezeichnungen und Vorstellungen, die bis heute in der beschreibenden Astronomie überlebt haben.

Die Verbindung zwischen Mythologie und Astronomie ist tief verwurzelt und zeugt vom menschlichen Bedürfnis, das wahrgenommene, aber dennoch unfassbare Universum durch räumliche und zeitliche Vorstellungen sowie durch Erzählungen begreifbar zu machen. Das Geschehen am Himmel musste auf die Menschen vor der Erfindung der Bewegtbilder und des Films in der späten Neuzeit sowohl attraktiv als auch spektakulär gewirkt haben. So konnten verschiedene mythische Gestalten am Himmel durch ihre scheinbaren Handlungen wahrgenommen werden. Durch die Wiederholung solcher Deutungen konnten sich besonders beliebte Mythen im kulturellen Kontext über die Zeit verfestigen, und entsprechende Riten konnten sich etablieren.

Damit war auch eine wesentliche Voraussetzung für den Glauben der Menschen an eine höhere Macht oder mehrere höhere Mächte gegeben. Der Begriff '''Religion''' stammt vom lateinischen Inifiniv &quot;relegere&quot; ab. Dieses Verb bedeutet wörtlich übersetzt &quot;wieder lesen&quot; und meint im Sinne von &quot;überdenken&quot; das bewusste Wahrnehmen von Prophezeiungen oder Omen sowie das nachhaltige Beachten tradierter Vorschriften.

'''→ Siehe:'''

* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Der Urozean''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Sagenwelt|'''Die Plejaden / Sagenwelt''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Mythologie|'''Der Himmelsstier''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Babylonische_Himmelswege|'''Babylonische Himmelswege''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Mithraskult|'''Mithraskult und Tauroktonie''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Höhlenmalerei_in_der_Magura-Höhle|'''Die Höhlenmalerei in der Magura-Höhle''']].

== Zur Theologie ==
Die '''Theologie''' (vom Altgriechischen θεός = theós = Gott und λόγος = lógos = Lehre) ist die Lehre von einem Gott oder von mehreren Göttern. Sie lehrt einen ausgeprägten religiösen Glauben, begründet rituelle Traditionen und deutet die vorhandenen Glaubensdokumente.

[[Datei:Aristoteles.Theologie.png|mini|rechts|Wahrnehmbarkeit und Vergänglichkeit nach Aristoteles]]

Die Theologie des '''{{w|Aristoteles}}''' (384–322) postuliert drei mögliche Substanzen:&lt;ref&gt;Aristoteles: ''Metaphysik'', Kapitel XII (Λ), Philosophische Theologie, Seiten 1069a –1076a&lt;/ref&gt;

{| class=&quot;wikitable&quot;
|+ Mögliche Substanzen nach Aristoteles
! Nummer !! Substanz !! Erläuterung !! Interpretationsbeispiel
|-
| 1. || Die sinnlich wahrnehmbare und vergängliche Substanz || Konkrete Dinge, die nur eine begrenzte Teilhabe an der Ewigkeit haben. || Lebewesen
|-
| 2. || Die sinnlich wahrnehmbare und unvergängliche Substanz || Konkrete Dinge, die eine unbegrenzte Teilhabe an der Ewigkeit haben. || Die sieben Wandelgestirne und die Fixsterne
|-
| 3. || Die sinnlich nicht wahrnehmbare und unvergängliche Substanz || Lebendiger, unbewegter Beweger, der der Ursprung aller anderen Dinge ist. || Gott
|}

Dieses theologische Prinzip wurde später auch von '''{{w|Thomas van Aquin}}''' (1225-1274) in seinen ''Quinque viae ad Deum'' (&quot;Fünf Wege zu Gott&quot;) aufgegriffen:

{| class=&quot;wikitable&quot;
|+ Nach dem ''Quinque viae ad Deum'' (&quot;Fünf Wege zu Gott&quot;) von Thomas von Aquin
! Weg !! Bezeichnung !! Voraussetzung !! Feststellung !! Folgerung
|-
| Via&amp;nbsp;I || Bewegungsbeweis || In der Welt ist überall Bewegung. || Alles Bewegte muss von einem anderen in Bewegung gebracht worden sein. || Der Erstbeweger ist Gott.
|-
| Via&amp;nbsp;II || Kausalitätsbeweis || In der Welt gibt es überall Ursachen und Wirkungen. || Jede Wirkung muss eine Ursache haben. || Die erste Ursache der Welt ist Gott.
|-
| Via&amp;nbsp;III || Kontingenzbeweis || Alles Empirische in der Welt entsteht und vergeht wieder. || Jedes empirische Wesen muss das Sein von einem absoluten Wesen empfangen haben. || Das absolute Wesen ist Gott.
|-
| Via&amp;nbsp;IV || Stufenbeweis || In der Welt gibt es abgestuft gute, wahre und schöne Dinge. || Das absolute Wesen muss die höchste Güte, Wahrheit und Schönheit haben. || Das höchste Gute, Wahre und Schöne ist Gott.
|-
| Via&amp;nbsp;V || Finalitätsbeweis || In der Welt gibt es Ordnung und Gesetzmäßigkeit. || Ordnung und Gesetzmäßigkeit müssen auf einen denkenden Geist zurückgehen. || Dieser Geist kommt von Gott.
|}

Auch '''{{w|Gottfried Wilhelm Leibniz}}''' (1646-1717) lehnt sich in seiner Hypothese von „Gott als letztem und zureichendem Grund der Welt“ daran an.

Auch im 90. Psalm wird dieser Ansatz thematisiert:

&lt;blockquote&gt;
Das vierte Buch&lt;br/&gt;
Der '''ewige''' Gott – der '''vergängliche''' Mensch&lt;br/&gt;&lt;br/&gt;
1 Ein Bittgebet des Mose, des Mannes Gottes. O Herr, du warst uns Wohnung '''von Geschlecht zu Geschlecht'''.&lt;br/&gt;
2 '''Ehe geboren wurden die Berge, ehe du unter Wehen hervorbrachtest Erde und Erdkreis''', bist du '''Gott von Ewigkeit zu Ewigkeit'''.&lt;br/&gt;
3 '''Zum Staub zurückkehren lässt du den Menschen''', du sprichst: Ihr Menschenkinder, kehrt zurück!&lt;br/&gt;
4 Denn tausend Jahre sind in deinen Augen wie der Tag, der gestern vergangen ist, wie eine Wache in der Nacht.
&lt;/blockquote&gt;

Darüber hinaus gibt der vierte Vers einen deutlichen Hinweis auf das Verhältnis zwischen der Länge des viele Jahrtausende dauernden Präzessionszyklus und der Länge eines siderischen Monats: der Mond wandert entlang der Ekliptiklinie an einem Tag genauso weit wie der Frühlingspunkt in tausend Jahren.

→ Siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Präzession|'''Präzession''']].

Der griechische Dichter '''{{w|Aratos von Soloi}}''' in Kilikien (≈310–245) hatte seine astronomischen Kenntnisse vom Astronomen und Mathematiker '''{{w|Eudoxos von Knidos}}''' (geboren nach 390, gestorben nach 338) erhalten. In dem in der Antike verbreiteten Lehrgedicht Φαινόμενα (Phainomena = „Himmelserscheinungen“) von Aratos wird der Sternenhimmel in zahlreichen Hexametern beschrieben. Sein monumentales sechseckiges Grab aus der antiken Stadt Pompeiopolis wurde 2020 in der türkischen Provinz Mersin wiederentdeckt.&lt;ref&gt;Patricia Claus: [https://greekreporter.com/2021/07/11/memorial-tomb-of-ancient-greek-astronomer-aratus-unearthed-in-turkey/ Memorial Tomb of Ancient Greek Astronomer Aratus Unearthed in Turkey], The Greek Reporter, 11. Juli 2021&lt;/ref&gt;

Hier der Beginn des Prologs des Lehrgedichts:

&lt;blockquote&gt;
Εκ Διὸς ἀρχώμεσθα , τὸν οὐδέποτ᾽ ἄνδρες ἐῶμεν&lt;br/&gt;
῎Αῤῥητον . Μεσταὶ δὲ Διὸς πᾶσαι μὲν ἀγυιαὶ ,&lt;br/&gt;
Πᾶσαι δ᾽ ἀνθρώπων ἀγοραί · μεστὴ δὲ θάλασσα ,&lt;br/&gt;
Καὶ λιμένες. πάντη δὲ Διὸς κεχρήμεθα πάντες .&lt;br/&gt;
'''Τοῦ γὰρ καὶ γένος εἰμέν''' · ὁ δ᾽ ἤπιος ἀνθρώποισι&lt;br/&gt;
Δεξιὰ σημαίνει · λαοὺς δ᾽ ἐπὶ ἔργον ἐγείρει ,&lt;br/&gt;
Μιμνήσκων βιότοιο . λέγει δ᾽ , ὅτε βῶλος ἀρίστη&lt;br/&gt;
Βουσί τε καὶ μακέλῃσι · λέγει δ᾽ , ὅτε δεξιαὶ ὧραι ,&lt;br/&gt;
Καὶ φυτὰ γύρῶσαι , καὶ σπέρματα πάντα βαλέσθαι .&lt;br/&gt;
Αὐτὸς γὰρ τάγε σήματ᾽ ἐν '''οὐρανῷ''' ἐστήριξεν ,&lt;br/&gt;
'''Αστρα''' διακρίνας · ἐσκέψατο δ᾽ εἰς ἐνιαυτὸν&lt;br/&gt;
'''᾿Αστέρας''' , οἵ κε μάλιστα τετυγμένα σημαίνοιεν&lt;br/&gt;
᾿Ανδράσιν ὡράων , ὄφρ᾽ ἔμπεδα πάντα φύωνται .&lt;br/&gt;
Τῷ μιν ἀεὶ πρῶτόν τε καὶ ὕστατον ἱλάσκονται .&lt;br/&gt;
Χαῖρε , πάτερ , μέγα θαῦμα , μέγ᾽ ἀνθρώποισιν ὄνειαρ ,&lt;br/&gt;
Αὐτὸς καὶ προτέρη γενεή ! χαίροιτε δὲ , Μοῦσαι&lt;br/&gt;
Μειλίχιαι , μάλα πᾶσαι ! ἐμοί γε μὲν '''ἀστέρας''' εἰπεῖν ,&lt;br/&gt;
Ηἱ θέμις εὐχομένῳ , τεκμήρατε πᾶσαν ἀοιδήν .&lt;br/&gt;
Οἱ μὲν ὁμῶς πολέες τε , καὶ ἄλλυδις ἄλλοι ἐόντες ,&lt;br/&gt;
'''Οὐρανῷ''' ἕλκονται πάντ᾽ ἤματα συνεχὲς αἰεί.&lt;br/&gt;
Αὐτὰρ ὅγ᾽ οὐδ᾽ ὀλίγον μετανίσσεται · ἀλλὰ μάλ' αὕτως&lt;br/&gt;
'''῎Αξων''' οἱ ἐνάρηρεν · ἔχει δ᾽ ἀτάλαντον ἁπάντη&lt;br/&gt;
'''Μεσσηγὺς γαῖαν''' , περὶ δ᾽ '''οὐρανὸν''' αὐτὸν ἀγινεῖ.&lt;br/&gt;
Καί μιν πειραίνουσι δύω '''πόλοι''' ἀμφοτέρωθεν ·&lt;br/&gt;
᾿Αλλ᾽ ὁ μὲν οὐκ ἐπίοπτος · ὁ δ᾽ ἀντίος ἐκ '''Βορέαο''' ,&lt;br/&gt;
Ὑψόθεν Ὠκεανοῖο . Δύω δὲ μιν ἀμφὶς ἔχουσαι&lt;br/&gt;
'''Ἄρκτοι''' ἅμα τροχόωσι · τὸ δὴ καλέονται '''῞Αμαξαι''' .
&lt;/blockquote&gt;

Übersetzung unter Beibehaltung der Hexameter nach dem deutschen Dichter, Übersetzer und Hochschullehrer Johann Heinrich Voss (1751–1826) von 1824:&lt;ref&gt;АРАТОΥ ΦΑΙΝΟΜΕΝΑ ΚΑΙ ΔΙΟΣΗΜΕΙΑ. Des Aratos Sternerscheinungen und Wetterzeichen. Übersetzt und erklärt von Johann Heinrich Voss. Heidelberg bei Christian Friedrich Winter. 1824.&lt;/ref&gt;

&lt;blockquote&gt;
Zeus sei unser Beginn , und niemals bleib' er uns Männern&lt;br/&gt;
Ungelobt. Voll wahrlich des Zeus sind alle des Wandels&lt;br/&gt;
Weg' , und alle Versammlung der Welt ; voll jegliche Meerflut ,&lt;br/&gt;
Jeglicher Port ; ringsum ja des Zeus bedürfen wir alle .&lt;br/&gt;
'''Seines Geschlechts auch sind wir''' ; und Er , mildherzig den Menschen,&lt;br/&gt;
Zeichnet, was frommt, rechtsher ; und zu Tätigkeit weckt er die Völker,&lt;br/&gt;
Mahnend an Lebensbedarf : Er sagt , wann besser dem Pflugstier&lt;br/&gt;
Fuge die Scholl' , und dem Karst ; er sagt , wann schickliche Jahrszeit,&lt;br/&gt;
Dass man die Pflanze behäuf&quot; , und einsenk' allerlei Anwachs .&lt;br/&gt;
Denn selbst hat er die Zeichen am oberen '''Himmel''' befestigt ,&lt;br/&gt;
Und '''Sternbilder''' verteilt ; er hat fürsehend dem Jahrlauf&lt;br/&gt;
'''Sterne''' bestimmt , die den Menschen zumeist annahende Wechsel&lt;br/&gt;
Deuteten jeglicher Zeit , dass in Völligkeit alles erwachse .&lt;br/&gt;
Drum ihn immer zuerst , und zulezt ihn , sühnen sie feiernd.&lt;br/&gt;
Heil , anstaunlicher Vater , den Sterblichen mächtiges Labsal ,&lt;br/&gt;
Du auch , selbst des Geschlechts Ursprung ! Heil , freundliche Musen,&lt;br/&gt;
Heil euch allen gesamt ! doch mir , der , die '''Sterne''' zu melden ,&lt;br/&gt;
Euch , wie geziemt , anfleht , bringt allen Gesang zur Vollendung.&lt;br/&gt;
Jene zugleich , so viele zerstreuete , andere anders ,&lt;br/&gt;
Ziehn mit dem '''Himmel''' einher in ewigem Zuge beständig .&lt;br/&gt;
Doch nie schwanket er selbst um ein weniges; sondern durchaus so&lt;br/&gt;
Bleibt ihm die '''Axe''' geheftet ; die hält gleichschwebend vom Umfang&lt;br/&gt;
Hier '''in der Mitte die Erd'''' , und umher dort dreht sie den '''Himmel''' .&lt;br/&gt;
Sie dann hat zween '''Pol'''' an jeglichem Ende gerichtet :&lt;br/&gt;
Unsichtbar ist jener; doch hier um den '''Boreas''' ragt er&lt;br/&gt;
Ob dem Okeanos hoch. Zwo dem zu den Seiten gestellte&lt;br/&gt;
'''Bärinnen''' rollen umher: drum auch '''Rollwagen''' benamet.
&lt;/blockquote&gt;

'''''Hinweise:'''''
* Die &quot;Axe&quot; beschreibt die Erdachse.
* ''Mit dem &quot;Boreas&quot; ist der Himmelsnordpol gemeint.''
* ''Bei den beiden Bärinnen handelt es sich um die Sternbilder des Großen Bären (Ursa Maior) und des Kleinen Bären (Ursa Minor).''
* ''Die beiden Rollwagen sind bei uns heute die Asterismen Großer Wagen und Kleiner Wagen.''

Der Apostel '''{{w|Paulus von Tarsus}}''' (geboren vor 10, gestorben nach 60) war der bedeutendste Missionar des Urchristentums und kannte diesen Text offensichtlich. Im 17.&amp;nbsp;Kapitel der Apostelgeschichte des Lukas wird ihm ein Zitat aus dem Prolog des Lehrgedichts über die Abstammung der Menschen von Gott in den Mund gelegt.&lt;ref&gt;[https://www.die-bibel.de/bibel/NA28,EUE/ACT.17.28 Apostelgeschichte 17,28], Abschnitt: ''Paulus in Athen'', Novum Testamentum Graece und Einheitsübersetzung&lt;/ref&gt;

&lt;blockquote&gt;
Apostelgeschichte 17,28: '''Τοῦ γὰρ καὶ γένος ἐσμέν.'''
&lt;/blockquote&gt;

&lt;blockquote&gt;
Apostelgeschichte 17,28: '''Wir sind von seinem Geschlecht.'''
&lt;/blockquote&gt;

=== Zahlen in Religionen ===
Die '''Zwei''' steht oft für Gegensätze, wie zum Beispiel Tag und Nacht, Aufgang und Untergang, Sommerhalbjahr und Winterhalbjahr, zunehmender und abnehmender Mond oder obere und untere Kulmination. Eine solche Zweiteilung findet sich oft auch in gegensätzliche Kategorien wieder, die in vielen Disziplinen, insbesondere auch in der Ethik und in Religionen verwendet werden, wie beispielsweise gut und böse, oben und unten, Leben und Tod, Licht und Schatten, Wärme und Kälte oder Himmel und Hölle.

Interessant ist auch die frühgeschichtliche astronomische Auffassung von '''zwei''' mächtigen Gegenspielern, die sich im Sternenhimmel an zwei gegenüberliegenden Seiten befinden, der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|der Himmelsstier]] und der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsskorpion|der Himmelsskorpion]].

→ Siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwei|'''Zur Zwei''']].

Die astronomischen Zahlen '''Sieben''' und '''Zwölf''' werden als heilige Zahlen angesehen. Sie werden in vielfältigen Kontexten in religiösen Texten erwähnt und für viele religiöse Symbole verwendet. Ferner spielt auch die astronomische Zahl '''Vier''' in Religionen eine bedeutende Rolle, wo sie deswegen manchmal ebenfalls als heilige Zahlen angesehen wird:

* '''Vier''' Hauptsterne respektive Hauptsternbilder mit den '''vier''' Himmelsrichtungen und den '''vier''' Jahreszeiten: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Vier_in_Religionen|'''Bedeutung der Vier in Religionen''']].
* '''Sieben''' Wandelgestirne mit den die '''sieben''' Tagen einer Woche beziehungsweise eines Mondviertels: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Sieben_in_Religionen|'''Bedeutung der Sieben in Religionen''']].
* '''Zwölf''' Ekliptiksternbilder, '''zwölf''' Monate pro Jahr, '''zwölf''' Jahre Umlaufzeit des Planeten Jupiter, jeweils '''zwölf''' Stunden Tag und Nacht: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Zwölf_in_Religionen|'''Bedeutung der Zwölf in Religionen''']].

=== Altes Testament ===
In der Bibel wird in der Regel nicht zwischen Fixsternen und Planeten unterschieden. Eine Ausnahme gibt es im 2.&amp;nbsp;Buch der Könige, Kapitel&amp;nbsp;23, Vers&amp;nbsp;5 aus dem siebenten vorchristlichen Jahrhundert, wo in der deutschsprachigen Einheitsübersetzung von &quot;den Wandelsternen&quot; und in der Luther-Bibel von &quot;den Planeten&quot; die Rede ist. Die Vulgata schreibt hier allerdings von den &quot;duodecim signis&quot;, womit sicherlich die zwölf Sternzeichen der Ekliptik gemeint sind, durch die die sieben Wandelgestirne ziehen. Die Septuaginta spricht noch allgemeiner von den &quot;μαζουρωθ&quot; nach dem Hebräischen Wort &quot;מַזָּלָה&quot; (&quot;mazzaroth&quot;), womit vermutlich Sternkonstellationen und im engeren Sinne ebenfalls die zwölf Sternzeichen des Zodiaks gemeint sind:

&lt;blockquote&gt;
'''Septuaginta '''&lt;br/&gt;
5 καὶ κατέπαυσεν τοὺς χωμαριμ, οὓς ἔδωκαν βασιλεῖς Ιουδα καὶ ἐθυμίων ἐν τοῖς ὑψηλοῖς καὶ ἐν ταῖς πόλεσιν Ιουδα καὶ τοῖς περικύκλῳ Ιερουσαλημ, καὶ τοὺς θυμιῶντας τῷ Βααλ καὶ τῷ ἡλίῳ καὶ τῇ σελήνῃ καὶ τοῖς '''μαζουρωθ''' καὶ πάσῃ τῇ δυνάμει τοῦ οὐρανοῦ.&lt;br/&gt;
&lt;br/&gt;
'''Vulgata'''&lt;br/&gt;
5 Et delevit aedituos, quos posuerant reges Iudae ad sacrificandum in excelsis per civitates Iudae et in circuitu Ierusalem, et eos, qui adolebant Baal et soli et lunae et '''duodecim signis''' et omni militiae caeli.&lt;br/&gt;
&lt;br/&gt;
'''Einheitsübersetzung (2016)'''&lt;br/&gt;
5 Auch setzte er die Götzenpriester ab, die von den Königen von Juda bestellt worden waren und die auf den Kulthöhen, in den Städten Judas und in der Umgebung Jerusalems Opfer verbrannt sowie dem Baal, der Sonne, dem Mond, den '''Wandelsternen''' und dem ganzen Heer des Himmels geopfert hatten.&lt;br/&gt;
&lt;br/&gt;
'''Luther-Bibel (2017)'''&lt;br/&gt;
5 Und er setzte die Götzenpriester ab, die die Könige von Juda eingesetzt hatten, um auf den Höhen zu opfern in den Städten Judas und um Jerusalem her; auch die dem Baal geräuchert hatten, der Sonne und dem Mond und den '''Planeten''' und allem Heer am Himmel.&lt;br/&gt;
&lt;/blockquote&gt;

Der Prophet Habakuk erwähnt in seinem Psalm in Kapitel&amp;nbsp;3 aus dem siebenten vorchristlichen Jahrhundert das Konzept der Aufteilung der Ekliptik in Mondstationen respektive in Mondhäuser:

&lt;blockquote&gt;
10 Wenn sie dich sehen, erbeben die Berge,&lt;br/&gt;
das Tosen der Wasser rauscht vorüber; es erhebt die Urflut ihre Stimme,&lt;br/&gt;
hoch oben vergisst die Sonne ihre Strahlen.&lt;br/&gt;
11 '''Der Mond bleibt in der Behausung;'''&lt;br/&gt;
als Beleuchtung schwirren deine Pfeile,&lt;br/&gt;
als heller Schein das Blitzen deiner Lanze.
&lt;/blockquote&gt;

In den folgenden Bibelstellen aus dem Alten Testament spiegeln sich astronomische Vorstellungen in Bezug auf Gott wider:

'''Genesis 1:'''
&lt;blockquote&gt;
1 Im Anfang erschuf Gott '''Himmel''' und Erde.&lt;br/&gt;
2 Die '''Erde''' war wüst und wirr und '''Finsternis''' lag über der '''Urflut''' und Gottes Geist schwebte über dem '''Wasser'''.&lt;br/&gt;
3 Gott sprach: Es werde '''Licht'''. Und es wurde '''Licht'''.
...&lt;br/&gt;
5 Und Gott nannte das Licht '''Tag''' und die Finsternis nannte er '''Nacht'''. Es wurde '''Abend''' und es wurde '''Morgen''': erster Tag.&lt;br/&gt;
...&lt;br/&gt;
14 Dann sprach Gott: Lichter sollen am '''Himmelsgewölbe''' sein, um '''Tag''' und '''Nacht''' zu scheiden. Sie sollen als Zeichen für '''Festzeiten''', für '''Tage''' und '''Jahre''' dienen.&lt;br/&gt;
15 Sie sollen Lichter am Himmelsgewölbe sein, um über die Erde hin zu leuchten. Und so geschah es.&lt;br/&gt;
16 Gott machte '''die beiden großen Lichter''', das große zur Herrschaft über den '''Tag''', das kleine zur Herrschaft über die '''Nacht''', und die '''Sterne'''.
&lt;/blockquote&gt;

'''Psalm 8:'''
&lt;blockquote&gt;
4 Seh ich deine '''Himmel''', die Werke deiner Finger, '''Mond '''und '''Sterne''', die du befestigt.
&lt;/blockquote&gt;

[[Datei:Johannes.Kepler.Coeli.enarrant.gloriam.Dei.png|mini|rechts|Portrait des jungen Johannes Keplers mit dem Motto &quot;Coeli enarrant gloriam Dei.&quot; nach Psalm 19: &quot;Die Himmel erzählen die Herrlichkeit Gottes.&quot;]]

'''Psalm 19:'''
&lt;blockquote&gt;
2 Die '''Himmel''' erzählen die Herrlichkeit Gottes und das '''Firmament''' kündet das Werk seiner Hände.
&lt;/blockquote&gt;

'''Psalm 90:'''
&lt;blockquote&gt;
2 Ehe geboren wurden die Berge, ehe du unter Wehen hervorbrachtest '''Erde''' und '''Erdkreis''', bist du Gott von Ewigkeit zu Ewigkeit.
&lt;/blockquote&gt;

'''Psalm 102:'''
&lt;blockquote&gt;
26 Vorzeiten hast du der Erde Grund gelegt, die '''Himmel''' sind das Werk deiner Hände.
&lt;/blockquote&gt;

'''Psalm 103:'''
&lt;blockquote&gt;
19 Der HERR hat seinen Thron errichtet im '''Himmel''', seine königliche Macht beherrscht '''das All'''.
&lt;/blockquote&gt;

'''Psalm 104:'''
&lt;blockquote&gt;
19 Du machst den '''Mond''' zum Maß für die Zeiten, die '''Sonne''' weiß, wann sie untergeht.
&lt;/blockquote&gt;

'''Psalm 113:'''
&lt;blockquote&gt;
3 Vom '''Aufgang der Sonne''' bis zu ihrem '''Untergang''' sei gelobt der Name des HERRN.&lt;br/&gt;
4 Erhaben ist der HERR über alle Völker, über den '''Himmeln''' ist seine Herrlichkeit.
&lt;/blockquote&gt;

'''Psalm 136:'''
&lt;blockquote&gt;
3 Dankt dem Herrn der Herren, denn seine Huld währt ewig!&lt;br/&gt;
4 Ihm, der allein große Wunder tut, denn seine Huld währt ewig,&lt;br/&gt;
5 der den '''Himmel''' gemacht hat in Weisheit, denn seine Huld währt ewig,&lt;br/&gt;
6 der die Erde gefestigt hat über den Wassern, denn seine Huld währt ewig,&lt;br/&gt;
7 der '''die großen Leuchten''' gemacht hat, denn seine Huld währt ewig,&lt;br/&gt;
8 die '''Sonne''' zur Herrschaft über den '''Tag''', denn seine Huld währt ewig,&lt;br/&gt;
9 den '''Mond''' und die '''Sterne''' zur Herrschaft über die '''Nacht''', denn seine Huld währt ewig.
&lt;/blockquote&gt;

'''Psalm 147:'''
&lt;blockquote&gt;
4 Er bestimmt die Zahl der '''Sterne''' und ruft sie alle mit Namen.
&lt;/blockquote&gt;

'''Psalm 148:'''
&lt;blockquote&gt;
'''Lobpreis auf den Herrn, den König des Kosmos'''&lt;br/&gt;
1 Halleluja! Lobt den HERRN vom '''Himmel''' her, lobt ihn in den Höhen:&lt;br/&gt;
2 Lobt ihn, all seine Engel, lobt ihn, all seine Heerscharen,&lt;br/&gt;
3 lobt ihn, '''Sonne''' und '''Mond''', lobt ihn, all ihr leuchtenden '''Sterne''',&lt;br/&gt;
4 lobt ihn, ihr '''Himmel der Himmel''', ihr Wasser über dem '''Himmel'''!
&lt;/blockquote&gt;

Mit den &quot;Wassern über dem Himmel&quot; können nicht die Wolken unterhalb der Sternensphäre gemeint sein. Vielmehr dürfte es sich um eine Anspielung auf den Urozean beziehungsweise die Urflut handeln (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Urozean''']]). Diese Urflut existierte bereits vor der Erschaffung des Lichts und der Gestirne. Man erinnere sich an den Beginn der Schöpfungsgeschichte in den ersten drei Versen der Bibel (siehe oben).

'''Buch der Weisheit (Weisheit Salomos):'''
&lt;blockquote&gt;
'''Salomos Gebet um Weisheit'''&lt;br/&gt;
9,1 Gott der Väter und Herr des Erbarmens, du hast '''das All''' durch dein Wort gemacht.
&lt;/blockquote&gt;

'''Jesus Sirach 42:'''
&lt;blockquote&gt;
'''Lob Gottes in der Schöpfung'''&lt;br/&gt;
15 Nun will ich der Werke des Herrn gedenken, und was ich gesehen habe, werde ich erzählen: Durch die Worte des Herrn sind seine Werke und durch seinen Segen gab er ihnen ihre Bestimmung.&lt;br/&gt;
16 Die leuchtende '''Sonne''' blickt auf alles hernieder und von der Herrlichkeit des Herrn ist sein Werk erfüllt.&lt;br/&gt;
17 Der Herr gab es selbst den Heiligen nicht, all seine Wunder zu erzählen, der Herr der Herrscher über '''das All''', hat sie gegründet, sodass '''das All''' in seiner Herrlichkeit Bestand hat.&lt;br/&gt;
18 Abgrund und Herz hat er durchforscht und ihre Absichten hat er durchschaut; denn der Höchste kennt alles Wissen und er blickt auf die '''Zeichen der Zeiten'''.&lt;br/&gt;
19 Er tut das Vergangene und das Kommende kund und enthüllt die Spuren des Verborgenen.&lt;br/&gt;
20 Kein Gedanke entgeht ihm und kein einziges Wort bleibt ihm verborgen.&lt;br/&gt;
21 Die Großtaten seiner Weisheit hat er geordnet; wie er ist '''von Ewigkeit und in Ewigkeit'''. Ihm ist weder etwas hinzugefügt noch weggenommen worden und er hat keines Ratgebers bedurft.
&lt;/blockquote&gt;

Auch im nachfolgenden Kapitel lobt Jesus Sirach die Sonne, den Mond und die Sterne in den höchsten Tönen:

'''Jesus Sirach 43:'''
&lt;blockquote&gt;
1 Der Stolz der Höhe ist ein '''Firmament''' von Reinheit, die Gestalt des '''Himmels''' beim Anblick der Herrlichkeit.&lt;br/&gt;
2 Die '''Sonne''' verkündet durch ihr Erscheinen beim Aufgang, ein wunderbares Geschöpf, ein Werk des Höchsten!&lt;br/&gt;
3 Zur '''Mittagszeit''' trocknet sie den Boden aus, wer wird bestehen vor ihrer Glut?&lt;br/&gt;
4 Wer in einen Ofen bläst bei Arbeiten mit Glut - dreimal so stark versengt die '''Sonne''' Berge; sie atmet Feuerdämpfe aus und blendet mit gleißenden Strahlen die Augen.&lt;br/&gt;
5 Groß ist der Herr, der sie gemacht hat, mit seinen Worten beschleunigt er ihren Lauf.&lt;br/&gt;
6 Auch der '''Mond''' hält sich in allem an seinen Zeitpunkt, zur '''Festsetzung der Zeiten''' und als Zeichen auf Dauer.&lt;br/&gt;
7 Vom '''Mond''' geht das Zeichen für einen Festtag aus, ein Gestirn, das abnimmt bis zur Vollendung.&lt;br/&gt;
8 Der Name '''Monat''' kommt vom '''Neumond''', der wunderbar zunimmt beim Wechsel, ein Geschöpf des Heeres in der Höhe, das am '''Himmelsgewölbe''' leuchtet.&lt;br/&gt;
9 Die Schönheit des '''Himmels''' ist der Glanz der '''Sterne''', ein strahlender Schmuck in den Höhen des Herrn.&lt;br/&gt;
10 Durch die Worte des Heiligen stehen sie gemäß ihrer Bestimmung und sie ermüden nie bei ihrer Wache.&lt;br/&gt;
...&lt;br/&gt;
27 Vieles werden wir sagen, aber wir kommen nie an ein Ziel und das Ende der Worte ist: Er ist '''das All'''.
&lt;/blockquote&gt;

'''Jesaja 40:'''
&lt;blockquote&gt;
26 Hebt eure Augen in die Höhe und seht: Wer hat diese '''Gestirne''' erschaffen?&lt;br/&gt;
Der vollzählig herausführt ihr Heer, er ruft sie alle beim Namen.&lt;br/&gt;
Wegen seiner Fülle an Kraft und mächtiger Stärke fehlt kein einziges.
&lt;/blockquote&gt;

Das Buch Baruch gehört zu den späten Schriften des Alten Testaments. Im dritten Kapitel werden das Licht und die Sterne in Bezug auf Gott thematisiert:

'''Baruch 3:'''
&lt;blockquote&gt;
33 Er entsendet das '''Licht''' und es eilt dahin; er ruft es zurück und zitternd gehorcht es ihm.&lt;br/&gt;
34 Froh leuchten die '''Sterne''' auf ihren Posten.&lt;br/&gt;
35 Ruft er sie, so antworten sie: Hier sind wir. Sie leuchten mit Freude für ihren Schöpfer.&lt;br/&gt;
36 Das ist unser Gott; kein anderer gilt neben ihm.
&lt;/blockquote&gt;

Ein Lobpreis auf die Werke, Engel und Mächte Gottes am Gewölbe des Himmels findet sich im '''Buch Daniel''' im dritten Kapitel. Der Text macht inhaltlich eine ähnliche Aussage wie der Lobpreis auf den Herrn, den König des Kosmos in Psalm 148 (siehe oben):

'''Daniel 3:'''
&lt;blockquote&gt;
56 Gepriesen bist du am Gewölbe des '''Himmels''', gerühmt und verherrlicht in Ewigkeit.&lt;br/&gt;
57 Preist den HERRN, all ihr Werke des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
58 Preist den HERRN, ihr '''Himmel'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
59 Preist den HERRN, ihr Engel des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
60 Preist den HERRN, all ihr '''Wasser über dem Himmel'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
61 Preist den HERRN, all ihr Mächte des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
62 Preist den HERRN, '''Sonne und Mond'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
63 Preist den HERRN, ihr '''Sterne am Himmel'''; lobt und rühmt ihn in Ewigkeit!
&lt;/blockquote&gt;

=== Der Himmelsthron ===
Der '''Himmelsthron''' wir in vielen Texten des Alten Testaments als der Sitz Gottes genannt. Hier zunächst einige Erwähnungen in den Psalmen:

&lt;blockquote&gt;
11,4 Der HERR ist in seinem heiligen Tempel, der HERR hat seinen '''Thron im Himmel'''.&lt;br/&gt;
Seine Augen schauen herab, seine Blicke prüfen die Menschen.
&lt;/blockquote&gt;

&lt;blockquote&gt;
33,13 Der HERR blickt herab vom '''Himmel''', er sieht alle Menschen.&lt;br/&gt;
33,14 Von seinem '''Thronsitz''' schaut er nieder auf alle Bewohner der Erde.
&lt;/blockquote&gt;

&lt;blockquote&gt;
89,37 Sein Haus soll bleiben auf ewig, sein '''Thron''' habe Bestand vor mir wie die '''Sonne''';
&lt;/blockquote&gt;

&lt;blockquote&gt;
103,19 Der HERR hat seinen '''Thron''' errichtet im '''Himmel''', seine königliche Macht beherrscht '''das All'''.
&lt;/blockquote&gt;

Im Buch der Weisheit stehen die folgenden beiden Verse:

&lt;blockquote&gt;
9,9 Mit dir ist die Weisheit, die deine Werke kennt und die zugegen war, als du die Welt erschufst. Sie weiß, was wohlgefällig ist in deinen Augen und was recht ist nach deinen Geboten.&lt;br/&gt;
9,10 Sende sie vom heiligen '''Himmel''' und schick sie vom '''Thron''' deiner Herrlichkeit, damit sie bei mir sei und alle Mühe mit mir teile und ich erkenne, was wohlgefällig ist bei dir!
&lt;/blockquote&gt;

Diese Bild von Gottes Thron im Himmel wir auch im Neuen Testament aufgegriffen, wie beispielsweise beim Evangelisten Matthäus (Kapitel 5, Vers 34) oder in der Offenbarung des Johannes, wo im vierten Kapitel die eröffnende Himmelsvision mit dem Abschnitt über &quot;Die Huldigung vor dem Thron Gottes&quot; beginnt:

&lt;blockquote&gt;
1 Danach sah ich und siehe, eine Tür war geöffnet am '''Himmel'''; und die erste Stimme, die ich gleich einer Posaune mit mir reden gehört hatte, sagte: Komm herauf und ich werde dir zeigen, was dann geschehen muss.&lt;br/&gt;
2 Sogleich wurde ich vom Geist ergriffen. Und siehe, '''ein Thron stand im Himmel'''; auf dem Thron saß einer,&lt;br/&gt;
3 der wie ein Jaspis und ein Karneol aussah. Und über dem '''Thron''' wölbte sich ein Regenbogen, der wie ein Smaragd aussah.&lt;br/&gt;
4 Und rings um den '''Thron standen vierundzwanzig Throne''' und auf den Thronen saßen vierundzwanzig Älteste, in weiße Gewänder gekleidet und mit goldenen Kränzen auf dem Haupt.&lt;br/&gt;
5 Von dem Thron gingen Blitze, Stimmen und Donner aus. Und '''sieben lodernde Fackeln brannten vor dem Thron; das sind die sieben Geister Gottes'''.&lt;br/&gt;
6 Und vor dem Thron war etwas wie ein gläsernes Meer, gleich Kristall. Und in der Mitte des Thrones und rings um den Thron waren '''vier Lebewesen''' voller Augen, vorn und hinten.&lt;br/&gt;
7 Das erste Lebewesen glich einem '''Löwen''', das zweite einem '''Stier''', das dritte sah aus wie ein '''Mensch''', das vierte glich einem '''fliegenden Adler'''.&lt;br/&gt;
&lt;/blockquote&gt;

Der achtstrophige Adventshymnus ''Veni redemptor gentium'' (die deutschsprachige Kontrafaktur heißt &quot;Nun komm, der Heiden Heiland&quot;) wird dem Kirchenvater Ambrosius von Mailand (339–397) zugeschrieben. In der fünften Strophe wird mit Bezug auf die Himmelfahrt des Messias der Sitz Gottes erwähnt:

&lt;blockquote&gt;
5,1 Egressus eius a Patre,&lt;br/&gt;
5,2 Regressus eius ad Patrem;&lt;br/&gt;
5,3 Excursus usque ad inferos,&lt;br/&gt;
5,4 Recursus ad '''sedem Dei'''.
&lt;/blockquote&gt;

&lt;blockquote&gt;
5,1 Sein Ausgang ist vom Vater,&lt;br/&gt;
5,2 Seine Rückkehr ist beim Vater;&lt;br/&gt;
5,3 Hinausgelaufen bis zu den Toten,&lt;br/&gt;
5,4 Zurückgelaufen bis zum '''Sitz Gottes'''.
&lt;/blockquote&gt;

Es ist nicht viel Phantasie erforderlich, um den Thron Gottes im '''Himmelsstier''' wiederzuerkennen. Die vierundzwanzig Throne, die sich entlang der '''Ekliptik''' um diesen Thron herum aufreihen, stehen für die vierundzwanzig Stunden eines Tages, und sie sind je zwei für jedes der zwölf Lebewesenkreiszeichen des '''Zodiaks'''. Die als sieben lodernde Fackeln vor dem Thron sind die sieben '''Wandelgestirne''', die als die '''sieben Geister Gottes''' immer wieder durch das '''Goldene Tor der Ekliptik''' in der Sitzfläche des Thrones ziehen. Die '''vier besonderen Lebewesen''' sind die vier Evangelistensymbole bei den vier zoroastrischen '''Königssternen'''.

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|'''Himmelsstier''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Die_Ekliptik|'''Ekliptik''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|'''Zodiak''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|'''Goldenes Tor der Ekliptik''']].

→ Siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Vier_in_Religionen|'''Bedeutung der Vier in Religionen''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Königssterne|'''Königssterne''']].

&lt;gallery caption=&quot;Throne&quot; widths=640 heights=480 perrow=3&gt;
StatueOfEl.png|Rekonstruktion der 1988 in Ugarit ausgegrabenen und auf einem Thron sitzenden Statue vom höchsten ugaritischen Gott El, der als Erschaffer der Welt angebetet wurde.
Aachen_Cathedral_Karlsthron_02.jpg|Thron Karls des Großen aus den 790er Jahren im Aachener Dom.
Himmelsthron.Taurus.Aries.png|Himmelsthron in den Sternbildern Stier (Taurus) und Widder (Aries) vor dem Untergang in Richtung Westen.
&lt;/gallery&gt;

=== Das Lamm ===
Im ersten Kapitel des Evangeliums nach Johannes wird Jesus von Nazareth explizit als &quot;Lamm Gottes&quot; bezeichnet:&lt;ref&gt;[https://www.bibleserver.com/EU/Johannes1%2C29 Johannes 1,29], bibleserver.com, Einheitsübersetzung (2016)&lt;/ref&gt;

&lt;blockquote&gt;
29b Seht, das '''Lamm Gottes''', das die Sünde der Welt hinwegnimmt!&lt;br/&gt;
...&lt;br/&gt;
36b Seht, das '''Lamm Gottes'''!
&lt;/blockquote&gt;

Es handelt sich beim „Lamm Gottes“ (Kirchenlatein: „Agnus Dei“) um ein seit ältester Zeit verbreitetes Symbol für Jesus Christus. Es wird auch als das Osterlamm bezeichnet, das am Ostertag, also kurz nach der Tag-und-Nacht-Gleiche im Frühjahr auferstanden ist. Nach dem Evangelisten Markus wurde die Auferstehung „... am ersten Tag der Woche, früh am Morgen, als eben die Sonne aufging“, also am Ostersonntag während der Morgenröte im Osten entdeckt.&lt;ref&gt;[https://www.bibleserver.com/LUT/Markus16%2C2 Markus 16,2], Einheitsübersetzung, 2016&lt;/ref&gt; Am 40.&amp;nbsp;Tag ist Jesus Christus nach dem Zeugnis der Evangelisten Markus und Lukas in den Himmel aufgefahren. Zu Beginn der Apostelgeschichte wird dieses Ereignis folgendermaßen beschrieben:&lt;ref&gt;[https://www.bibleserver.com/EU/Apostelgeschichte1 Apostelgeschichte 1], Einheitsübersetzung, 2016&lt;/ref&gt;

&lt;blockquote&gt;
7 Er sagte zu ihnen: Euch steht es nicht zu, Zeiten und Fristen zu erfahren, die der Vater in seiner Macht festgesetzt hat.&lt;br/&gt;
8 Aber ihr werdet Kraft empfangen, wenn der Heilige Geist auf euch herabkommen wird; und ihr werdet meine Zeugen sein in Jerusalem und in ganz Judäa und Samarien und bis an die Grenzen der Erde.&lt;br/&gt;
9 Als er das gesagt hatte, wurde er vor ihren Augen emporgehoben und eine Wolke nahm ihn auf und entzog ihn ihren Blicken.&lt;br/&gt;
&lt;/blockquote&gt;

Im altrömischen Glaubensbekenntnis gibt es die Textstelle:

&lt;blockquote&gt;
„ascendit in caelis, sedet ad dexteram Patris“
&lt;/blockquote&gt;

Zu Deutsch:

&lt;blockquote&gt;
„aufgefahren in den Himmel, er sitzt zur Rechten des Vaters“
&lt;/blockquote&gt;

Das '''Lamm''' (astronomisch Widder) befindet sich am nördlichen Sternenhimmel '''zur Rechten''' des Stieres (Taurus). Sowohl der mesopotamische Himmelsstier als auch das altarabische Sternbild Thuraya verbinden diese beiden neuzeitlichen Sternbilder zu einer Einheit. Der Hauptstern im Sternbild Widder (Aries) heißt Hamal, und das arabische Wort &quot;hamal&quot; steht für ein einjähriges Lamm.&lt;ref name=&quot;Adams&quot;&gt;Danielle Adams: [http://onesky.arizona.edu/arab-star-names/the-lamb/ The Lamb – A folkloric celestial complex], Two Deserts, one Sky – Arab Star Calendars&lt;/ref&gt; Der fette Schwanz des Lammes wird durch die '''Plejaden (Siebengestirn)''' markiert.&lt;ref name=&quot;Adams&quot; /&gt; Die Augen des Stieres sind die Sterne '''Aldebaran''' und '''Ain'''. Zwischen dem Kopf des Stieres und den '''Plejaden''' befindet sich das '''Goldene Tor der Ekliptik''', durch das alle Wandelgestirne regelmäßig hindurchziehen.

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Bibelstellen|'''Bibelstellen zum Siebengestirn''']].

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|'''Goldenes Tor der Ekliptik''']].

Der Frühlingspunkt der Sonne, also deren Ort auf der Ekliptiklinie zur Tag-und-Nacht-Gleiche im Frühjahr, ist von der monotheistischen Schöpfung bis zur Geburt des christlichen Gottessohns vom Kopf des Stiers (bei den Sternen '''Aldebaran''' und '''Ain''' im Goldenen Tor der Ekliptik) im heutigen Sternbild Stier (Taurus) bis zum Kopf des Lammes (beim Stern '''Hamal''') im heutigen Sternbild Widder (Aries) nach Westen gewandert. Heute befindet sich der Frühlingspunkt bereits am westlichen Ende des Sternbilds Fische (Pisces), das sich westlich an das Sternbild Widder anschließt.

==== Offenbarung des Johannes ====
In der Offenbarung des Johannes heißt es im 7.&amp;nbsp;Kapitel:

&lt;blockquote&gt;
10b Die Rettung kommt von unserem '''Gott''', der auf dem '''Thron''' sitzt, und von dem '''Lamm'''.&lt;br/&gt;
17a Denn das Lamm in der Mitte vor dem Thron wird sie weiden und zu den Quellen führen, aus denen das '''Wasser des Lebens''' strömt.
&lt;/blockquote&gt;

Wird der '''Thron Gottes''' mit dem Himmelsstier identifiziert (siehe oben), dann sitzt das '''Lamm''' (Aries, Sternbild Widder) westlich und somit rechts vor diesem Thron. Im weiteren Verlauf der Ekliptik nach Westen befinden sich die zusammenhängenden '''Wassersternbilder''' des Urozeans, dem Urquell des Lebens. Es handelt ich um die heutigen Sternbilder Fluss Eridanus, Walfisch (Cetus), Fische (Pisces), Wassermann (Aquarius), Südlicher Fisch (Piscis Austrinus) und Delphin (Delphinus) sowie Steinbock (Capricornus, früher Ziegenfisch).

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Urozean''']].

&lt;gallery caption=&quot;Das Lamm zur Rechten des Stieres&quot; mode=packed widths=800 heights=600&gt;
Himmelsstier.P1117152.jpg|Astrophotographie vom Asterismus Himmelsstier
Himmelsstier.Sternbilder.P1117152.png|Beschriftete Astrophotographie vom Himmelsstier am winterlichen Abendhimmel in Richtung südlicher Meridian. Die Ekliptiklinie verläuft horizontal etwas unterhalb der Bildmitte.
Haende.der.Thuraya.Vollmond.Sterne.P1079912.jpg|Astrophotographie der Himmelsregion mit dem beduinischen Sternbild &quot;Hände der Thuraya&quot; (grüne durchgezogene Linien, Ekliptik rot gepunktete Linie) mit arabisch bezeichneten Sternen. Der Vollmond befindet sich zwischen den Sternbildern Taurus, Aries und Cetus.
Urozean.Wassersternbilder.png|Die zusammenhängenden Wassersternbilder des Urozeans am Sternenhimmel: Fluss Eridanus, Walfisch (Cetus), Fische (Pisces), Wassermann (Aquarius), Südlicher Fisch (Piscis Austrinus), Delphin (Delphinus) sowie Ziegenfisch (Steinbock, Capricornus).
&lt;/gallery&gt;

Interpretiert man das Sternbild &quot;Lamm&quot; (Widder / Aries) als Mittler auf dem ekliptischen Weg vom finsteren kosmischen Urozean im Westen (rechts) zum strahlenden majestätischen Sternbild Stier (Taurus) im Osten (links), ergeben auch andere Bibelstellen in Bezug auf den Sternenhimmel einen tiefen symbolischen Sinn, die in den folgenden Abschnitten aufgeführt sind.

==== Evangelium nach Johannes ====
Die Rede von Jesus an den Jünger Thomas aus dem 14.&amp;nbsp;Kapitel des Evangeliums nach Johannes ist in diesem Zusammenhang interessant:

&lt;blockquote&gt;
6 Jesus sagte zu ihm: Ich bin der Weg und die Wahrheit und das Leben; niemand kommt zum Vater außer durch mich.&lt;br/&gt;
7 Wenn ihr mich erkannt habt, werdet ihr auch meinen Vater erkennen. Schon jetzt kennt ihr ihn und habt ihn gesehen.
&lt;/blockquote&gt;

Alle Wandelgestirne bewegen sich entlang der Ekliptiklinie (Weg) durch das heutige Sternbild Widder (das altarabische Sternbild &quot;Lamm&quot;) im Westen zum [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der-Ekliptik|Goldenen Tor der Ekliptik]] nach Osten im großen Himmelsstier (Vater / Thron).

==== Evangelium nach Markus ====
Im Evangelium nach Markus heißt es:

&lt;blockquote&gt;
14,62 Jesus sagte: Ich bin es. Und ihr werdet den Menschensohn '''zur Rechten der Macht''' sitzen und mit den Wolken des '''Himmels''' kommen sehen.
&lt;/blockquote&gt;

&lt;blockquote&gt;
16,19 Nachdem Jesus, der Herr, dies zu ihnen gesagt hatte, wurde er in den '''Himmel''' aufgenommen und setzte sich '''zur Rechten Gottes'''.
&lt;/blockquote&gt;

==== Evangelium nach Lukas ====
Im Evangelium nach Lukas ist es folgendermaßen formuliert:

&lt;blockquote&gt;
22,69 Von nun an wird der Menschensohn '''zur Rechten der Macht Gottes''' sitzen.
&lt;/blockquote&gt;

==== Evangelium nach Matthäus ====
Auch im Evangelium nach Matthäus findet sich eine entsprechende Stelle:

&lt;blockquote&gt;
26,64 Jesus antwortete: Du hast es gesagt. Doch ich erkläre euch: Von nun an werdet ihr den Menschensohn '''zur Rechten der Macht''' sitzen und auf den Wolken des '''Himmels''' kommen sehen.
&lt;/blockquote&gt;

==== Brief an die Hebräer ====
Im Brief an die Hebräer, dessen Autor unbekannt ist, gibt es etliche entsprechende Stellen:

&lt;blockquote&gt;
'''Gottes Rede in seinem Sohn'''&lt;br/&gt;
1,3 er ist der Abglanz seiner Herrlichkeit und das Abbild seines Wesens; er trägt '''das All''' durch sein machtvolles Wort, hat die Reinigung von den Sünden bewirkt und sich dann '''zur Rechten der Majestät in der Höhe''' gesetzt;&lt;br/&gt;
1,10 Und: Du, Herr, hast vorzeiten der Erde Grund gelegt, die '''Himmel''' sind das Werk deiner Hände.&lt;br/&gt;
1,11 Sie werden vergehen, '''du aber bleibst'''; sie alle veralten wie ein Gewand;&lt;br/&gt;
1,12 du rollst sie zusammen wie einen Mantel und wie ein Gewand werden sie gewechselt. Du aber bleibst, der du bist, und '''deine Jahre enden nie'''.&lt;br/&gt;
1,13 Zu welchem Engel hat er jemals gesagt: Setze dich mir '''zur Rechten''' und ich lege dir deine Feinde als Schemel unter die Füße?
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Die Liturgie des neuen Bundes'''&lt;br/&gt;
8,1 Die Hauptsache bei dem Gesagten aber ist: Wir haben einen solchen Hohepriester, der sich '''zur Rechten des Thrones der Majestät im Himmel''' gesetzt hat,&lt;br/&gt;
8,2 als Diener des Heiligtums und des '''wahren Zeltes''', das der Herr selbst aufgeschlagen hat, nicht ein Mensch.
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Christus als Mittler des neuen Bundes'''&lt;br/&gt;
9,24 Denn Christus ist nicht in ein von Menschenhand gemachtes Heiligtum hineingegangen, in ein Abbild des wirklichen, sondern '''in den Himmel selbst''', um jetzt '''vor Gottes Angesicht''' zu erscheinen für uns;
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Das Opfer Jesu Christi als endgültige Versöhnung mit Gott'''&lt;br/&gt;
10,12 Dieser aber hat nur ein einziges Opfer für die Sünden dargebracht und sich dann '''für immer zur Rechten Gottes''' gesetzt;
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Das Beispiel Jesu Christi'''&lt;br/&gt;
12,2 und dabei auf Jesus blicken, den Urheber und Vollender des Glaubens; er hat angesichts der vor ihm liegenden Freude das Kreuz auf sich genommen, ohne auf die Schande zu achten, und sich '''zur Rechten von Gottes Thron''' gesetzt.
&lt;/blockquote&gt;

==== Erster Brief des Petrus ====
Der erste Brief des Petrus zählt zu den katholischen Briefen des Neuen Testaments. Dort heißt es im letzten Satz über Jesus Christus:

&lt;blockquote&gt;
22 der in den '''Himmel''' gegangen ist; dort ist er '''zur Rechten''' Gottes und Engel, Gewalten und Mächte sind ihm unterworfen.
&lt;/blockquote&gt;

==== Apostelgeschichte ====
Die Apostelgeschichte schließt an das Evangelium nach Lukas an und wird ebenfalls diesem zugeschrieben. Hier kommen der erste bekennende sowie erste berufene Apostel Petrus und der erste christliche Märtyrer Stephanus zu Wort:

&lt;blockquote&gt;
'''Die Pfingstpredigt des Petrus'''&lt;br/&gt;
2,33 '''Zur Rechten Gottes''' erhöht, hat er vom Vater den verheißenen Heiligen Geist empfangen und ihn ausgegossen, wie ihr seht und hört.
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Steinigung des Stephanus'''&lt;br/&gt;
7,55 Er aber, erfüllt vom Heiligen Geist, blickte zum '''Himmel''' empor, sah die Herrlichkeit Gottes und Jesus '''zur Rechten Gottes''' stehen&lt;br/&gt;
7,56 und rief: Siehe, ich sehe den Himmel offen und den Menschensohn '''zur Rechten Gottes''' stehen.
&lt;/blockquote&gt;

=== Himmelspforte ===
Das Sternbild Widder (Aries) repräsentiert als das Lamm Gottes den nördlichen Pfeiler des Goldenen Tors der Ekliptik. Der fette Schwanz des Lammes wird nach altarabischer Tradition durch das Siebengestirn (Plejaden) gebildet, das heute zu Sternbild '''Stier''' (Taurus) gezählt wird. Der südliche Pfeiler des Goldenen Tors der Ekliptik wird durch die Hyaden und den Stern Menkar im Sternbild Walfisch (Cetus) gebildet. Das Goldene Tor der Ekliptik stellt mit diesen beiden Pfeilern somit eine '''Himmelspforte''' dar, durch die alle Wandelgestirne regelmäßig von Westen aus dem dunklen Urozean der winterlichen Wassersternbilder sowie der Richtung des Sonnenuntergangs nach Osten in das helle Gebiet des Sternenhimmels mit den Frühlings- und Sommersternbildern sowie die Richtung des Sonnenaufgangs treten.

[[Datei:Mars.im.Goldenen.Tor.der.Ekliptik.P1091607.jpg|mini|hochkant=3|zentriert|Der am nordwestlichen Horizont in der Nähe der Ekliptiklinie und im Goldenen Tor der Ekliptik untergehende Mars (rote Scheibe unten halb rechts) drei Tage vor dem Durchqueren der '''Himmelspforte''' zwischen dem Kopf des Himmelsstieres mit dem Sternhaufen der Hyaden (unten links) und den Plejaden nördlich der Ekliptik (rechts unten).]]

Die Genesis berichtet im 28.&amp;nbsp;Kapitel unter der Überschrift &quot;Jakob in Bet-El&quot; (hebräisch בֵּית אֵל „Haus des El“ oder „Haus Gottes“) über einen Traum von Jakob, in dem er eine Treppe zum Himmel (die Himmelsleiter oder Jakobsleiter) sieht, an dessen oberen Ende sich das Tor des Himmels (die Himmelspforte) befindet:

&lt;blockquote&gt;
10 Jakob zog aus Beerscheba weg und ging nach Haran.&lt;br/&gt;
11 Er kam an einen bestimmten Ort und übernachtete dort, denn die Sonne war untergegangen. Er nahm einen von den Steinen dieses Ortes, legte ihn unter seinen Kopf und schlief dort ein.&lt;br/&gt;
12 Da hatte er einen Traum: Siehe, eine Treppe stand auf der Erde, ihre Spitze reichte bis zum '''Himmel'''. Und siehe: Auf ihr stiegen Engel Gottes auf und nieder.&lt;br/&gt;
13 Und siehe, der HERR stand vor ihm und sprach: Ich bin der HERR, der Gott deines Vaters Abraham und der Gott Isaaks. Das Land, auf dem du liegst, will ich dir und deinen Nachkommen geben.&lt;br/&gt;
14 Deine Nachkommen werden zahlreich sein wie der Staub auf der Erde. Du wirst dich '''nach Westen und Osten, nach Norden und Süden''' ausbreiten und durch dich und deine Nachkommen werden alle Sippen der Erde Segen erlangen.&lt;br/&gt;
15 Siehe, ich bin mit dir, ich behüte dich, wohin du auch gehst, und bringe dich zurück in dieses Land. Denn ich verlasse dich nicht, bis ich vollbringe, was ich dir versprochen habe.&lt;br/&gt;
16 Jakob erwachte aus seinem Schlaf und sagte: Wirklich, der HERR ist an diesem Ort und ich wusste es nicht.&lt;br/&gt;
17 Er fürchtete sich und sagte: Wie Ehrfurcht gebietend ist doch dieser Ort! Er ist nichts anderes als das Haus Gottes und das '''Tor des Himmels'''.&lt;br/&gt;
&lt;/blockquote&gt;

El war für die semitischen Ugariter im zweiten vorchristlichen Jahrtausend der Name ihres höchsten Gottes. Ihm wurden die Beinamen „König“, „Freundlicher“ und „'''Stier'''“ verliehen. Diese Symbolik weist auf den Himmelsstier hin. Der Name El wurde von den Israeliten übernommen, und dieser Gott wurde von ihnen mit ihrem einzigen Gott gleichgesetzt. Der Gott El wurde vom Gott Baal verdrängt, der ebenfalls mit Stierhörnern konnotiert war. Er wurde auch als donnernder und Blitze schleudernder Gott dargestellt, was sich in den Mythen des antiken Griechenlands in der Figur des höchsten griechischen Gottes Zeus (Jupiter) widerspiegelt. In diesem Zusammenhang sei auf noch weitere Parallelitäten den verschiedenen Götterkulturen hingewiesen, die sich zum ugaritischen Baal-Zyklus ergeben, der in den keilalphabetischen Texten aus Ugarit (KTU) zu finden ist. Am Schluss dieses Werkes wird die kanaanitische Sonnengöttin Šapšu, die Zweitfrau von El, für die Wiederherstellung und Bewahrung der kosmischen Ordnung zu einem Opfermahl eingeladen, bei der ihr '''Brot und Wein''' dargeboten werden.&lt;ref&gt;Herbert Niehr: ''Der Ba‘al-Zyklus (KTU 1.1-6 + 1.8)'', Gütersloh 2015, S. 236.&lt;/ref&gt;

Jakob war der der erste der drei Erzväter des Volkes Israel und der älteste Sohn des ältesten Sohnes Isaak von Abraham. Abraham war aus dem mesopotamischen Ur über Haran nach Bet-El gezogen, und Jakob ging in dieser Schilderung aus Beerscheba in der Nähe des Ortes Bet-El nach Haran zurück.

Der Apostel Paulus schreibt in seinem zweiten Brief an die Bewohner der griechischen Hafenstadt Korinth zu Beginn des 5.&amp;nbsp;Kapitels mit der Überschrift &quot;Die Hoffnung des Apostels&quot; über das Gebäude hinter der Pforte zum Himmel:

&lt;blockquote&gt;
1 Wir wissen: Wenn unser irdisches Zelt abgebrochen wird, dann haben wir eine Wohnung von Gott, ein nicht von Menschenhand errichtetes '''ewiges Haus im Himmel'''.
&lt;/blockquote&gt;

=== Gedanken zur wundersamen Brotvermehrung ===
==== Evangelien ====
[[Datei:Face de chapiteau figurant la Multiplication des pains, choeur de l'église de Saint-Nectaire, Puy-de-Dôme.jpg|mini|rechts|hochkant=2|Jesus mit vier seiner Jünger mit fünf Broten und zwei Fischen an einem Säulenkapitell in der romanischen Wallfahrtskirche Saint Nectaire auf dem Mont Cornadore in Saint-Nectaire in Frankreich (Département Puy-de-Dôme in der Region Auvergne-Rhône-Alpes).]]

Die wundersame Speisung der mehreren Tausend mit wenigen Broten und Fischen wird in aller vier Evangelien der Bibel erwähnt. Das Ereignis fand auf einem Berg am Ufer des Sees von Galiläa (auch als &quot;See von Tiberias&quot;, &quot;See Genezareth&quot; oder &quot;Galiläisches Meer&quot; bekannt) statt. In der abgelegenen Gegend gab es damals sehr wenig künstliche Lichtquellen, so dass ein ungestörter Anblick des Sternenhimmels möglich war.

===== Evangelium nach Johannes =====
Im sechsten Kapitel des Evangeliums nach '''Johannes''' tauchen bei der Beschreibung der Brotvermehrung durch Jesus zum jüdischen Pessachfest neben einigen weiteren Symbolen mit astronomischer Deutungsmöglichkeit auch die expliziten Zahlen Zwei, Fünf und Zwölf auf:

&lt;blockquote&gt;
9 Hier ist ein kleiner Junge, der hat '''fünf Gerstenbrote''' und '''zwei Fische'''; doch was ist das für so viele?&lt;br/&gt;
10 Jesus sagte: Lasst die Leute sich setzen! Es gab dort nämlich viel Gras. Da setzten sie sich; es waren etwa '''fünftausend''' Männer.&lt;br/&gt;
11 Dann nahm Jesus die '''Brote''', sprach das Dankgebet und teilte an die Leute aus, so viel sie wollten; ebenso machte er es mit den '''Fischen'''.&lt;br/&gt;
12 Als die Menge satt geworden war, sagte er zu seinen Jüngern: Sammelt die übrig gebliebenen Brocken, damit nichts verdirbt!&lt;br/&gt;
13 Sie sammelten und füllten '''zwölf Körbe''' mit den Brocken, die von den '''fünf Gerstenbroten''' nach dem Essen übrig waren.&lt;br/&gt;
...&lt;br/&gt;
31 Unsere Väter haben das '''Manna''' in der Wüste gegessen, wie es in der Schrift heißt: '''Brot vom Himmel''' gab er ihnen zu essen.&lt;br/&gt;
32 Jesus sagte zu ihnen: Amen, amen, ich sage euch: Nicht Mose hat euch das '''Brot vom Himmel''' gegeben, sondern mein Vater gibt euch das wahre '''Brot vom Himmel'''.&lt;br/&gt;
33 Denn das '''Brot''', das Gott gibt, kommt vom '''Himmel''' herab und gibt der Welt das Leben.&lt;br/&gt;
34 Da baten sie ihn: Herr, gib uns immer dieses '''Brot'''!&lt;br/&gt;
35 Jesus antwortete ihnen: Ich bin das '''Brot des Lebens'''; wer zu mir kommt, wird nie mehr hungern, und wer an mich glaubt, wird nie mehr Durst haben.&lt;br/&gt;
...&lt;br/&gt;
48 Ich bin das '''Brot des Lebens'''.&lt;br/&gt;
49 Eure Väter haben in der Wüste das '''Manna''' gegessen und sind gestorben.&lt;br/&gt;
50 So aber ist es mit dem '''Brot''', das vom '''Himmel''' herabkommt: Wenn jemand davon isst, wird er nicht sterben.&lt;br/&gt;
51 Ich bin das '''lebendige Brot''', das vom '''Himmel''' herabgekommen ist. Wer von diesem '''Brot''' isst, wird in Ewigkeit leben. Das '''Brot''', das ich geben werde, ist mein Fleisch für das Leben der Welt.
&lt;/blockquote&gt;

===== Evangelium nach Markus =====
Eine ähnliche Schilderung befindet sich im sechsten Kapitel des Evangeliums nach '''Markus''', wo das Ereignis an einem abgelegenen und einsamen Ort stattgefunden hat:

&lt;blockquote&gt;
38 Er sagte zu ihnen: Wie viele '''Brote''' habt ihr? Geht und seht nach! Sie sahen nach und berichteten: '''Fünf Brote''' und außerdem '''zwei Fische'''.&lt;br/&gt;
39 Dann befahl er ihnen, sie sollten sich in Mahlgemeinschaften im grünen Gras lagern.&lt;br/&gt;
40 Und sie ließen sich in Gruppen zu hundert und zu fünfzig nieder.&lt;br/&gt;
41 Darauf nahm er die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis, brach die '''Brote''' und gab sie den Jüngern, damit sie diese an die Leute austeilten. Auch die '''zwei Fische''' ließ er unter allen verteilen.&lt;br/&gt;
42 Und alle aßen und wurden satt.&lt;br/&gt;
43 Und sie hoben Brocken auf, '''zwölf Körbe''' voll, und Reste von den '''Fischen'''.&lt;br/&gt;
44 Es waren '''fünftausend''' Männer, die von den '''Broten''' gegessen hatten.
&lt;/blockquote&gt;

Die Brotvermehrung auch ein weiteres Mal im achten Kapitel des Evangeliums nach '''Markus''' erwähnt:

&lt;blockquote&gt;
5 Er fragte sie: Wie viele '''Brote''' habt ihr? Sie antworteten: '''Sieben'''.&lt;br/&gt;
6 Da forderte er die Leute auf, sich auf den Boden zu setzen. Dann nahm er die sieben '''Brote''', sprach das Dankgebet, brach die '''Brote''' und gab sie seinen Jüngern zum Verteilen; und die Jünger teilten sie an die Leute aus.&lt;br/&gt;
7 Sie hatten auch noch ein paar '''Fische''' bei sich. Jesus segnete sie und ließ auch sie austeilen.&lt;br/&gt;
8 Die Leute aßen und wurden satt. Und sie hoben die Überreste der '''Brotstücke''' auf, '''sieben Körbe''' voll.&lt;br/&gt;
9 Es waren etwa '''viertausend''' Menschen beisammen. Danach schickte er sie nach Hause.&lt;br/&gt;
...&lt;br/&gt;
19 Als ich die '''fünf Brote''' für die '''Fünftausend''' brach, wie viele '''Körbe voll Brotstücke''' habt ihr da aufgehoben? Sie antworteten ihm: '''Zwölf'''.&lt;br/&gt;
20 Und als ich die '''sieben Brote''' für die '''Viertausend''' brach, wie viele '''Körbe''' voll habt ihr da aufgehoben? Sie antworteten: '''Sieben'''.&lt;br/&gt;
21 Da sagte er zu ihnen: Versteht ihr immer noch nicht?
&lt;/blockquote&gt;

===== Evangelium nach Lukas =====
Ebenso verhält es sich im neunten Kapitel des Evangeliums nach '''Lukas''', wo das Ereignis dem Ort Betsaida (zu Deutsch: „Haus des Fisches“) am See Genezareth zugeordnet ist:

&lt;blockquote&gt;
12 Als der Tag zur Neige ging, kamen '''die Zwölf''' und sagten zu ihm: Schick die Leute weg, damit sie in die umliegenden Dörfer und Gehöfte gehen, dort Unterkunft finden und etwas zu essen bekommen; denn wir sind hier an einem abgelegenen Ort.&lt;br/&gt;
13 Er antwortete ihnen: Gebt ihr ihnen zu essen! Sie sagten: Wir haben nicht mehr als '''fünf Brote''' und '''zwei Fische'''; wir müssten erst weggehen und für dieses ganze Volk etwas zu essen kaufen.&lt;br/&gt;
14 Es waren nämlich etwa '''fünftausend''' Männer. Er aber sagte zu seinen Jüngern: Lasst sie sich in Gruppen zu ungefähr fünfzig lagern!&lt;br/&gt;
15 Die Jünger taten so und veranlassten, dass sich alle lagerten.&lt;br/&gt;
16 Jesus aber nahm die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis und brach sie; dann gab er sie den Jüngern, damit sie diese an die Leute austeilten.&lt;br/&gt;
17 Und alle aßen und wurden satt. Als man die übrig gebliebenen Brotstücke einsammelte, waren es '''zwölf Körbe''' voll.
&lt;/blockquote&gt;

===== Evangelium nach Matthäus =====
Auch im vierzehnten Kapitel des Evangeliums nach '''Matthäus''' ist von einem abgelegenen Ort in einer einsamen Gegend die Rede:

&lt;blockquote&gt;
17 Sie sagten zu ihm: Wir haben nur '''fünf Brote''' und '''zwei Fische''' hier.&lt;br/&gt;
18 Er antwortete: Bringt sie mir her!&lt;br/&gt;
19 Dann ordnete er an, die Leute sollten sich ins Gras setzen. Und er nahm die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis, brach die Brote und gab sie den Jüngern; die Jünger aber gaben sie den Leuten&lt;br/&gt;
20 und alle aßen und wurden satt. Und sie sammelten die übrig gebliebenen Brotstücke ein, '''zwölf Körbe''' voll.&lt;br/&gt;
21 Es waren etwa '''fünftausend''' Männer, die gegessen hatten, dazu noch Frauen und Kinder.
&lt;/blockquote&gt;

Etwas abgewandelt taucht die Brotvermehrung mit '''sieben Körben''' auch im fünfzehnten Kapitel des Evangeliums nach '''Matthäus''' auf:

&lt;blockquote&gt;
34 Jesus sagte zu ihnen: Wie viele '''Brote''' habt ihr? Sie antworteten: '''Sieben''' - und ein paar '''Fische'''.&lt;br/&gt;
35 Da forderte er die Leute auf, sich auf den Boden zu setzen.&lt;br/&gt;
36 Und er nahm die '''sieben Brote''' und die '''Fische''', sprach das Dankgebet, brach sie und gab sie den Jüngern und die Jünger gaben sie den Menschen.&lt;br/&gt;
37 Und alle aßen und wurden satt. Und sie sammelten die übrig gebliebenen Stücke ein, '''sieben Körbe''' voll.&lt;br/&gt;
38 Es waren '''viertausend''' Männer, die gegessen hatten, dazu noch Frauen und Kinder.&lt;br/&gt;
39 Danach schickte er die Menge nach Hause, stieg ins Boot und fuhr in die Gegend von Magadan.
&lt;/blockquote&gt;

Der Ort Magadan ist möglicherweise mit dem heutigen Ort Migdal (aramäisch: Magdala) am westlichen Ufer des Sees Genezareth gleichzusetzen.

==== Astronomische Bezüge ====
[[Datei:Sternenhimmel.Pessach.25.3.23.png|mini|rechts|hochkant=2|Sternenhimmel am jüdischen Pessachfest im Jahr 25 nach Christus. Der Vollmond stand hoch über dem Horizont im Süden im Herbstpunkt beim Stern Spica (= &quot;Kornähre&quot;) im Sternbild Jungfrau (Virgo). Gleichzeitig befand sich die Sonne tief unter dem Horizont im Norden in der Nähe des Frühlingspunktes im Sternbild Fische (Pisces).]]
[[Datei:Dendera.09.Jungfrau.Loewe.jpg|mini|rechts|hochkant=2|Das Sternbild Jungfrau (links) mit der Kornähre in der Hand und das Sternbild Löwe (rechts) im ägyptischen Zodiak von Dendera aus der Zeit kurz vor Christi Geburt.]]
[[Datei:Dendera.03.Fische.Wassermann.jpg|mini|rechts|hochkant=2|Das Sternbild Fische (links) und das Sternbild Wassermann (rechts unten) im ägyptischen Zodiak von Dendera aus der Zeit kurz vor Christi Geburt.]]

Zu diesen Bibelstellen sind im Folgenden einige Hinweise mit astronomischen Bezügen aufgeführt. Die [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|Bezugspunkte]] liegen hierbei in der Nähe der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Die_Ekliptik|Ekliptik]]:

* In den Versen im Evangelium nach Johannes ist mehrfach vom '''Brot, das vom Himmel herabkommt''' die Rede.
* Das zur Herstellung von Brot erforderliche Getreide kann durch eine '''Kornähre''' symbolisiert werden. Am Sternenhimmel wird die Kornähre durch den hellen, ekliptiknahen Stern '''Spica''' (α Virginis) im Sternbild '''Jungfrau''' (Virgo) repräsentiert. Der Vollmond stand zum jüdischen Pessachfest beim Stern Spica.
* Alle Pflanzen benötigen für das Gedeihen '''Wasser'''. Das '''Wasser''' wird am Himmel durch die drei Wassersternbilder der Ekliptik '''Fische''' (Pisces), '''Wassermann''' (Aquarius), und '''Ziegenfisch''' (Steinbock, Capricornus) westlich des [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Frühlingspunkt|Frühlingspunktes]] repräsentiert. Diese Sternbilder bilden mit einigen weiteren angrenzenden Wassersternbildern den [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|Urozean am Himmel]] (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Trichter_der_Thuraya|Der Trichter der Thuraya]]). Die Wassersternbilder waren zum Pessachfest in den drei Monaten unmittelbar zuvor von der Sonne durchlaufen worden und befanden sich beim Sonnenuntergang deshalb bereits unterhalb des westlichen Horizonts.
* Das Sternbild '''Fische''' (Pisces) besteht seit der Antike aus '''zwei Fischen'''.
* Zu Lebzeiten von Jesus von Nazareth war der '''Frühlingspunkt''' vom Sternbild Widder (Aries, ursprünglich das Hinterteil des großen Sternbilds [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|Himmelsstier (Taurus caeli)]]) in das Sternbild '''Fische''' (Pisces) gewandert. Inzwischen ist er innerhalb dieses Sternbilds noch weiter nach Westen gewandert. Die Sonne und der Neumond standen zu Beginn des jüdischen Monats Nisan, also dem Monat des jüdischen Pessachfestes, im Sternbild '''Fische'''. Der erste Monat des Jahres Nisan hieß bereits in der mesopotamischen Tradition, als sich der Frühlingspunkt noch im Sternbild Widder (Aries) befand, auf Akkadisch &quot;nisannu&quot; (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|Plejaden-Schaltregeln]]). In der alten jüdischen Tradition war der Nisan deswegen mit dem Sternbild Widder verbunden. Ferner wurde der Widder dem israelitischen Stamm Juda zugeordnet.
* Zu Lebzeiten von Jesus von Nazareth war der '''Herbstpunkt''' vom Sternbild Waage (Libra, ursprünglich die Scheren des großen Sternbilds [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsskorpion|Himmelsskorpion (Scorpio caeli)]]) in das Sternbild Jungfrau (Virgo) gewandert. Inzwischen ist er innerhalb dieses Sternbilds noch weiter nach Westen gewandert. Um 285 nach Christi erreichte der '''Herbstpunkt''' dann die ekliptikale Länge des Sterns '''Spica''' (α Virginis).
* Der '''Frühlingspunkt''' –&amp;nbsp;damals im Sternbild Fische&amp;nbsp;– und der '''Herbstpunkt''' –&amp;nbsp;damals im Sternbild Jungfrau (Virgo) beim Stern Spica&amp;nbsp;– befinden sich immer in genau gegenüber liegenden Punkten auf der Ekliptik. Auf diese Weise umfassen diese beiden ausgezeichneten Punkte den Lebewesenkreis (Zodiak) mit seinen '''zwölf''' Sternbildern sowie die Bahnen aller '''sieben''' Wandelgestirne. Diese beiden Punkte teilten die Ekliptik in '''zwei''' gleichgroße Teile, das Sommerhalbjahr und das Winterhalbjahr. Siehe hierzu auch &quot;[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|Beobachtungen in der Nähe der Ekliptik]]&quot;.
** Die '''fünf Brote''' können also mit den fünf mit bloßem Auge sichtbaren Wandelgestirnen (Planeten) '''Merkur''', '''Venus''', '''Mars''', '''Jupiter '''und '''Saturn''' gleichgesetzt werden.&lt;br/&gt;'''''Anmerkung''': In der Bibel wird in der Regel nicht zwischen Fixsternen und Planeten unterschieden. Für eine Ausnahme siehe 2.&amp;nbsp;Buch der Könige, Kapitel 23, Vers 5 aus dem siebenten vorchristlichen Jahrhundert, wo in der Einheitsübersetzung explizit von &quot;den Wandelsternen&quot; und in der Luther-Bibel von &quot;den Planeten&quot; die Rede ist.&lt;ref&gt;[https://www.bibleserver.com/EU/2.K%C3%B6nige23%2C5 2.&amp;nbsp;Buch der Könige, Kapitel 23, Vers 5], bibleserver.com, Einheitsübersetzung 2016&lt;/ref&gt; Die Vulgata schreibt hier allerdings von den &quot;duodecim signis&quot; (zu Deutsch: &quot;'''zwölf''' Zeichen&quot;), womit die '''zwölf''' Sternzeichen der Ekliptik gemeint sind, durch die die '''sieben''' Wandelgestirne ziehen. Die Septuaginta spricht noch allgemeiner von den &quot;μαζουρωθ&quot; (&quot;mazuroth&quot;) nach dem Hebräischen Wort &quot;מַזָּלָה&quot; (&quot;mazzaroth&quot;), womit allgemein eher Sternkonstellationen und nur im engeren Sinne die Sternzeichen des Zodiaks gemeint sind.''
** Die '''zwei Fische''' können also mit den beiden flächenhaft wahrnehmbaren Wandelgestirnen '''Sonne''' und '''Mond '''gleichgesetzt werden.
** Die Summe der '''fünf Brote''' und der '''zwei Fische''' respektive die '''sieben Brote''' (oder die '''sieben Körbe''') entsprechen der Anzahl der freiäugig sichtbaren '''sieben Wandelgestirne''', die sich entlang der Ekliptiklinie stetig gegenüber dem Fixsternhimmel bewegen. Siehe hierzu auch &quot;[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Zusammenhang_mit_dem_Stier|Zu den Etyma und den Kognaten von &quot;Sieben&quot;, &quot;Stier&quot;, &quot;Gestirn&quot; und &quot;Stern&quot;]]&quot;.
** Die ausgeteilten '''Brote''' und '''Fische''' durchmaßen die gesamte versammelte Menschenmenge, die durch den vollständigen [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|Lebewesenkreis (Zodiak)]] mit den '''zwölf Lebewesenkreiszeichen''' beziehungsweise durch die '''zwölf Körbe''' symbolisiert wird. Der Planet Jupiter, der den Zodiak in zwölf Jahren einmal durchläuft, wurde in Babylonien mit dem babylonischen Hauptgott Marduk gleichgesetzt.
* Insgesamt gibt es am Fixsternhimmel gut 2800&amp;nbsp;Sterne bis zur scheinbaren Helligkeit 5,5&lt;sup&gt;m&lt;/sup&gt; und knapp 8800&amp;nbsp;Sterne bis zur scheinbaren Helligkeit&amp;nbsp;6,5&lt;sup&gt;m&lt;/sup&gt;, die ohne Lichtverschmutzung mit bloßem Auge als einzelne Lichtpunkte gesehen werden können. Diese verteilen sich allerdings in der gesamten Himmelssphäre, so dass von einem Punkt auf der Erdoberfläche aus zu jedem Zeitpunkt immer nur ungefähr die Hälfte davon über dem Horizont steht. An den beiden Polen sind stets nur die Sterne der jeweiligen nördlichen oder südlichen Hemisphäre zu sehen, und am Äquator können im Laufe eines Jahres alle Sterne gesehen werden. Je nach Breitengrad und Zeitpunkt können bei Neumond (kein Streulicht) innerhalb einer wolkenlosen Nacht viertausend bis zu fast siebentausend Sterne beobachtet werden.&lt;ref&gt;Bob King: [https://skyandtelescope.org/astronomy-blogs/how-many-stars-night-sky-09172014/ 9,096 Stars in the Sky—Is that all? How many stars in the sky can you see?], skyandtelescope.org - The essential Guide to Astronomy, 17. September 2014&lt;/ref&gt; Diese Spanne entspricht der Angabe der bei der Brotvermehrung versammelten Menschen, deren Anzahl in den Evangelien mit '''viertausend''' beziehungsweise '''fünftausend''' angegeben ist.
** Im ersten Buch des Alten Testaments ('''Genesis''') wird Abram aus Ur in Mesopotamien bereits das Folgende prophezeit:
&lt;blockquote&gt;
15,5 ''Sieh doch zum Himmel hinauf und zähl die Sterne, wenn du sie zählen kannst! Und er sprach zu ihm: So zahlreich werden deine Nachkommen sein''&lt;br/&gt;
...&lt;br/&gt;
17,5 ''Man wird dich nicht mehr Abram nennen. Abraham, Vater der Menge, wird dein Name sein; denn zum Stammvater einer Menge von Völkern habe ich dich bestimmt.''
&lt;/blockquote&gt;
* Die Gruppen von (ungefähr) '''fünfzig''' oder '''hundert Männern''' entsprechen den Sternbildern, die über den gesamten Himmel verteilt sind. Nach der Festlegung der Internationalen Astronomischen Union (IAU) von 1930 gibt es heute 88&amp;nbsp;Sternbilder, die den Himmel vollständig abdecken. Mit den maximal fast 8800&amp;nbsp;freiäugig sichtbaren Sternen entspricht dies im Mittel also 100&amp;nbsp;Sternen pro Sternbild. Bei 4400&amp;nbsp;freiäugig sichtbaren Sternen wären es 50&amp;nbsp;Sterne pro Sternbild. Dies entspricht genau der Spanne der Gruppenstärke, die im Neuen Testament angegeben sind.
* Das '''Brot''' und der '''Wein''' werden nach der christlichen Lehre bei der Transsubstantiation in den Leib und das Blut des vom '''Himmel''' herabgekommenen &quot;Brot des Lebens&quot; (vergleiche die Rede über das Himmelsbrot von Jesus in der Synagoge von Kafarnaum in Evangelium nach Johannes 6,48–58) gewandelt, das die kosmische Ewigkeit verheißt.

Die Zahlen '''Zwei''', '''Fünf''', '''Sieben''' und '''Zwölf''' stehen in einem einfachen arithmetischen Zusammenhang, bei dem die beiden jeweils vorhergehenden Zahlen der Folge addiert werden:

{| class=&quot;wikitable&quot;
|+
|'''Zahl'''
|'''Summe'''
|'''Anmerkung'''
|-
|'''2'''
|
|Anzahl der freiäugig als '''flächenhaft wahrnehmbaren Wandelgestirne''' ('''Sonne''' und '''Mond'''), siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwei|Zur Zwei]]
|-
|'''5'''
|
|Anzahl der freiäugig als '''punktförmig wahrnehmbaren Wandelgestirne''' '''Merkur''', '''Venus''', '''Mars''', '''Jupiter''', '''Saturn'''
|-
|'''7'''
|= 2 + 5
|Anzahl der freiäugig wahrnehmbaren '''Wandelgestirne''' sowie der '''Tage in der Woche''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Sieben|Zur Sieben]]
|-
|'''12'''
|= 5 + 7
|Anzahl der '''Monate im Jahr''', der '''Lebewesenkreiszeichen des Zodiaks''' sowie der '''Erdenjahre pro Jupiterjahr''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwölf|Zur Zwölf]], vergleiche hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|Der Zodiak]]
|-
|'''19'''
|= 7 + 12
|Anzahl der '''Jahre''' mit '''zwölf Monaten''' und '''sieben Schaltmonaten''' einer '''Meton-Periode''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Neunzehn|Zur Neunzehn]], vergleiche hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|Die Plejaden-Schaltregeln]] und [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Mondzyklen#Der_Meton-Zyklus|Der Meton-Zyklus]]
|}

=== Weitere Bezüge ===
Weitere Bezüge von der Astronomie zur Theologie ergeben sich bei den folgenden Sachverhalten:

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Biblische_Erwähnungen|'''biblische Erwähnungen von Konstellationen''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Der_Stern_von_Bethlehem|'''Der Stern von Bethlehem''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Ochs_und_Esel|'''Ochs und Esel / Krippe / „Ich bin das Alpha und das Omega“''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Biblische_Bezüge|'''Biblische Bezüge zu den Mondhäusern / Mondstationen''']].

== Zur Kosmologie ==
[[Datei:Kosmologisches.Modell.Schwarze.Schale.Rotverschiebung.png|mini|rechts|hochkant=2.5|Ein kosmologisches Modell unseres im Zentrum isotropen und inhomogenen Universums, das von einer undurchsichtigen und massereichen schwarzen Kugelschale umgeben ist. Von der äußeren Region aus betrachtet, ist unser Universum ein gigantisches Schwarzes Loch. Zwischen dem inneren und dem äußeren Bereich der schwarzen Kugelschale ist kein Informationsaustausch möglich. Jegliche Materie, die von innen oder außen in die schwarze Kugelschale gelangt, ist von innen und von außen nicht mehr sichtbar. Sowohl die innere als auch die äußere Grenze der schwarzen Kugelschale stellen demzufolge einen Ereignishorizont dar.]]

Die '''Kosmologie''' beschäftigt sich mit der Struktur, dem Ursprung und der Entwicklung des Universums. Dadurch ergeben sich zahlreiche Bezüge zur beobachtenden '''Astronomie''' und zur '''Astrophysik''', aber auch zur '''Quantenphysik'''.

In der Antike gingen die Menschen noch davon aus, dass sich die Erde im Mittelpunkt der Welt und somit auch in der Mitte des sichtbaren Universums befindet. Dieses geozentrische Weltbild wurde seit dem 16.&amp;nbsp;Jahrhundert, ausgelöst durch die kopernikanische Wende, zunehmend verworfen und durch ein heliozentrisches Weltbild ersetzt. Durch die Erfindung und Verwendung von Fernrohren konnten seit dem Beginn des 17.&amp;nbsp;Jahrhunderts immer mehr Details im Sternenhimmel entdeckt werden. Durch astronomische Beobachtungen ergaben sich immer mehr Indizien für die Tatsache, dass die Erde einmal pro Jahr auf einer Ellipsenbahn die Sonne umrundet und nicht die Sonne die Erde umkreist. Der Philosoph Immanuel Kant (1724–1804) erkannte bereits 1755 in seiner Allgemeinen Naturgeschichte und Theorie des Himmels das innere Wesen unserer Milchstraße. Mit der ersten zuverlässigen Messung der Parallaxe von unserer Erde zum benachbarten Fixstern 61&amp;nbsp;Cygni (&quot;Bessel's Stern&quot;) durch Friedrich Wilhelm Bessel (1784–1846) in Königsberg und der daraus folgenden Berechnung von dessen Entfernung von gut zehn Lichtjahren im Jahr 1838 war die Tatsache, dass die Erde um die Sonne läuft, endgültig bewiesen.

Die Auswertung der astronomischen Beobachtungen hat zu der heute allgemein geteilten Auffassung geführt, dass unser Universum bei einem Urknall entstanden ist und seitdem expandiert. Die Berücksichtigung des Äquivalenzprinzips zwischen schwerer und träger Masse, das zu der von '''Albert Einstein''' (1879–1955) formulierten Allgemeinen Relativitätstheorie führt, brachte '''Alexander Friedmann''' (1888–1925) 1922 zu der theoretischen Vorhersage eines dynamischen Universums. Fünf Jahre später schlussfolgerte der belgische Astronom '''Georges Lemaître''' (1894–1966) aus den von '''Vesto Slipher''' (1875–1969) beobachteten Rotverschiebungen von fernen Galaxien und den von '''Edwin Hubble''' (1889–1953) ermittelten Entfernungen dieser Galaxien, dass das Universum expandiert. Aufgrund dieser Erkenntnis ergibt sich, dass das Universum einen Ursprung mit sehr kleinem Radius gehabt haben muss. Diesen Zustand nannte er &quot;primordiales Atom&quot; beziehungsweise &quot;Uratom&quot;. In der Folgezeit etablierte sich für diesen initialen Vorgang der Begriff &quot;'''Urknall'''&quot; (im Englischen: &quot;'''Big Bang'''&quot;).&lt;ref&gt;Markus Bautsch: ''[https://en.wikibooks.org/wiki/Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell/Brief_historical_review Moving objects in retarded gravitational potentials of an expanding spherical shell / Brief historical review], Wikibook (englisch), 2024, abgerufen am 28. Februar 2026&lt;/ref&gt;

Viele Astrophysiker versuchen heute mit dem sogenannten '''Standardmodell der Kosmologie''' (auch '''ΛCDM-Modell''' beziehungsweise Lambda-CDM-Modell, wobei &quot;CDM&quot; für &quot;cold dark matter&quot; steht, also für &quot;kalte, dunkle Materie&quot;) die Entwicklung des Universums nachzubilden. Hierfür wenden sie das kosmologische Prinzip an, das von zwei grundlegenden Annahmen ausgeht:&lt;ref&gt;Markus Bautsch: ''[https://en.wikibooks.org/wiki/Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell/Preface Moving objects in retarded gravitational potentials of an expanding spherical shell / Preface], Wikibook (englisch), 2024, abgerufen am 28. Februar 2026&lt;/ref&gt;

# Das Weltall sei '''homogen''', was bedeutet, dass es in groben Zügen von jedem Punkt aus gleich aussieht.
# Das Weltall sei '''isotrop''', was besagt, dass es in groben Zügen in jede Richtung gleich aussieht.

Mit diesen Annahmen kann das Modell berechnet werden, und mit diversen zusätzlichen Annahmen stimmt es in vielerlei Hinsicht mit den astronomischen Beobachtungen überein. Zu den zusätzlichen Annahmen gehören die folgenden beiden hypothetischen Größen:

* '''Kalte, dunkle Materie''', die zwar der Gravitation unterläge, aber keine Wechselwirkung mit elektromagnetischer Strahlung zeigt.
* Eine '''kosmologische Konstante''' Λ, die eine '''dunkle Energie''' beschreibt und für die beschleunigte Expansion des Universums verantwortlich sei.

Weder für die Homogenität noch für die Isotropie des Kosmos konnten bislang Belege gefunden werden, und auch für die kalte dunkle Materie und die dunkle Energie konnte bislang keine physikalische Interpretation geliefert werden.

Ferner ist auch die Annahme, dass die Naturkonstanten unveränderliche Werte haben, nicht begründbar. Auf kosmischen Zeitskalen kann es durchaus Änderungen geben, die wir derzeit nicht messen können. Die gilt insbesondere für die Hubble-Konstante, die die Expansionsrate des Universums beschreibt, für die Gravitationskonstante, die die Anziehung zweier Massen beschreibt, oder für die kosmologische Konstante, die die beschleunigte Expansion des Universums beschreibt. In diesem Kontext sei darauf hingewiesen, dass unser Universum genauso groß ist wie ein Schwarzes Loch mit der Masse unseres Universums. Deshalb gehen einige Kosmologen davon aus, dass wir innerhalb eines Schwarzen Loches der Größe und Masse unseres Universums leben könnten.

Siehe hierzu auch: [[:en:Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell|'''Moving objects in retarded gravitational potentials of an expanding spherical shell''']].

Darüber hinaus mehren sich Anzeichen und Hinweise, die gegen die Ergebnisse des Standardmodells der Kosmologie sprechen, beziehungsweise durch weitere Hypothesen, die physikalisch nicht begründet werden können, im Standardmodell berücksichtigt werden müssen. Die folgende unvollständige Liste soll hierzu einige Anhaltspunkte liefern:

* Präzise astronomische Beobachtungen zeigen, dass das Weltall auch auf großen Längenskalen '''nicht homogen''' ist, sondern Strukturen zeigt.
* Präzise astronomische Beobachtungen zeigen, dass das Weltall auch auf großen Längenskalen '''nicht isotrop''' ist (Asymmetrie der kosmischen Hintergrundstrahlung).
* Die Hubble-Konstante hat heute einen anderen Wert als früher (&quot;'''Hubble tension'''&quot;), was mit dem Standardmodell nicht im Einklang steht.
* Das beobachtete Vorkommen des dritten Elements im Periodensystem, also des Alkalimetalls '''Lithium''', ist mindestens dreimal geringer als vom Standardmodell vorhergesagt.
* Die '''Rotverschiebung von fernen Galaxien''' ist deutlich größer als es nach dem Standardmodell möglich wäre.
* Die beobachteten '''Rotationskurven von Spiralgalaxien''' stehen im Widerspruch zu den Ergebnissen des Standardmodells.
* Das Standardmodell ist nicht in der Lage, die Abwesenheit von '''Antimaterie''' im sichtbaren Teil des Universums zu erklären.
* Die im frühen Universum beobachteten '''primordialen Schwarzen Löcher und Galaxien''' mit explodierende '''Supernovae''' sowie dem Vorkommen von '''Sauerstoff''' stehen im Widerspruch zu den Ergebnissen des Standardmodells.

== Zur Astrologie ==
Eine Sonderstellung nimmt die '''{{w|Astrologie}}''' (zusammengesetzt mit dem altgriechischen ἄστρον (&quot;astron&quot;), zu Deutsch „Sternenlehre“) ein. Sie ist ein weiteres Beispiel für eine Disziplin, bei der grundlegende Kenntnisse über die Astronomie eine Voraussetzung sind. Sie versucht, Zusammenhänge zwischen den Konstellationen der Wandelgestirne oder astronomischen Ereignissen am Sternenhimmel mit irdischen Geschehnissen oder Veränderungen herzustellen, insbesondere was bestimmte Konjunktionen und daraus abgeleitete Prophezeiungen betrifft. Sie wurde bereits in Mesopotamien und in anderen alten Kulturkreisen von Astronomen ausgeübt. Noch der Astronom '''{{w|Johannes Kepler}}''' (1571–1630) hat als einer der letzten Astronomen einen wesentlichen Teil seiner Einkünfte durch die Erstellung von Horoskopen bestritten. Aber schon Aristoteles hatte festgestellt und beschrieben, dass die bei bestimmten Konstellationen am Himmel vorhergesagten Ereignisse nicht eingetreten waren.

Vor der Aufklärung haben astrologische Prophezeiungen noch eine große und weitreichende gesellschaftliche Bedeutung gehabt. Als Beispiel seien die Behauptungen des ersten im Kurfürstentum Brandenburg tätigen Astrologen '''{{w|Johannes Carion}}''' (1499–1537) genannt, der für 1524 eine Sintflut vorhersagte, die nicht eingetroffen ist.&lt;ref&gt;{{Literatur |Autor=Markus Bautsch, Friedhelm Pedde |Titel=Vor 500 Jahren: Die Sintflut von 1524 die nicht stattfand |Online=https://wfs.berlin/wp-content/uploads/2024/05/A19-BROplanetA4_40s-feb2024ff_www-rz.pdf |Sammelwerk=Dem Himmel nahe. |WerkErg=Mitteilungen der Wilhelm-Foerster-Sternwarte e.V.|Nummer=19 |Hrsg=Wilhelm-Foerster-Sternwarte e.V. / Zeiss-Planetarium am Insulaner |Ort=Berlin |Datum=2024-02 |Seiten=16–19 |Sprache=de |Abruf=2025-08-03|ISSN=2940-9330}}&lt;/ref&gt; Der Wiener Hofastronom '''{{w|Georg Tannstetter}}''' (1482–1535) sah sich 1523 bemüßigt, die schon lange im Voraus erhitzten und besorgten Gemüter zu beruhigen:&lt;ref&gt;Georg Tannstetter: ''Libellus consolatorius contra opiniones de diluvio et aliis horrendis periculis anni 1523''&lt;/ref&gt;

&lt;blockquote&gt;
Nun hat sich überall, in allen Köpfen, in allen Seelen das Gerücht eingeschlichen:&lt;br/&gt;
die Gelehrten und Weisen sind in ständigem Streitgespräch, andere hingegen sind derart verstört, dass sie ihren Geschäften nicht mehr nachgehen können; sie verkaufen ihre Anwesen, ihre Felder und Besitztümer oder lassen davon ab, Güter zu kaufen, in der Hoffnung, ihr Geld leichter in die sicheren Berge transportieren zu können. Andere wiederum verschieben ihr Heiratsversprechen, kündigen ohne scheinbaren Grund Verträge auf, entziehen sich ihren christlichen Gelübden, arbeiten faul und missmutig auf dem Land und fragen sich, was es denn nütze, Geld und Gut anzuhäufen, wenn doch in kürzester Zeit niemand mehr davon Nutzen ziehen könne.
&lt;/blockquote&gt;

'''→ Siehe auch:'''

* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Definition|'''Konjunktionen''', Abschnitt '''Definition''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Historische_Konjunktionen|'''Historische Konjunktionen''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|'''Beobachtungen in der Nähe der Ekliptik''']].
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

== Einzelnachweise ==
&lt;references&gt;&lt;/references&gt;</text>
      <sha1>6k4pu9x4rtl2l6btwot7sflwwb30h34</sha1>
    </revision>
    <revision>
      <id>1088606</id>
      <parentid>1088605</parentid>
      <timestamp>2026-07-04T11:13:48Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <comment>/* Himmelspforte */ Psalm&amp;nbsp;65</comment>
      <origin>1088606</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="89383" sha1="2g746kk3u2vc8578nij7uh5v2k07gxo" xml:space="preserve">Viele Bezeichnungen für verschiedene Lehren werden mit der aus dem Altgriechischen stammenden Endung &quot;-logie&quot; (altgriechisch λόγος (&quot;logos&quot;), zu Deutsch „Lehre“) gebildet. Die folgenden Disziplinen sind in diesem Kontext hervorzuheben, da sie insbesondere für die '''{{w|Archäoastronomie}}''' wertvolle wissenschaftliche Ergänzungen zur '''{{w|Astronomie}}''' (aus den altgriechischen Wörtern ἄστρον (&quot;ástron&quot;, zu Deutsch „Stern“) und νόμος (&quot;nómos, zu Deutsch „Gesetz“) zusammengesetzt also „Sterngesetz“) liefern:

* Die '''{{w|Archäologie}}''' (zusammengesetzt mit dem altgriechischen Wort ἀρχαῖος (&quot;archaios&quot;), zu Deutsch „Altertumslehre“) beschäftigt sich mit der kulturellen Entwicklung der Menschheit.
* Die '''{{w|Etymologie}}''' (zusammengesetzt mit dem altgriechischen Wort ἔτυμος (&quot;etymos&quot;), zu Deutsch „Wortherkunftslehre“) untersucht die geschichtliche Herkunft von Wörtern.
* Die '''{{w|Mythologie}}''' (zusammengesetzt mit dem altgriechischen Wort μῦθος (&quot;mythos&quot;), zu Deutsch „Erzählungslehre“), die sich wissenschaftlich mit der Sagenwelt beschäftigt.
* Die '''{{w|Theologie}}''' (zusammengesetzt mit dem altgriechischen Wort θεός (&quot;theós&quot;), zu Deutsch „Gotteslehre“) mit ihren Lehren zum religiösen Glauben und dessen Glaubensdokumenten.
* Die '''{{w|Kosmologie}}''' (zusammengesetzt mit dem altgriechischen Wort κόσμος (&quot;kósmos&quot;), zu Deutsch „Weltenlehre“) ist hingegen eine Lehre, die sich im Laufe der Jahrtausende deutlich verändert hat und sich auch heute noch erheblich weiterentwickelt, da es in der modernen Astronomie und Astrophysik mit zunehmend hohem technischem Aufwand immer wieder zu neuen Erkenntnissen kommt.
* Die '''{{w|Numerologie}}''' (zusammengesetzt mit dem lateinischen Wort numerus, zu Deutsch „Zahlenlehre“) mit ihren mystischen Lehren über die symbolische Zuweisung von Bedeutungen an Zahlen.

Von der Antike bis ins Mittelalter galt die Beherrschung der '''{{w|sieben freien Künste}}''' als Voraussetzung für das Betreiben von Philosophie. Zu den drei &quot;trivialen&quot; Künsten der {{w|Grammatik}}, der {{w|Rhetorik}} und der {{w|Dialektik}} des '''{{w|Trivium|Triviums}}''' wurden die vier Künste der {{w|Musiktheorie}}, der {{w|Arithmetik}}, der {{w|Geometrie}} und der {{w|Astronomie}} zu den Künsten des '''{{w|Quadrivium|Quadriviums}}''' gezählt → siehe hierzu auch [[Quadriviale_Kuriositäten|'''Wikibook ''Quadriviale Kuriositäten''''']].

== Zur Etymologie ==
Die Genesis aus dem Alten Testament greift die Thematik der Verwirrung der einheitlichen Sprache in ihrem elften Kapitel auf, und beschreibt, wie die bereits sternenkundigen Menschen im Norden Mesopotamiens übermütig geworden waren und in Babel einen Turm mit einer Spitze '''bis in den Himmel''' errichten wollten:&lt;ref&gt;[https://www.bibleserver.com/EU/1.Mose11 Genesis 11], Genesis, Kapitel 11, Einheitsübersetzung&lt;/ref&gt;

&lt;blockquote&gt;
1 Die ganze Erde hatte eine Sprache und ein und dieselben Worte.&lt;br/&gt;
2 Als sie ostwärts aufbrachen, fanden sie eine Ebene im Land Schinar und siedelten sich dort an.&lt;br/&gt;
3 Sie sagten zueinander: Auf, formen wir Lehmziegel und brennen wir sie zu Backsteinen. So dienten ihnen gebrannte Ziegel als Steine und Erdpech als Mörtel.&lt;br/&gt;
4 Dann sagten sie: Auf, bauen wir uns eine Stadt und einen Turm mit einer Spitze '''bis in den Himmel'''! So wollen wir uns einen Namen machen, damit wir uns nicht über die ganze Erde zerstreuen.&lt;br/&gt;
5 Da stieg der HERR herab, um sich Stadt und Turm anzusehen, die die Menschenkinder bauten.&lt;br/&gt;
6 Und der HERR sprach: Siehe, ein Volk sind sie und eine Sprache haben sie alle. Und das ist erst der Anfang ihres Tuns. Jetzt wird ihnen nichts mehr unerreichbar sein, wenn sie es sich zu tun vornehmen.&lt;br/&gt;
7 Auf, steigen wir hinab und verwirren wir dort ihre Sprache, sodass keiner mehr die Sprache des anderen versteht.&lt;br/&gt;
8 Der HERR zerstreute sie von dort aus über die ganze Erde und sie hörten auf, an der Stadt zu bauen.&lt;br/&gt;
9 Darum gab man der Stadt den Namen Babel, Wirrsal, denn dort hat der HERR die Sprache der ganzen Erde verwirrt und von dort aus hat er die Menschen über die ganze Erde zerstreut.
&lt;/blockquote&gt;

Es mag weniger verwunderlich sein, dass Schöpfungsmythen oder Berichte über Katastrophen nicht nur einen astronomischen Hintergrund haben, sondern in völlig verschiedenen Kulturen sehr ähnliche Merkmale zeigen, wenn man sich das Folgende bewusst macht: Einige Indizien deuten auf einen für viele Kulturen gemeinsamen Ursprung hin, der auf eine tiefsinnige Betrachtung und Beobachtung des Himmelsgeschehens hindeutet.

Bei bestimmten Wörtern sind die Ähnlichkeiten in vielen lebenden und toten Sprachen so auffällig, dass sie ein gemeinsames Ursprungswort (Etymon) haben und somit Kognaten sein dürften. 

=== &quot;Stern&quot; ===
Bei den Wörtern „Gestirn“ beziehungsweise „Stern“ sind die Ähnlichkeiten in vielen lebenden und toten Sprachen sehr auffällig, und diese Verwandtschaften mögen durch die Wörter für &quot;Stern&quot; in den folgenden Sprachen belegt werden:

* Akkadisch &quot;istar&quot;
* Indogermanisch &quot;ster&quot;
* Griechisch &quot;astro&quot; / &quot;asteri&quot;
* Lateinisch &quot;astrum&quot; / &quot;stella&quot;
* Althochdeutsch &quot;stern(o)&quot;
* Jiddisch &quot;shtern&quot;
* Katalanisch und Spanisch &quot;estrella&quot;
* Portugiesisch &quot;estrela&quot;
* Englisch &quot;star&quot;
* Niederländisch &quot;ster&quot;
* Westfriesisch &quot;stjer&quot;
* Italienisch und Korsisch &quot;stella&quot;
* Rumänisch &quot;stea&quot;
* Sardisch &quot;istedda&quot;
* Maltesisch &quot;stilla&quot;
* Französisch &quot;étoile&quot; aus Altfranzösisch &quot;estoile&quot;
* Galicisch &quot;estrela&quot;
* Walisisch &quot;seren&quot;
* Dänisch und Norwegisch &quot;stjerne&quot;
* Schwedisch &quot;stjärna&quot;
* Isländisch &quot;stjarna&quot;
* Kurdisch &quot;stêrk&quot;
* Gujarati &quot;Tārō&quot;
* Hindi &quot;तारा&quot; (taara)
* Marathi &quot;तारा&quot; (Tārā)
* Nepalesisch &quot;तारा&quot; (Tārā)
* Punjabi &quot;ਤਾਰਾ&quot; (Tārā)
* Singhalesisch &quot;තරුව&quot; (taruva)
* Khmer &quot;តារា&quot; (tara)
* Armenisch &quot;աստղ&quot; (astgh)
* Tadschikisch &quot;ситора&quot; (sitora)
* Hausa &quot;tauraro&quot;
* Krio &quot;sta&quot;

=== &quot;Stier&quot; ===
Eine starke Ähnlichkeit gibt es in vielen Sprachen auch zwischen den Wörtern „Stern“ und „Stier“. Der Stier bezeichnet zudem auch ein bedeutendes und eines der ältesten Sternbilder überhaupt:

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|'''Himmelsstier''']].

* Akkadisch und Assyrisch &quot;šūru&quot;
* Aramäisch &quot;tōra&quot;
* Hebräisch &quot;šǒr&quot;
* Ugaritisch &quot;twr&quot;
* Arabisch &quot;ثور&quot; (&quot;thawr&quot;)
* Griechisch &quot;ταύρος&quot; (&quot;tauros&quot;)
* Lateinisch &quot;taurus&quot;
* Althochdeutsch &quot;stior&quot;
* Italienisch, Katalanisch und Spanisch &quot;toro&quot;
* Galicisch &quot;touro&quot;
* Gallisch &quot;tarvos&quot;
* Französisch &quot;taureau&quot;
* Schwedisch &quot;tjur&quot;
* Dänisch &quot;tyr&quot;
* Irisch und Gälisch &quot;tarbh&quot;
* Wallisisch &quot;tarw&quot;

=== &quot;Horn&quot; ===
Auch die Hörner des Stieres betreffend setzen sich die vielen Ähnlichkeiten fort:

* Akkadisch &quot;carnu&quot;
* Aramäisch &quot;qeren&quot;
* Griechisch &quot;κόρνο&quot; (&quot;korno&quot;)
* Lateinisch &quot;cornu&quot;
* Maltesisch &quot;qrun&quot;*
* Arabisch &quot;قرون&quot; (&quot;qurun&quot;)
* Französisch &quot;corne&quot;
* Italienisch &quot;corne&quot;
* Rumänisch &quot;corn&quot;
* Haitianisch &quot;kòn&quot;

=== &quot;Sieben&quot; ===
Die in vielen Kulturen als heilig angesehene Zahl Sieben taucht im Zusammenhang mit der Astronomie als Anzahl der mit bloßem Auge sichtbaren Wandelgestirne und als Zahl der Hauptsterne in vielen Asterismen auf:

* Sieben Wandelgestirne: Sonne Mond, Merkur, Venus, Mars, Jupiter, Saturn
* Siebengestirn im Himmelsstier: Alkione, Atlas, Electra, Maia, Merope, Taygeta, Pleione
* Sternbild Orion: Beteigeuze, Rigel, Bellatrix, Alnilam, Alnitak, Saiph, Mintaka
* Asterismus Großer Wagen: Alioth, Dubhe, Alkaid, Mizar, Merak, Phekda, Megrez

→ Siehe auch:

* [[Quadriviale_Kuriositäten/_Zahlen#Zur_Sieben|'''Zur Sieben''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Der_Fixsternhimmel#Die_sieben_hellsten_Objekte_der_Ekliptik|'''Die sieben hellsten Objekte der Ekliptik''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Kalenderführung#Die_Siebentagewoche|'''Die Siebentagewoche''']].

Wegen der hohen kulturellen, rituellen oder mythischen Bedeutung gibt es in vielen Kulturen und Sprachen etymologische Übereinstimmungen:

* Akkadisch &quot;sebe&quot;
* Proto-Indoeuropäisch &quot;septḿ̥&quot;
* Hetitisch &quot;sipta&quot;
* Proto-Germanisch &quot;*sebun&quot;
* Althochdeutsch &quot;sibun&quot;
* Hebräisch &quot;sajin&quot; (Buchstabe) oder &quot;scheva&quot; (Wort)
* Etruskisch &quot;semph&quot;
* Maltesisch &quot;sebgħa&quot;
* Arabisch &quot;sabʿa&quot;
* Griechisch &quot;επτά&quot; (&quot;(h)epta&quot;)
* Lateinisch &quot;septem&quot;
* Ungarisch &quot;het&quot;
* Proto-Balto-slawisch &quot;septin&quot;
* Proto-Indo-Iranisch &quot;saptá&quot;
* Katalanisch &quot;set&quot;
* Spanisch &quot;siete&quot;
* Galicisch &quot;sete&quot;
* Lettisch &quot;septiņi&quot;
* Italienisch &quot;sette&quot;
* Französisch &quot;sept&quot;
* Englisch &quot;seven&quot;
* Wallisisch &quot;saith&quot;
* Bosnisch / Kroatisch &quot;sedam&quot;
* Rumänisch &quot;șapte&quot;
* Irisch &quot;seacht&quot;
* Swahili &quot;saba&quot;
* Haitianisch &quot;sèt&quot;

== Zur Mythologie ==
Seit Jahrtausenden blicken Menschen in den Nachthimmel und versuchen, die unzähligen Lichter am Firmament zu deuten. Schon früh begannen sie, die von ihnen erfundenen Sternbilder und die unablässig durch den Himmel ziehenden Wandelgestirne durch Geschichten über Götter, Helden oder andere Wesen zu interpretieren, zu erzählen und zum Teil über Jahrhunderte hinweg zu tradieren. Die '''Mythologie''' spielte dabei eine zentrale Rolle: Sie half nicht nur, eine symbolische Ordnung in den geheimnisvollen Kosmos zu bringen, sondern prägte auch viele der Bezeichnungen und Vorstellungen, die bis heute in der beschreibenden Astronomie überlebt haben.

Die Verbindung zwischen Mythologie und Astronomie ist tief verwurzelt und zeugt vom menschlichen Bedürfnis, das wahrgenommene, aber dennoch unfassbare Universum durch räumliche und zeitliche Vorstellungen sowie durch Erzählungen begreifbar zu machen. Das Geschehen am Himmel musste auf die Menschen vor der Erfindung der Bewegtbilder und des Films in der späten Neuzeit sowohl attraktiv als auch spektakulär gewirkt haben. So konnten verschiedene mythische Gestalten am Himmel durch ihre scheinbaren Handlungen wahrgenommen werden. Durch die Wiederholung solcher Deutungen konnten sich besonders beliebte Mythen im kulturellen Kontext über die Zeit verfestigen, und entsprechende Riten konnten sich etablieren.

Damit war auch eine wesentliche Voraussetzung für den Glauben der Menschen an eine höhere Macht oder mehrere höhere Mächte gegeben. Der Begriff '''Religion''' stammt vom lateinischen Inifiniv &quot;relegere&quot; ab. Dieses Verb bedeutet wörtlich übersetzt &quot;wieder lesen&quot; und meint im Sinne von &quot;überdenken&quot; das bewusste Wahrnehmen von Prophezeiungen oder Omen sowie das nachhaltige Beachten tradierter Vorschriften.

'''→ Siehe:'''

* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Der Urozean''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Sagenwelt|'''Die Plejaden / Sagenwelt''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Mythologie|'''Der Himmelsstier''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Babylonische_Himmelswege|'''Babylonische Himmelswege''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Mithraskult|'''Mithraskult und Tauroktonie''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Höhlenmalerei_in_der_Magura-Höhle|'''Die Höhlenmalerei in der Magura-Höhle''']].

== Zur Theologie ==
Die '''Theologie''' (vom Altgriechischen θεός = theós = Gott und λόγος = lógos = Lehre) ist die Lehre von einem Gott oder von mehreren Göttern. Sie lehrt einen ausgeprägten religiösen Glauben, begründet rituelle Traditionen und deutet die vorhandenen Glaubensdokumente.

[[Datei:Aristoteles.Theologie.png|mini|rechts|Wahrnehmbarkeit und Vergänglichkeit nach Aristoteles]]

Die Theologie des '''{{w|Aristoteles}}''' (384–322) postuliert drei mögliche Substanzen:&lt;ref&gt;Aristoteles: ''Metaphysik'', Kapitel XII (Λ), Philosophische Theologie, Seiten 1069a –1076a&lt;/ref&gt;

{| class=&quot;wikitable&quot;
|+ Mögliche Substanzen nach Aristoteles
! Nummer !! Substanz !! Erläuterung !! Interpretationsbeispiel
|-
| 1. || Die sinnlich wahrnehmbare und vergängliche Substanz || Konkrete Dinge, die nur eine begrenzte Teilhabe an der Ewigkeit haben. || Lebewesen
|-
| 2. || Die sinnlich wahrnehmbare und unvergängliche Substanz || Konkrete Dinge, die eine unbegrenzte Teilhabe an der Ewigkeit haben. || Die sieben Wandelgestirne und die Fixsterne
|-
| 3. || Die sinnlich nicht wahrnehmbare und unvergängliche Substanz || Lebendiger, unbewegter Beweger, der der Ursprung aller anderen Dinge ist. || Gott
|}

Dieses theologische Prinzip wurde später auch von '''{{w|Thomas van Aquin}}''' (1225-1274) in seinen ''Quinque viae ad Deum'' (&quot;Fünf Wege zu Gott&quot;) aufgegriffen:

{| class=&quot;wikitable&quot;
|+ Nach dem ''Quinque viae ad Deum'' (&quot;Fünf Wege zu Gott&quot;) von Thomas von Aquin
! Weg !! Bezeichnung !! Voraussetzung !! Feststellung !! Folgerung
|-
| Via&amp;nbsp;I || Bewegungsbeweis || In der Welt ist überall Bewegung. || Alles Bewegte muss von einem anderen in Bewegung gebracht worden sein. || Der Erstbeweger ist Gott.
|-
| Via&amp;nbsp;II || Kausalitätsbeweis || In der Welt gibt es überall Ursachen und Wirkungen. || Jede Wirkung muss eine Ursache haben. || Die erste Ursache der Welt ist Gott.
|-
| Via&amp;nbsp;III || Kontingenzbeweis || Alles Empirische in der Welt entsteht und vergeht wieder. || Jedes empirische Wesen muss das Sein von einem absoluten Wesen empfangen haben. || Das absolute Wesen ist Gott.
|-
| Via&amp;nbsp;IV || Stufenbeweis || In der Welt gibt es abgestuft gute, wahre und schöne Dinge. || Das absolute Wesen muss die höchste Güte, Wahrheit und Schönheit haben. || Das höchste Gute, Wahre und Schöne ist Gott.
|-
| Via&amp;nbsp;V || Finalitätsbeweis || In der Welt gibt es Ordnung und Gesetzmäßigkeit. || Ordnung und Gesetzmäßigkeit müssen auf einen denkenden Geist zurückgehen. || Dieser Geist kommt von Gott.
|}

Auch '''{{w|Gottfried Wilhelm Leibniz}}''' (1646-1717) lehnt sich in seiner Hypothese von „Gott als letztem und zureichendem Grund der Welt“ daran an.

Auch im 90. Psalm wird dieser Ansatz thematisiert:

&lt;blockquote&gt;
Das vierte Buch&lt;br/&gt;
Der '''ewige''' Gott – der '''vergängliche''' Mensch&lt;br/&gt;&lt;br/&gt;
1 Ein Bittgebet des Mose, des Mannes Gottes. O Herr, du warst uns Wohnung '''von Geschlecht zu Geschlecht'''.&lt;br/&gt;
2 '''Ehe geboren wurden die Berge, ehe du unter Wehen hervorbrachtest Erde und Erdkreis''', bist du '''Gott von Ewigkeit zu Ewigkeit'''.&lt;br/&gt;
3 '''Zum Staub zurückkehren lässt du den Menschen''', du sprichst: Ihr Menschenkinder, kehrt zurück!&lt;br/&gt;
4 Denn tausend Jahre sind in deinen Augen wie der Tag, der gestern vergangen ist, wie eine Wache in der Nacht.
&lt;/blockquote&gt;

Darüber hinaus gibt der vierte Vers einen deutlichen Hinweis auf das Verhältnis zwischen der Länge des viele Jahrtausende dauernden Präzessionszyklus und der Länge eines siderischen Monats: der Mond wandert entlang der Ekliptiklinie an einem Tag genauso weit wie der Frühlingspunkt in tausend Jahren.

→ Siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Präzession|'''Präzession''']].

Der griechische Dichter '''{{w|Aratos von Soloi}}''' in Kilikien (≈310–245) hatte seine astronomischen Kenntnisse vom Astronomen und Mathematiker '''{{w|Eudoxos von Knidos}}''' (geboren nach 390, gestorben nach 338) erhalten. In dem in der Antike verbreiteten Lehrgedicht Φαινόμενα (Phainomena = „Himmelserscheinungen“) von Aratos wird der Sternenhimmel in zahlreichen Hexametern beschrieben. Sein monumentales sechseckiges Grab aus der antiken Stadt Pompeiopolis wurde 2020 in der türkischen Provinz Mersin wiederentdeckt.&lt;ref&gt;Patricia Claus: [https://greekreporter.com/2021/07/11/memorial-tomb-of-ancient-greek-astronomer-aratus-unearthed-in-turkey/ Memorial Tomb of Ancient Greek Astronomer Aratus Unearthed in Turkey], The Greek Reporter, 11. Juli 2021&lt;/ref&gt;

Hier der Beginn des Prologs des Lehrgedichts:

&lt;blockquote&gt;
Εκ Διὸς ἀρχώμεσθα , τὸν οὐδέποτ᾽ ἄνδρες ἐῶμεν&lt;br/&gt;
῎Αῤῥητον . Μεσταὶ δὲ Διὸς πᾶσαι μὲν ἀγυιαὶ ,&lt;br/&gt;
Πᾶσαι δ᾽ ἀνθρώπων ἀγοραί · μεστὴ δὲ θάλασσα ,&lt;br/&gt;
Καὶ λιμένες. πάντη δὲ Διὸς κεχρήμεθα πάντες .&lt;br/&gt;
'''Τοῦ γὰρ καὶ γένος εἰμέν''' · ὁ δ᾽ ἤπιος ἀνθρώποισι&lt;br/&gt;
Δεξιὰ σημαίνει · λαοὺς δ᾽ ἐπὶ ἔργον ἐγείρει ,&lt;br/&gt;
Μιμνήσκων βιότοιο . λέγει δ᾽ , ὅτε βῶλος ἀρίστη&lt;br/&gt;
Βουσί τε καὶ μακέλῃσι · λέγει δ᾽ , ὅτε δεξιαὶ ὧραι ,&lt;br/&gt;
Καὶ φυτὰ γύρῶσαι , καὶ σπέρματα πάντα βαλέσθαι .&lt;br/&gt;
Αὐτὸς γὰρ τάγε σήματ᾽ ἐν '''οὐρανῷ''' ἐστήριξεν ,&lt;br/&gt;
'''Αστρα''' διακρίνας · ἐσκέψατο δ᾽ εἰς ἐνιαυτὸν&lt;br/&gt;
'''᾿Αστέρας''' , οἵ κε μάλιστα τετυγμένα σημαίνοιεν&lt;br/&gt;
᾿Ανδράσιν ὡράων , ὄφρ᾽ ἔμπεδα πάντα φύωνται .&lt;br/&gt;
Τῷ μιν ἀεὶ πρῶτόν τε καὶ ὕστατον ἱλάσκονται .&lt;br/&gt;
Χαῖρε , πάτερ , μέγα θαῦμα , μέγ᾽ ἀνθρώποισιν ὄνειαρ ,&lt;br/&gt;
Αὐτὸς καὶ προτέρη γενεή ! χαίροιτε δὲ , Μοῦσαι&lt;br/&gt;
Μειλίχιαι , μάλα πᾶσαι ! ἐμοί γε μὲν '''ἀστέρας''' εἰπεῖν ,&lt;br/&gt;
Ηἱ θέμις εὐχομένῳ , τεκμήρατε πᾶσαν ἀοιδήν .&lt;br/&gt;
Οἱ μὲν ὁμῶς πολέες τε , καὶ ἄλλυδις ἄλλοι ἐόντες ,&lt;br/&gt;
'''Οὐρανῷ''' ἕλκονται πάντ᾽ ἤματα συνεχὲς αἰεί.&lt;br/&gt;
Αὐτὰρ ὅγ᾽ οὐδ᾽ ὀλίγον μετανίσσεται · ἀλλὰ μάλ' αὕτως&lt;br/&gt;
'''῎Αξων''' οἱ ἐνάρηρεν · ἔχει δ᾽ ἀτάλαντον ἁπάντη&lt;br/&gt;
'''Μεσσηγὺς γαῖαν''' , περὶ δ᾽ '''οὐρανὸν''' αὐτὸν ἀγινεῖ.&lt;br/&gt;
Καί μιν πειραίνουσι δύω '''πόλοι''' ἀμφοτέρωθεν ·&lt;br/&gt;
᾿Αλλ᾽ ὁ μὲν οὐκ ἐπίοπτος · ὁ δ᾽ ἀντίος ἐκ '''Βορέαο''' ,&lt;br/&gt;
Ὑψόθεν Ὠκεανοῖο . Δύω δὲ μιν ἀμφὶς ἔχουσαι&lt;br/&gt;
'''Ἄρκτοι''' ἅμα τροχόωσι · τὸ δὴ καλέονται '''῞Αμαξαι''' .
&lt;/blockquote&gt;

Übersetzung unter Beibehaltung der Hexameter nach dem deutschen Dichter, Übersetzer und Hochschullehrer Johann Heinrich Voss (1751–1826) von 1824:&lt;ref&gt;АРАТОΥ ΦΑΙΝΟΜΕΝΑ ΚΑΙ ΔΙΟΣΗΜΕΙΑ. Des Aratos Sternerscheinungen und Wetterzeichen. Übersetzt und erklärt von Johann Heinrich Voss. Heidelberg bei Christian Friedrich Winter. 1824.&lt;/ref&gt;

&lt;blockquote&gt;
Zeus sei unser Beginn , und niemals bleib' er uns Männern&lt;br/&gt;
Ungelobt. Voll wahrlich des Zeus sind alle des Wandels&lt;br/&gt;
Weg' , und alle Versammlung der Welt ; voll jegliche Meerflut ,&lt;br/&gt;
Jeglicher Port ; ringsum ja des Zeus bedürfen wir alle .&lt;br/&gt;
'''Seines Geschlechts auch sind wir''' ; und Er , mildherzig den Menschen,&lt;br/&gt;
Zeichnet, was frommt, rechtsher ; und zu Tätigkeit weckt er die Völker,&lt;br/&gt;
Mahnend an Lebensbedarf : Er sagt , wann besser dem Pflugstier&lt;br/&gt;
Fuge die Scholl' , und dem Karst ; er sagt , wann schickliche Jahrszeit,&lt;br/&gt;
Dass man die Pflanze behäuf&quot; , und einsenk' allerlei Anwachs .&lt;br/&gt;
Denn selbst hat er die Zeichen am oberen '''Himmel''' befestigt ,&lt;br/&gt;
Und '''Sternbilder''' verteilt ; er hat fürsehend dem Jahrlauf&lt;br/&gt;
'''Sterne''' bestimmt , die den Menschen zumeist annahende Wechsel&lt;br/&gt;
Deuteten jeglicher Zeit , dass in Völligkeit alles erwachse .&lt;br/&gt;
Drum ihn immer zuerst , und zulezt ihn , sühnen sie feiernd.&lt;br/&gt;
Heil , anstaunlicher Vater , den Sterblichen mächtiges Labsal ,&lt;br/&gt;
Du auch , selbst des Geschlechts Ursprung ! Heil , freundliche Musen,&lt;br/&gt;
Heil euch allen gesamt ! doch mir , der , die '''Sterne''' zu melden ,&lt;br/&gt;
Euch , wie geziemt , anfleht , bringt allen Gesang zur Vollendung.&lt;br/&gt;
Jene zugleich , so viele zerstreuete , andere anders ,&lt;br/&gt;
Ziehn mit dem '''Himmel''' einher in ewigem Zuge beständig .&lt;br/&gt;
Doch nie schwanket er selbst um ein weniges; sondern durchaus so&lt;br/&gt;
Bleibt ihm die '''Axe''' geheftet ; die hält gleichschwebend vom Umfang&lt;br/&gt;
Hier '''in der Mitte die Erd'''' , und umher dort dreht sie den '''Himmel''' .&lt;br/&gt;
Sie dann hat zween '''Pol'''' an jeglichem Ende gerichtet :&lt;br/&gt;
Unsichtbar ist jener; doch hier um den '''Boreas''' ragt er&lt;br/&gt;
Ob dem Okeanos hoch. Zwo dem zu den Seiten gestellte&lt;br/&gt;
'''Bärinnen''' rollen umher: drum auch '''Rollwagen''' benamet.
&lt;/blockquote&gt;

'''''Hinweise:'''''
* Die &quot;Axe&quot; beschreibt die Erdachse.
* ''Mit dem &quot;Boreas&quot; ist der Himmelsnordpol gemeint.''
* ''Bei den beiden Bärinnen handelt es sich um die Sternbilder des Großen Bären (Ursa Maior) und des Kleinen Bären (Ursa Minor).''
* ''Die beiden Rollwagen sind bei uns heute die Asterismen Großer Wagen und Kleiner Wagen.''

Der Apostel '''{{w|Paulus von Tarsus}}''' (geboren vor 10, gestorben nach 60) war der bedeutendste Missionar des Urchristentums und kannte diesen Text offensichtlich. Im 17.&amp;nbsp;Kapitel der Apostelgeschichte des Lukas wird ihm ein Zitat aus dem Prolog des Lehrgedichts über die Abstammung der Menschen von Gott in den Mund gelegt.&lt;ref&gt;[https://www.die-bibel.de/bibel/NA28,EUE/ACT.17.28 Apostelgeschichte 17,28], Abschnitt: ''Paulus in Athen'', Novum Testamentum Graece und Einheitsübersetzung&lt;/ref&gt;

&lt;blockquote&gt;
Apostelgeschichte 17,28: '''Τοῦ γὰρ καὶ γένος ἐσμέν.'''
&lt;/blockquote&gt;

&lt;blockquote&gt;
Apostelgeschichte 17,28: '''Wir sind von seinem Geschlecht.'''
&lt;/blockquote&gt;

=== Zahlen in Religionen ===
Die '''Zwei''' steht oft für Gegensätze, wie zum Beispiel Tag und Nacht, Aufgang und Untergang, Sommerhalbjahr und Winterhalbjahr, zunehmender und abnehmender Mond oder obere und untere Kulmination. Eine solche Zweiteilung findet sich oft auch in gegensätzliche Kategorien wieder, die in vielen Disziplinen, insbesondere auch in der Ethik und in Religionen verwendet werden, wie beispielsweise gut und böse, oben und unten, Leben und Tod, Licht und Schatten, Wärme und Kälte oder Himmel und Hölle.

Interessant ist auch die frühgeschichtliche astronomische Auffassung von '''zwei''' mächtigen Gegenspielern, die sich im Sternenhimmel an zwei gegenüberliegenden Seiten befinden, der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|der Himmelsstier]] und der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsskorpion|der Himmelsskorpion]].

→ Siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwei|'''Zur Zwei''']].

Die astronomischen Zahlen '''Sieben''' und '''Zwölf''' werden als heilige Zahlen angesehen. Sie werden in vielfältigen Kontexten in religiösen Texten erwähnt und für viele religiöse Symbole verwendet. Ferner spielt auch die astronomische Zahl '''Vier''' in Religionen eine bedeutende Rolle, wo sie deswegen manchmal ebenfalls als heilige Zahlen angesehen wird:

* '''Vier''' Hauptsterne respektive Hauptsternbilder mit den '''vier''' Himmelsrichtungen und den '''vier''' Jahreszeiten: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Vier_in_Religionen|'''Bedeutung der Vier in Religionen''']].
* '''Sieben''' Wandelgestirne mit den die '''sieben''' Tagen einer Woche beziehungsweise eines Mondviertels: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Sieben_in_Religionen|'''Bedeutung der Sieben in Religionen''']].
* '''Zwölf''' Ekliptiksternbilder, '''zwölf''' Monate pro Jahr, '''zwölf''' Jahre Umlaufzeit des Planeten Jupiter, jeweils '''zwölf''' Stunden Tag und Nacht: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Zwölf_in_Religionen|'''Bedeutung der Zwölf in Religionen''']].

=== Altes Testament ===
In der Bibel wird in der Regel nicht zwischen Fixsternen und Planeten unterschieden. Eine Ausnahme gibt es im 2.&amp;nbsp;Buch der Könige, Kapitel&amp;nbsp;23, Vers&amp;nbsp;5 aus dem siebenten vorchristlichen Jahrhundert, wo in der deutschsprachigen Einheitsübersetzung von &quot;den Wandelsternen&quot; und in der Luther-Bibel von &quot;den Planeten&quot; die Rede ist. Die Vulgata schreibt hier allerdings von den &quot;duodecim signis&quot;, womit sicherlich die zwölf Sternzeichen der Ekliptik gemeint sind, durch die die sieben Wandelgestirne ziehen. Die Septuaginta spricht noch allgemeiner von den &quot;μαζουρωθ&quot; nach dem Hebräischen Wort &quot;מַזָּלָה&quot; (&quot;mazzaroth&quot;), womit vermutlich Sternkonstellationen und im engeren Sinne ebenfalls die zwölf Sternzeichen des Zodiaks gemeint sind:

&lt;blockquote&gt;
'''Septuaginta '''&lt;br/&gt;
5 καὶ κατέπαυσεν τοὺς χωμαριμ, οὓς ἔδωκαν βασιλεῖς Ιουδα καὶ ἐθυμίων ἐν τοῖς ὑψηλοῖς καὶ ἐν ταῖς πόλεσιν Ιουδα καὶ τοῖς περικύκλῳ Ιερουσαλημ, καὶ τοὺς θυμιῶντας τῷ Βααλ καὶ τῷ ἡλίῳ καὶ τῇ σελήνῃ καὶ τοῖς '''μαζουρωθ''' καὶ πάσῃ τῇ δυνάμει τοῦ οὐρανοῦ.&lt;br/&gt;
&lt;br/&gt;
'''Vulgata'''&lt;br/&gt;
5 Et delevit aedituos, quos posuerant reges Iudae ad sacrificandum in excelsis per civitates Iudae et in circuitu Ierusalem, et eos, qui adolebant Baal et soli et lunae et '''duodecim signis''' et omni militiae caeli.&lt;br/&gt;
&lt;br/&gt;
'''Einheitsübersetzung (2016)'''&lt;br/&gt;
5 Auch setzte er die Götzenpriester ab, die von den Königen von Juda bestellt worden waren und die auf den Kulthöhen, in den Städten Judas und in der Umgebung Jerusalems Opfer verbrannt sowie dem Baal, der Sonne, dem Mond, den '''Wandelsternen''' und dem ganzen Heer des Himmels geopfert hatten.&lt;br/&gt;
&lt;br/&gt;
'''Luther-Bibel (2017)'''&lt;br/&gt;
5 Und er setzte die Götzenpriester ab, die die Könige von Juda eingesetzt hatten, um auf den Höhen zu opfern in den Städten Judas und um Jerusalem her; auch die dem Baal geräuchert hatten, der Sonne und dem Mond und den '''Planeten''' und allem Heer am Himmel.&lt;br/&gt;
&lt;/blockquote&gt;

Der Prophet Habakuk erwähnt in seinem Psalm in Kapitel&amp;nbsp;3 aus dem siebenten vorchristlichen Jahrhundert das Konzept der Aufteilung der Ekliptik in Mondstationen respektive in Mondhäuser:

&lt;blockquote&gt;
10 Wenn sie dich sehen, erbeben die Berge,&lt;br/&gt;
das Tosen der Wasser rauscht vorüber; es erhebt die Urflut ihre Stimme,&lt;br/&gt;
hoch oben vergisst die Sonne ihre Strahlen.&lt;br/&gt;
11 '''Der Mond bleibt in der Behausung;'''&lt;br/&gt;
als Beleuchtung schwirren deine Pfeile,&lt;br/&gt;
als heller Schein das Blitzen deiner Lanze.
&lt;/blockquote&gt;

In den folgenden Bibelstellen aus dem Alten Testament spiegeln sich astronomische Vorstellungen in Bezug auf Gott wider:

'''Genesis 1:'''
&lt;blockquote&gt;
1 Im Anfang erschuf Gott '''Himmel''' und Erde.&lt;br/&gt;
2 Die '''Erde''' war wüst und wirr und '''Finsternis''' lag über der '''Urflut''' und Gottes Geist schwebte über dem '''Wasser'''.&lt;br/&gt;
3 Gott sprach: Es werde '''Licht'''. Und es wurde '''Licht'''.
...&lt;br/&gt;
5 Und Gott nannte das Licht '''Tag''' und die Finsternis nannte er '''Nacht'''. Es wurde '''Abend''' und es wurde '''Morgen''': erster Tag.&lt;br/&gt;
...&lt;br/&gt;
14 Dann sprach Gott: Lichter sollen am '''Himmelsgewölbe''' sein, um '''Tag''' und '''Nacht''' zu scheiden. Sie sollen als Zeichen für '''Festzeiten''', für '''Tage''' und '''Jahre''' dienen.&lt;br/&gt;
15 Sie sollen Lichter am Himmelsgewölbe sein, um über die Erde hin zu leuchten. Und so geschah es.&lt;br/&gt;
16 Gott machte '''die beiden großen Lichter''', das große zur Herrschaft über den '''Tag''', das kleine zur Herrschaft über die '''Nacht''', und die '''Sterne'''.
&lt;/blockquote&gt;

'''Psalm 8:'''
&lt;blockquote&gt;
4 Seh ich deine '''Himmel''', die Werke deiner Finger, '''Mond '''und '''Sterne''', die du befestigt.
&lt;/blockquote&gt;

[[Datei:Johannes.Kepler.Coeli.enarrant.gloriam.Dei.png|mini|rechts|Portrait des jungen Johannes Keplers mit dem Motto &quot;Coeli enarrant gloriam Dei.&quot; nach Psalm 19: &quot;Die Himmel erzählen die Herrlichkeit Gottes.&quot;]]

'''Psalm 19:'''
&lt;blockquote&gt;
2 Die '''Himmel''' erzählen die Herrlichkeit Gottes und das '''Firmament''' kündet das Werk seiner Hände.
&lt;/blockquote&gt;

'''Psalm 90:'''
&lt;blockquote&gt;
2 Ehe geboren wurden die Berge, ehe du unter Wehen hervorbrachtest '''Erde''' und '''Erdkreis''', bist du Gott von Ewigkeit zu Ewigkeit.
&lt;/blockquote&gt;

'''Psalm 102:'''
&lt;blockquote&gt;
26 Vorzeiten hast du der Erde Grund gelegt, die '''Himmel''' sind das Werk deiner Hände.
&lt;/blockquote&gt;

'''Psalm 103:'''
&lt;blockquote&gt;
19 Der HERR hat seinen Thron errichtet im '''Himmel''', seine königliche Macht beherrscht '''das All'''.
&lt;/blockquote&gt;

'''Psalm 104:'''
&lt;blockquote&gt;
19 Du machst den '''Mond''' zum Maß für die Zeiten, die '''Sonne''' weiß, wann sie untergeht.
&lt;/blockquote&gt;

'''Psalm 113:'''
&lt;blockquote&gt;
3 Vom '''Aufgang der Sonne''' bis zu ihrem '''Untergang''' sei gelobt der Name des HERRN.&lt;br/&gt;
4 Erhaben ist der HERR über alle Völker, über den '''Himmeln''' ist seine Herrlichkeit.
&lt;/blockquote&gt;

'''Psalm 136:'''
&lt;blockquote&gt;
3 Dankt dem Herrn der Herren, denn seine Huld währt ewig!&lt;br/&gt;
4 Ihm, der allein große Wunder tut, denn seine Huld währt ewig,&lt;br/&gt;
5 der den '''Himmel''' gemacht hat in Weisheit, denn seine Huld währt ewig,&lt;br/&gt;
6 der die Erde gefestigt hat über den Wassern, denn seine Huld währt ewig,&lt;br/&gt;
7 der '''die großen Leuchten''' gemacht hat, denn seine Huld währt ewig,&lt;br/&gt;
8 die '''Sonne''' zur Herrschaft über den '''Tag''', denn seine Huld währt ewig,&lt;br/&gt;
9 den '''Mond''' und die '''Sterne''' zur Herrschaft über die '''Nacht''', denn seine Huld währt ewig.
&lt;/blockquote&gt;

'''Psalm 147:'''
&lt;blockquote&gt;
4 Er bestimmt die Zahl der '''Sterne''' und ruft sie alle mit Namen.
&lt;/blockquote&gt;

'''Psalm 148:'''
&lt;blockquote&gt;
'''Lobpreis auf den Herrn, den König des Kosmos'''&lt;br/&gt;
1 Halleluja! Lobt den HERRN vom '''Himmel''' her, lobt ihn in den Höhen:&lt;br/&gt;
2 Lobt ihn, all seine Engel, lobt ihn, all seine Heerscharen,&lt;br/&gt;
3 lobt ihn, '''Sonne''' und '''Mond''', lobt ihn, all ihr leuchtenden '''Sterne''',&lt;br/&gt;
4 lobt ihn, ihr '''Himmel der Himmel''', ihr Wasser über dem '''Himmel'''!
&lt;/blockquote&gt;

Mit den &quot;Wassern über dem Himmel&quot; können nicht die Wolken unterhalb der Sternensphäre gemeint sein. Vielmehr dürfte es sich um eine Anspielung auf den Urozean beziehungsweise die Urflut handeln (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Urozean''']]). Diese Urflut existierte bereits vor der Erschaffung des Lichts und der Gestirne. Man erinnere sich an den Beginn der Schöpfungsgeschichte in den ersten drei Versen der Bibel (siehe oben).

'''Buch der Weisheit (Weisheit Salomos):'''
&lt;blockquote&gt;
'''Salomos Gebet um Weisheit'''&lt;br/&gt;
9,1 Gott der Väter und Herr des Erbarmens, du hast '''das All''' durch dein Wort gemacht.
&lt;/blockquote&gt;

'''Jesus Sirach 42:'''
&lt;blockquote&gt;
'''Lob Gottes in der Schöpfung'''&lt;br/&gt;
15 Nun will ich der Werke des Herrn gedenken, und was ich gesehen habe, werde ich erzählen: Durch die Worte des Herrn sind seine Werke und durch seinen Segen gab er ihnen ihre Bestimmung.&lt;br/&gt;
16 Die leuchtende '''Sonne''' blickt auf alles hernieder und von der Herrlichkeit des Herrn ist sein Werk erfüllt.&lt;br/&gt;
17 Der Herr gab es selbst den Heiligen nicht, all seine Wunder zu erzählen, der Herr der Herrscher über '''das All''', hat sie gegründet, sodass '''das All''' in seiner Herrlichkeit Bestand hat.&lt;br/&gt;
18 Abgrund und Herz hat er durchforscht und ihre Absichten hat er durchschaut; denn der Höchste kennt alles Wissen und er blickt auf die '''Zeichen der Zeiten'''.&lt;br/&gt;
19 Er tut das Vergangene und das Kommende kund und enthüllt die Spuren des Verborgenen.&lt;br/&gt;
20 Kein Gedanke entgeht ihm und kein einziges Wort bleibt ihm verborgen.&lt;br/&gt;
21 Die Großtaten seiner Weisheit hat er geordnet; wie er ist '''von Ewigkeit und in Ewigkeit'''. Ihm ist weder etwas hinzugefügt noch weggenommen worden und er hat keines Ratgebers bedurft.
&lt;/blockquote&gt;

Auch im nachfolgenden Kapitel lobt Jesus Sirach die Sonne, den Mond und die Sterne in den höchsten Tönen:

'''Jesus Sirach 43:'''
&lt;blockquote&gt;
1 Der Stolz der Höhe ist ein '''Firmament''' von Reinheit, die Gestalt des '''Himmels''' beim Anblick der Herrlichkeit.&lt;br/&gt;
2 Die '''Sonne''' verkündet durch ihr Erscheinen beim Aufgang, ein wunderbares Geschöpf, ein Werk des Höchsten!&lt;br/&gt;
3 Zur '''Mittagszeit''' trocknet sie den Boden aus, wer wird bestehen vor ihrer Glut?&lt;br/&gt;
4 Wer in einen Ofen bläst bei Arbeiten mit Glut - dreimal so stark versengt die '''Sonne''' Berge; sie atmet Feuerdämpfe aus und blendet mit gleißenden Strahlen die Augen.&lt;br/&gt;
5 Groß ist der Herr, der sie gemacht hat, mit seinen Worten beschleunigt er ihren Lauf.&lt;br/&gt;
6 Auch der '''Mond''' hält sich in allem an seinen Zeitpunkt, zur '''Festsetzung der Zeiten''' und als Zeichen auf Dauer.&lt;br/&gt;
7 Vom '''Mond''' geht das Zeichen für einen Festtag aus, ein Gestirn, das abnimmt bis zur Vollendung.&lt;br/&gt;
8 Der Name '''Monat''' kommt vom '''Neumond''', der wunderbar zunimmt beim Wechsel, ein Geschöpf des Heeres in der Höhe, das am '''Himmelsgewölbe''' leuchtet.&lt;br/&gt;
9 Die Schönheit des '''Himmels''' ist der Glanz der '''Sterne''', ein strahlender Schmuck in den Höhen des Herrn.&lt;br/&gt;
10 Durch die Worte des Heiligen stehen sie gemäß ihrer Bestimmung und sie ermüden nie bei ihrer Wache.&lt;br/&gt;
...&lt;br/&gt;
27 Vieles werden wir sagen, aber wir kommen nie an ein Ziel und das Ende der Worte ist: Er ist '''das All'''.
&lt;/blockquote&gt;

'''Jesaja 40:'''
&lt;blockquote&gt;
26 Hebt eure Augen in die Höhe und seht: Wer hat diese '''Gestirne''' erschaffen?&lt;br/&gt;
Der vollzählig herausführt ihr Heer, er ruft sie alle beim Namen.&lt;br/&gt;
Wegen seiner Fülle an Kraft und mächtiger Stärke fehlt kein einziges.
&lt;/blockquote&gt;

Das Buch Baruch gehört zu den späten Schriften des Alten Testaments. Im dritten Kapitel werden das Licht und die Sterne in Bezug auf Gott thematisiert:

'''Baruch 3:'''
&lt;blockquote&gt;
33 Er entsendet das '''Licht''' und es eilt dahin; er ruft es zurück und zitternd gehorcht es ihm.&lt;br/&gt;
34 Froh leuchten die '''Sterne''' auf ihren Posten.&lt;br/&gt;
35 Ruft er sie, so antworten sie: Hier sind wir. Sie leuchten mit Freude für ihren Schöpfer.&lt;br/&gt;
36 Das ist unser Gott; kein anderer gilt neben ihm.
&lt;/blockquote&gt;

Ein Lobpreis auf die Werke, Engel und Mächte Gottes am Gewölbe des Himmels findet sich im '''Buch Daniel''' im dritten Kapitel. Der Text macht inhaltlich eine ähnliche Aussage wie der Lobpreis auf den Herrn, den König des Kosmos in Psalm 148 (siehe oben):

'''Daniel 3:'''
&lt;blockquote&gt;
56 Gepriesen bist du am Gewölbe des '''Himmels''', gerühmt und verherrlicht in Ewigkeit.&lt;br/&gt;
57 Preist den HERRN, all ihr Werke des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
58 Preist den HERRN, ihr '''Himmel'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
59 Preist den HERRN, ihr Engel des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
60 Preist den HERRN, all ihr '''Wasser über dem Himmel'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
61 Preist den HERRN, all ihr Mächte des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
62 Preist den HERRN, '''Sonne und Mond'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
63 Preist den HERRN, ihr '''Sterne am Himmel'''; lobt und rühmt ihn in Ewigkeit!
&lt;/blockquote&gt;

=== Der Himmelsthron ===
Der '''Himmelsthron''' wir in vielen Texten des Alten Testaments als der Sitz Gottes genannt. Hier zunächst einige Erwähnungen in den Psalmen:

&lt;blockquote&gt;
11,4 Der HERR ist in seinem heiligen Tempel, der HERR hat seinen '''Thron im Himmel'''.&lt;br/&gt;
Seine Augen schauen herab, seine Blicke prüfen die Menschen.
&lt;/blockquote&gt;

&lt;blockquote&gt;
33,13 Der HERR blickt herab vom '''Himmel''', er sieht alle Menschen.&lt;br/&gt;
33,14 Von seinem '''Thronsitz''' schaut er nieder auf alle Bewohner der Erde.
&lt;/blockquote&gt;

&lt;blockquote&gt;
89,37 Sein Haus soll bleiben auf ewig, sein '''Thron''' habe Bestand vor mir wie die '''Sonne''';
&lt;/blockquote&gt;

&lt;blockquote&gt;
103,19 Der HERR hat seinen '''Thron''' errichtet im '''Himmel''', seine königliche Macht beherrscht '''das All'''.
&lt;/blockquote&gt;

Im Buch der Weisheit stehen die folgenden beiden Verse:

&lt;blockquote&gt;
9,9 Mit dir ist die Weisheit, die deine Werke kennt und die zugegen war, als du die Welt erschufst. Sie weiß, was wohlgefällig ist in deinen Augen und was recht ist nach deinen Geboten.&lt;br/&gt;
9,10 Sende sie vom heiligen '''Himmel''' und schick sie vom '''Thron''' deiner Herrlichkeit, damit sie bei mir sei und alle Mühe mit mir teile und ich erkenne, was wohlgefällig ist bei dir!
&lt;/blockquote&gt;

Diese Bild von Gottes Thron im Himmel wir auch im Neuen Testament aufgegriffen, wie beispielsweise beim Evangelisten Matthäus (Kapitel 5, Vers 34) oder in der Offenbarung des Johannes, wo im vierten Kapitel die eröffnende Himmelsvision mit dem Abschnitt über &quot;Die Huldigung vor dem Thron Gottes&quot; beginnt:

&lt;blockquote&gt;
1 Danach sah ich und siehe, eine Tür war geöffnet am '''Himmel'''; und die erste Stimme, die ich gleich einer Posaune mit mir reden gehört hatte, sagte: Komm herauf und ich werde dir zeigen, was dann geschehen muss.&lt;br/&gt;
2 Sogleich wurde ich vom Geist ergriffen. Und siehe, '''ein Thron stand im Himmel'''; auf dem Thron saß einer,&lt;br/&gt;
3 der wie ein Jaspis und ein Karneol aussah. Und über dem '''Thron''' wölbte sich ein Regenbogen, der wie ein Smaragd aussah.&lt;br/&gt;
4 Und rings um den '''Thron standen vierundzwanzig Throne''' und auf den Thronen saßen vierundzwanzig Älteste, in weiße Gewänder gekleidet und mit goldenen Kränzen auf dem Haupt.&lt;br/&gt;
5 Von dem Thron gingen Blitze, Stimmen und Donner aus. Und '''sieben lodernde Fackeln brannten vor dem Thron; das sind die sieben Geister Gottes'''.&lt;br/&gt;
6 Und vor dem Thron war etwas wie ein gläsernes Meer, gleich Kristall. Und in der Mitte des Thrones und rings um den Thron waren '''vier Lebewesen''' voller Augen, vorn und hinten.&lt;br/&gt;
7 Das erste Lebewesen glich einem '''Löwen''', das zweite einem '''Stier''', das dritte sah aus wie ein '''Mensch''', das vierte glich einem '''fliegenden Adler'''.&lt;br/&gt;
&lt;/blockquote&gt;

Der achtstrophige Adventshymnus ''Veni redemptor gentium'' (die deutschsprachige Kontrafaktur heißt &quot;Nun komm, der Heiden Heiland&quot;) wird dem Kirchenvater Ambrosius von Mailand (339–397) zugeschrieben. In der fünften Strophe wird mit Bezug auf die Himmelfahrt des Messias der Sitz Gottes erwähnt:

&lt;blockquote&gt;
5,1 Egressus eius a Patre,&lt;br/&gt;
5,2 Regressus eius ad Patrem;&lt;br/&gt;
5,3 Excursus usque ad inferos,&lt;br/&gt;
5,4 Recursus ad '''sedem Dei'''.
&lt;/blockquote&gt;

&lt;blockquote&gt;
5,1 Sein Ausgang ist vom Vater,&lt;br/&gt;
5,2 Seine Rückkehr ist beim Vater;&lt;br/&gt;
5,3 Hinausgelaufen bis zu den Toten,&lt;br/&gt;
5,4 Zurückgelaufen bis zum '''Sitz Gottes'''.
&lt;/blockquote&gt;

Es ist nicht viel Phantasie erforderlich, um den Thron Gottes im '''Himmelsstier''' wiederzuerkennen. Die vierundzwanzig Throne, die sich entlang der '''Ekliptik''' um diesen Thron herum aufreihen, stehen für die vierundzwanzig Stunden eines Tages, und sie sind je zwei für jedes der zwölf Lebewesenkreiszeichen des '''Zodiaks'''. Die als sieben lodernde Fackeln vor dem Thron sind die sieben '''Wandelgestirne''', die als die '''sieben Geister Gottes''' immer wieder durch das '''Goldene Tor der Ekliptik''' in der Sitzfläche des Thrones ziehen. Die '''vier besonderen Lebewesen''' sind die vier Evangelistensymbole bei den vier zoroastrischen '''Königssternen'''.

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|'''Himmelsstier''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Die_Ekliptik|'''Ekliptik''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|'''Zodiak''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|'''Goldenes Tor der Ekliptik''']].

→ Siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Vier_in_Religionen|'''Bedeutung der Vier in Religionen''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Königssterne|'''Königssterne''']].

&lt;gallery caption=&quot;Throne&quot; widths=640 heights=480 perrow=3&gt;
StatueOfEl.png|Rekonstruktion der 1988 in Ugarit ausgegrabenen und auf einem Thron sitzenden Statue vom höchsten ugaritischen Gott El, der als Erschaffer der Welt angebetet wurde.
Aachen_Cathedral_Karlsthron_02.jpg|Thron Karls des Großen aus den 790er Jahren im Aachener Dom.
Himmelsthron.Taurus.Aries.png|Himmelsthron in den Sternbildern Stier (Taurus) und Widder (Aries) vor dem Untergang in Richtung Westen.
&lt;/gallery&gt;

=== Das Lamm ===
Im ersten Kapitel des Evangeliums nach Johannes wird Jesus von Nazareth explizit als &quot;Lamm Gottes&quot; bezeichnet:&lt;ref&gt;[https://www.bibleserver.com/EU/Johannes1%2C29 Johannes 1,29], bibleserver.com, Einheitsübersetzung (2016)&lt;/ref&gt;

&lt;blockquote&gt;
29b Seht, das '''Lamm Gottes''', das die Sünde der Welt hinwegnimmt!&lt;br/&gt;
...&lt;br/&gt;
36b Seht, das '''Lamm Gottes'''!
&lt;/blockquote&gt;

Es handelt sich beim „Lamm Gottes“ (Kirchenlatein: „Agnus Dei“) um ein seit ältester Zeit verbreitetes Symbol für Jesus Christus. Es wird auch als das Osterlamm bezeichnet, das am Ostertag, also kurz nach der Tag-und-Nacht-Gleiche im Frühjahr auferstanden ist. Nach dem Evangelisten Markus wurde die Auferstehung „... am ersten Tag der Woche, früh am Morgen, als eben die Sonne aufging“, also am Ostersonntag während der Morgenröte im Osten entdeckt.&lt;ref&gt;[https://www.bibleserver.com/LUT/Markus16%2C2 Markus 16,2], Einheitsübersetzung, 2016&lt;/ref&gt; Am 40.&amp;nbsp;Tag ist Jesus Christus nach dem Zeugnis der Evangelisten Markus und Lukas in den Himmel aufgefahren. Zu Beginn der Apostelgeschichte wird dieses Ereignis folgendermaßen beschrieben:&lt;ref&gt;[https://www.bibleserver.com/EU/Apostelgeschichte1 Apostelgeschichte 1], Einheitsübersetzung, 2016&lt;/ref&gt;

&lt;blockquote&gt;
7 Er sagte zu ihnen: Euch steht es nicht zu, Zeiten und Fristen zu erfahren, die der Vater in seiner Macht festgesetzt hat.&lt;br/&gt;
8 Aber ihr werdet Kraft empfangen, wenn der Heilige Geist auf euch herabkommen wird; und ihr werdet meine Zeugen sein in Jerusalem und in ganz Judäa und Samarien und bis an die Grenzen der Erde.&lt;br/&gt;
9 Als er das gesagt hatte, wurde er vor ihren Augen emporgehoben und eine Wolke nahm ihn auf und entzog ihn ihren Blicken.&lt;br/&gt;
&lt;/blockquote&gt;

Im altrömischen Glaubensbekenntnis gibt es die Textstelle:

&lt;blockquote&gt;
„ascendit in caelis, sedet ad dexteram Patris“
&lt;/blockquote&gt;

Zu Deutsch:

&lt;blockquote&gt;
„aufgefahren in den Himmel, er sitzt zur Rechten des Vaters“
&lt;/blockquote&gt;

Das '''Lamm''' (astronomisch Widder) befindet sich am nördlichen Sternenhimmel '''zur Rechten''' des Stieres (Taurus). Sowohl der mesopotamische Himmelsstier als auch das altarabische Sternbild Thuraya verbinden diese beiden neuzeitlichen Sternbilder zu einer Einheit. Der Hauptstern im Sternbild Widder (Aries) heißt Hamal, und das arabische Wort &quot;hamal&quot; steht für ein einjähriges Lamm.&lt;ref name=&quot;Adams&quot;&gt;Danielle Adams: [http://onesky.arizona.edu/arab-star-names/the-lamb/ The Lamb – A folkloric celestial complex], Two Deserts, one Sky – Arab Star Calendars&lt;/ref&gt; Der fette Schwanz des Lammes wird durch die '''Plejaden (Siebengestirn)''' markiert.&lt;ref name=&quot;Adams&quot; /&gt; Die Augen des Stieres sind die Sterne '''Aldebaran''' und '''Ain'''. Zwischen dem Kopf des Stieres und den '''Plejaden''' befindet sich das '''Goldene Tor der Ekliptik''', durch das alle Wandelgestirne regelmäßig hindurchziehen.

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Bibelstellen|'''Bibelstellen zum Siebengestirn''']].

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|'''Goldenes Tor der Ekliptik''']].

Der Frühlingspunkt der Sonne, also deren Ort auf der Ekliptiklinie zur Tag-und-Nacht-Gleiche im Frühjahr, ist von der monotheistischen Schöpfung bis zur Geburt des christlichen Gottessohns vom Kopf des Stiers (bei den Sternen '''Aldebaran''' und '''Ain''' im Goldenen Tor der Ekliptik) im heutigen Sternbild Stier (Taurus) bis zum Kopf des Lammes (beim Stern '''Hamal''') im heutigen Sternbild Widder (Aries) nach Westen gewandert. Heute befindet sich der Frühlingspunkt bereits am westlichen Ende des Sternbilds Fische (Pisces), das sich westlich an das Sternbild Widder anschließt.

==== Offenbarung des Johannes ====
In der Offenbarung des Johannes heißt es im 7.&amp;nbsp;Kapitel:

&lt;blockquote&gt;
10b Die Rettung kommt von unserem '''Gott''', der auf dem '''Thron''' sitzt, und von dem '''Lamm'''.&lt;br/&gt;
17a Denn das Lamm in der Mitte vor dem Thron wird sie weiden und zu den Quellen führen, aus denen das '''Wasser des Lebens''' strömt.
&lt;/blockquote&gt;

Wird der '''Thron Gottes''' mit dem Himmelsstier identifiziert (siehe oben), dann sitzt das '''Lamm''' (Aries, Sternbild Widder) westlich und somit rechts vor diesem Thron. Im weiteren Verlauf der Ekliptik nach Westen befinden sich die zusammenhängenden '''Wassersternbilder''' des Urozeans, dem Urquell des Lebens. Es handelt ich um die heutigen Sternbilder Fluss Eridanus, Walfisch (Cetus), Fische (Pisces), Wassermann (Aquarius), Südlicher Fisch (Piscis Austrinus) und Delphin (Delphinus) sowie Steinbock (Capricornus, früher Ziegenfisch).

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Urozean''']].

&lt;gallery caption=&quot;Das Lamm zur Rechten des Stieres&quot; mode=packed widths=800 heights=600&gt;
Himmelsstier.P1117152.jpg|Astrophotographie vom Asterismus Himmelsstier
Himmelsstier.Sternbilder.P1117152.png|Beschriftete Astrophotographie vom Himmelsstier am winterlichen Abendhimmel in Richtung südlicher Meridian. Die Ekliptiklinie verläuft horizontal etwas unterhalb der Bildmitte.
Haende.der.Thuraya.Vollmond.Sterne.P1079912.jpg|Astrophotographie der Himmelsregion mit dem beduinischen Sternbild &quot;Hände der Thuraya&quot; (grüne durchgezogene Linien, Ekliptik rot gepunktete Linie) mit arabisch bezeichneten Sternen. Der Vollmond befindet sich zwischen den Sternbildern Taurus, Aries und Cetus.
Urozean.Wassersternbilder.png|Die zusammenhängenden Wassersternbilder des Urozeans am Sternenhimmel: Fluss Eridanus, Walfisch (Cetus), Fische (Pisces), Wassermann (Aquarius), Südlicher Fisch (Piscis Austrinus), Delphin (Delphinus) sowie Ziegenfisch (Steinbock, Capricornus).
&lt;/gallery&gt;

Interpretiert man das Sternbild &quot;Lamm&quot; (Widder / Aries) als Mittler auf dem ekliptischen Weg vom finsteren kosmischen Urozean im Westen (rechts) zum strahlenden majestätischen Sternbild Stier (Taurus) im Osten (links), ergeben auch andere Bibelstellen in Bezug auf den Sternenhimmel einen tiefen symbolischen Sinn, die in den folgenden Abschnitten aufgeführt sind.

==== Evangelium nach Johannes ====
Die Rede von Jesus an den Jünger Thomas aus dem 14.&amp;nbsp;Kapitel des Evangeliums nach Johannes ist in diesem Zusammenhang interessant:

&lt;blockquote&gt;
6 Jesus sagte zu ihm: Ich bin der Weg und die Wahrheit und das Leben; niemand kommt zum Vater außer durch mich.&lt;br/&gt;
7 Wenn ihr mich erkannt habt, werdet ihr auch meinen Vater erkennen. Schon jetzt kennt ihr ihn und habt ihn gesehen.
&lt;/blockquote&gt;

Alle Wandelgestirne bewegen sich entlang der Ekliptiklinie (Weg) durch das heutige Sternbild Widder (das altarabische Sternbild &quot;Lamm&quot;) im Westen zum [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der-Ekliptik|Goldenen Tor der Ekliptik]] nach Osten im großen Himmelsstier (Vater / Thron).

==== Evangelium nach Markus ====
Im Evangelium nach Markus heißt es:

&lt;blockquote&gt;
14,62 Jesus sagte: Ich bin es. Und ihr werdet den Menschensohn '''zur Rechten der Macht''' sitzen und mit den Wolken des '''Himmels''' kommen sehen.
&lt;/blockquote&gt;

&lt;blockquote&gt;
16,19 Nachdem Jesus, der Herr, dies zu ihnen gesagt hatte, wurde er in den '''Himmel''' aufgenommen und setzte sich '''zur Rechten Gottes'''.
&lt;/blockquote&gt;

==== Evangelium nach Lukas ====
Im Evangelium nach Lukas ist es folgendermaßen formuliert:

&lt;blockquote&gt;
22,69 Von nun an wird der Menschensohn '''zur Rechten der Macht Gottes''' sitzen.
&lt;/blockquote&gt;

==== Evangelium nach Matthäus ====
Auch im Evangelium nach Matthäus findet sich eine entsprechende Stelle:

&lt;blockquote&gt;
26,64 Jesus antwortete: Du hast es gesagt. Doch ich erkläre euch: Von nun an werdet ihr den Menschensohn '''zur Rechten der Macht''' sitzen und auf den Wolken des '''Himmels''' kommen sehen.
&lt;/blockquote&gt;

==== Brief an die Hebräer ====
Im Brief an die Hebräer, dessen Autor unbekannt ist, gibt es etliche entsprechende Stellen:

&lt;blockquote&gt;
'''Gottes Rede in seinem Sohn'''&lt;br/&gt;
1,3 er ist der Abglanz seiner Herrlichkeit und das Abbild seines Wesens; er trägt '''das All''' durch sein machtvolles Wort, hat die Reinigung von den Sünden bewirkt und sich dann '''zur Rechten der Majestät in der Höhe''' gesetzt;&lt;br/&gt;
1,10 Und: Du, Herr, hast vorzeiten der Erde Grund gelegt, die '''Himmel''' sind das Werk deiner Hände.&lt;br/&gt;
1,11 Sie werden vergehen, '''du aber bleibst'''; sie alle veralten wie ein Gewand;&lt;br/&gt;
1,12 du rollst sie zusammen wie einen Mantel und wie ein Gewand werden sie gewechselt. Du aber bleibst, der du bist, und '''deine Jahre enden nie'''.&lt;br/&gt;
1,13 Zu welchem Engel hat er jemals gesagt: Setze dich mir '''zur Rechten''' und ich lege dir deine Feinde als Schemel unter die Füße?
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Die Liturgie des neuen Bundes'''&lt;br/&gt;
8,1 Die Hauptsache bei dem Gesagten aber ist: Wir haben einen solchen Hohepriester, der sich '''zur Rechten des Thrones der Majestät im Himmel''' gesetzt hat,&lt;br/&gt;
8,2 als Diener des Heiligtums und des '''wahren Zeltes''', das der Herr selbst aufgeschlagen hat, nicht ein Mensch.
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Christus als Mittler des neuen Bundes'''&lt;br/&gt;
9,24 Denn Christus ist nicht in ein von Menschenhand gemachtes Heiligtum hineingegangen, in ein Abbild des wirklichen, sondern '''in den Himmel selbst''', um jetzt '''vor Gottes Angesicht''' zu erscheinen für uns;
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Das Opfer Jesu Christi als endgültige Versöhnung mit Gott'''&lt;br/&gt;
10,12 Dieser aber hat nur ein einziges Opfer für die Sünden dargebracht und sich dann '''für immer zur Rechten Gottes''' gesetzt;
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Das Beispiel Jesu Christi'''&lt;br/&gt;
12,2 und dabei auf Jesus blicken, den Urheber und Vollender des Glaubens; er hat angesichts der vor ihm liegenden Freude das Kreuz auf sich genommen, ohne auf die Schande zu achten, und sich '''zur Rechten von Gottes Thron''' gesetzt.
&lt;/blockquote&gt;

==== Erster Brief des Petrus ====
Der erste Brief des Petrus zählt zu den katholischen Briefen des Neuen Testaments. Dort heißt es im letzten Satz über Jesus Christus:

&lt;blockquote&gt;
22 der in den '''Himmel''' gegangen ist; dort ist er '''zur Rechten''' Gottes und Engel, Gewalten und Mächte sind ihm unterworfen.
&lt;/blockquote&gt;

==== Apostelgeschichte ====
Die Apostelgeschichte schließt an das Evangelium nach Lukas an und wird ebenfalls diesem zugeschrieben. Hier kommen der erste bekennende sowie erste berufene Apostel Petrus und der erste christliche Märtyrer Stephanus zu Wort:

&lt;blockquote&gt;
'''Die Pfingstpredigt des Petrus'''&lt;br/&gt;
2,33 '''Zur Rechten Gottes''' erhöht, hat er vom Vater den verheißenen Heiligen Geist empfangen und ihn ausgegossen, wie ihr seht und hört.
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Steinigung des Stephanus'''&lt;br/&gt;
7,55 Er aber, erfüllt vom Heiligen Geist, blickte zum '''Himmel''' empor, sah die Herrlichkeit Gottes und Jesus '''zur Rechten Gottes''' stehen&lt;br/&gt;
7,56 und rief: Siehe, ich sehe den Himmel offen und den Menschensohn '''zur Rechten Gottes''' stehen.
&lt;/blockquote&gt;

=== Himmelspforte ===
Das Sternbild Widder (Aries) repräsentiert als das Lamm Gottes den nördlichen Pfeiler des Goldenen Tors der Ekliptik. Der fette Schwanz des Lammes wird nach altarabischer Tradition durch das Siebengestirn (Plejaden) gebildet, das heute zu Sternbild '''Stier''' (Taurus) gezählt wird. Der südliche Pfeiler des Goldenen Tors der Ekliptik wird durch die Hyaden und den Stern Menkar im Sternbild Walfisch (Cetus) gebildet. Das Goldene Tor der Ekliptik stellt mit diesen beiden Pfeilern somit eine '''Himmelspforte''' dar, durch die alle Wandelgestirne regelmäßig von Westen aus dem dunklen Urozean der winterlichen Wassersternbilder sowie der Richtung des Sonnenuntergangs nach Osten in das helle Gebiet des Sternenhimmels mit den Frühlings- und Sommersternbildern sowie die Richtung des Sonnenaufgangs treten.

[[Datei:Mars.im.Goldenen.Tor.der.Ekliptik.P1091607.jpg|mini|hochkant=3|zentriert|Der am nordwestlichen Horizont in der Nähe der Ekliptiklinie und im Goldenen Tor der Ekliptik untergehende Mars (rote Scheibe unten halb rechts) drei Tage vor dem Durchqueren der '''Himmelspforte''' zwischen dem Kopf des Himmelsstieres mit dem Sternhaufen der Hyaden (unten links) und den Plejaden nördlich der Ekliptik (rechts unten).]]

Die Genesis berichtet im 28.&amp;nbsp;Kapitel unter der Überschrift &quot;Jakob in Bet-El&quot; (hebräisch בֵּית אֵל „Haus des El“ oder „Haus Gottes“) über einen Traum von Jakob, in dem er eine Treppe zum Himmel (die Himmelsleiter oder Jakobsleiter) sieht, an dessen oberen Ende sich das Tor des Himmels (die Himmelspforte) befindet:

&lt;blockquote&gt;
10 Jakob zog aus Beerscheba weg und ging nach Haran.&lt;br/&gt;
11 Er kam an einen bestimmten Ort und übernachtete dort, denn die Sonne war untergegangen. Er nahm einen von den Steinen dieses Ortes, legte ihn unter seinen Kopf und schlief dort ein.&lt;br/&gt;
12 Da hatte er einen Traum: Siehe, eine Treppe stand auf der Erde, ihre Spitze reichte bis zum '''Himmel'''. Und siehe: Auf ihr stiegen Engel Gottes auf und nieder.&lt;br/&gt;
13 Und siehe, der HERR stand vor ihm und sprach: Ich bin der HERR, der Gott deines Vaters Abraham und der Gott Isaaks. Das Land, auf dem du liegst, will ich dir und deinen Nachkommen geben.&lt;br/&gt;
14 Deine Nachkommen werden zahlreich sein wie der Staub auf der Erde. Du wirst dich '''nach Westen und Osten, nach Norden und Süden''' ausbreiten und durch dich und deine Nachkommen werden alle Sippen der Erde Segen erlangen.&lt;br/&gt;
15 Siehe, ich bin mit dir, ich behüte dich, wohin du auch gehst, und bringe dich zurück in dieses Land. Denn ich verlasse dich nicht, bis ich vollbringe, was ich dir versprochen habe.&lt;br/&gt;
16 Jakob erwachte aus seinem Schlaf und sagte: Wirklich, der HERR ist an diesem Ort und ich wusste es nicht.&lt;br/&gt;
17 Er fürchtete sich und sagte: Wie Ehrfurcht gebietend ist doch dieser Ort! Er ist nichts anderes als das Haus Gottes und das '''Tor des Himmels'''.&lt;br/&gt;
&lt;/blockquote&gt;

El war für die semitischen Ugariter im zweiten vorchristlichen Jahrtausend der Name ihres höchsten Gottes. Ihm wurden die Beinamen „König“, „Freundlicher“ und „'''Stier'''“ verliehen. Diese Symbolik weist auf den Himmelsstier hin. Der Name El wurde von den Israeliten übernommen, und dieser Gott wurde von ihnen mit ihrem einzigen Gott gleichgesetzt. Der Gott El wurde vom Gott Baal verdrängt, der ebenfalls mit Stierhörnern konnotiert war. Er wurde auch als donnernder und Blitze schleudernder Gott dargestellt, was sich in den Mythen des antiken Griechenlands in der Figur des höchsten griechischen Gottes Zeus (Jupiter) widerspiegelt. In diesem Zusammenhang sei auf noch weitere Parallelitäten den verschiedenen Götterkulturen hingewiesen, die sich zum ugaritischen Baal-Zyklus ergeben, der in den keilalphabetischen Texten aus Ugarit (KTU) zu finden ist. Am Schluss dieses Werkes wird die kanaanitische Sonnengöttin Šapšu, die Zweitfrau von El, für die Wiederherstellung und Bewahrung der kosmischen Ordnung zu einem Opfermahl eingeladen, bei der ihr '''Brot und Wein''' dargeboten werden.&lt;ref&gt;Herbert Niehr: ''Der Ba‘al-Zyklus (KTU 1.1-6 + 1.8)'', Gütersloh 2015, S. 236.&lt;/ref&gt; In Psalm&amp;nbsp;65 mit dem Titel &quot;Lobpreis auf den Retter und Schöpfer&quot; werden dem Gott der Israeliten ganz ähnliche Wohltaten zugeschrieben, wie dem Gott Baal in der ugaritischen Religion.

Jakob war der der erste der drei Erzväter des Volkes Israel und der älteste Sohn des ältesten Sohnes Isaak von Abraham. Abraham war aus dem mesopotamischen Ur über Haran nach Bet-El gezogen, und Jakob ging in dieser Schilderung aus Beerscheba in der Nähe des Ortes Bet-El nach Haran zurück.

Der Apostel Paulus schreibt in seinem zweiten Brief an die Bewohner der griechischen Hafenstadt Korinth zu Beginn des 5.&amp;nbsp;Kapitels mit der Überschrift &quot;Die Hoffnung des Apostels&quot; über das Gebäude hinter der Pforte zum Himmel:

&lt;blockquote&gt;
1 Wir wissen: Wenn unser irdisches Zelt abgebrochen wird, dann haben wir eine Wohnung von Gott, ein nicht von Menschenhand errichtetes '''ewiges Haus im Himmel'''.
&lt;/blockquote&gt;

=== Gedanken zur wundersamen Brotvermehrung ===
==== Evangelien ====
[[Datei:Face de chapiteau figurant la Multiplication des pains, choeur de l'église de Saint-Nectaire, Puy-de-Dôme.jpg|mini|rechts|hochkant=2|Jesus mit vier seiner Jünger mit fünf Broten und zwei Fischen an einem Säulenkapitell in der romanischen Wallfahrtskirche Saint Nectaire auf dem Mont Cornadore in Saint-Nectaire in Frankreich (Département Puy-de-Dôme in der Region Auvergne-Rhône-Alpes).]]

Die wundersame Speisung der mehreren Tausend mit wenigen Broten und Fischen wird in aller vier Evangelien der Bibel erwähnt. Das Ereignis fand auf einem Berg am Ufer des Sees von Galiläa (auch als &quot;See von Tiberias&quot;, &quot;See Genezareth&quot; oder &quot;Galiläisches Meer&quot; bekannt) statt. In der abgelegenen Gegend gab es damals sehr wenig künstliche Lichtquellen, so dass ein ungestörter Anblick des Sternenhimmels möglich war.

===== Evangelium nach Johannes =====
Im sechsten Kapitel des Evangeliums nach '''Johannes''' tauchen bei der Beschreibung der Brotvermehrung durch Jesus zum jüdischen Pessachfest neben einigen weiteren Symbolen mit astronomischer Deutungsmöglichkeit auch die expliziten Zahlen Zwei, Fünf und Zwölf auf:

&lt;blockquote&gt;
9 Hier ist ein kleiner Junge, der hat '''fünf Gerstenbrote''' und '''zwei Fische'''; doch was ist das für so viele?&lt;br/&gt;
10 Jesus sagte: Lasst die Leute sich setzen! Es gab dort nämlich viel Gras. Da setzten sie sich; es waren etwa '''fünftausend''' Männer.&lt;br/&gt;
11 Dann nahm Jesus die '''Brote''', sprach das Dankgebet und teilte an die Leute aus, so viel sie wollten; ebenso machte er es mit den '''Fischen'''.&lt;br/&gt;
12 Als die Menge satt geworden war, sagte er zu seinen Jüngern: Sammelt die übrig gebliebenen Brocken, damit nichts verdirbt!&lt;br/&gt;
13 Sie sammelten und füllten '''zwölf Körbe''' mit den Brocken, die von den '''fünf Gerstenbroten''' nach dem Essen übrig waren.&lt;br/&gt;
...&lt;br/&gt;
31 Unsere Väter haben das '''Manna''' in der Wüste gegessen, wie es in der Schrift heißt: '''Brot vom Himmel''' gab er ihnen zu essen.&lt;br/&gt;
32 Jesus sagte zu ihnen: Amen, amen, ich sage euch: Nicht Mose hat euch das '''Brot vom Himmel''' gegeben, sondern mein Vater gibt euch das wahre '''Brot vom Himmel'''.&lt;br/&gt;
33 Denn das '''Brot''', das Gott gibt, kommt vom '''Himmel''' herab und gibt der Welt das Leben.&lt;br/&gt;
34 Da baten sie ihn: Herr, gib uns immer dieses '''Brot'''!&lt;br/&gt;
35 Jesus antwortete ihnen: Ich bin das '''Brot des Lebens'''; wer zu mir kommt, wird nie mehr hungern, und wer an mich glaubt, wird nie mehr Durst haben.&lt;br/&gt;
...&lt;br/&gt;
48 Ich bin das '''Brot des Lebens'''.&lt;br/&gt;
49 Eure Väter haben in der Wüste das '''Manna''' gegessen und sind gestorben.&lt;br/&gt;
50 So aber ist es mit dem '''Brot''', das vom '''Himmel''' herabkommt: Wenn jemand davon isst, wird er nicht sterben.&lt;br/&gt;
51 Ich bin das '''lebendige Brot''', das vom '''Himmel''' herabgekommen ist. Wer von diesem '''Brot''' isst, wird in Ewigkeit leben. Das '''Brot''', das ich geben werde, ist mein Fleisch für das Leben der Welt.
&lt;/blockquote&gt;

===== Evangelium nach Markus =====
Eine ähnliche Schilderung befindet sich im sechsten Kapitel des Evangeliums nach '''Markus''', wo das Ereignis an einem abgelegenen und einsamen Ort stattgefunden hat:

&lt;blockquote&gt;
38 Er sagte zu ihnen: Wie viele '''Brote''' habt ihr? Geht und seht nach! Sie sahen nach und berichteten: '''Fünf Brote''' und außerdem '''zwei Fische'''.&lt;br/&gt;
39 Dann befahl er ihnen, sie sollten sich in Mahlgemeinschaften im grünen Gras lagern.&lt;br/&gt;
40 Und sie ließen sich in Gruppen zu hundert und zu fünfzig nieder.&lt;br/&gt;
41 Darauf nahm er die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis, brach die '''Brote''' und gab sie den Jüngern, damit sie diese an die Leute austeilten. Auch die '''zwei Fische''' ließ er unter allen verteilen.&lt;br/&gt;
42 Und alle aßen und wurden satt.&lt;br/&gt;
43 Und sie hoben Brocken auf, '''zwölf Körbe''' voll, und Reste von den '''Fischen'''.&lt;br/&gt;
44 Es waren '''fünftausend''' Männer, die von den '''Broten''' gegessen hatten.
&lt;/blockquote&gt;

Die Brotvermehrung auch ein weiteres Mal im achten Kapitel des Evangeliums nach '''Markus''' erwähnt:

&lt;blockquote&gt;
5 Er fragte sie: Wie viele '''Brote''' habt ihr? Sie antworteten: '''Sieben'''.&lt;br/&gt;
6 Da forderte er die Leute auf, sich auf den Boden zu setzen. Dann nahm er die sieben '''Brote''', sprach das Dankgebet, brach die '''Brote''' und gab sie seinen Jüngern zum Verteilen; und die Jünger teilten sie an die Leute aus.&lt;br/&gt;
7 Sie hatten auch noch ein paar '''Fische''' bei sich. Jesus segnete sie und ließ auch sie austeilen.&lt;br/&gt;
8 Die Leute aßen und wurden satt. Und sie hoben die Überreste der '''Brotstücke''' auf, '''sieben Körbe''' voll.&lt;br/&gt;
9 Es waren etwa '''viertausend''' Menschen beisammen. Danach schickte er sie nach Hause.&lt;br/&gt;
...&lt;br/&gt;
19 Als ich die '''fünf Brote''' für die '''Fünftausend''' brach, wie viele '''Körbe voll Brotstücke''' habt ihr da aufgehoben? Sie antworteten ihm: '''Zwölf'''.&lt;br/&gt;
20 Und als ich die '''sieben Brote''' für die '''Viertausend''' brach, wie viele '''Körbe''' voll habt ihr da aufgehoben? Sie antworteten: '''Sieben'''.&lt;br/&gt;
21 Da sagte er zu ihnen: Versteht ihr immer noch nicht?
&lt;/blockquote&gt;

===== Evangelium nach Lukas =====
Ebenso verhält es sich im neunten Kapitel des Evangeliums nach '''Lukas''', wo das Ereignis dem Ort Betsaida (zu Deutsch: „Haus des Fisches“) am See Genezareth zugeordnet ist:

&lt;blockquote&gt;
12 Als der Tag zur Neige ging, kamen '''die Zwölf''' und sagten zu ihm: Schick die Leute weg, damit sie in die umliegenden Dörfer und Gehöfte gehen, dort Unterkunft finden und etwas zu essen bekommen; denn wir sind hier an einem abgelegenen Ort.&lt;br/&gt;
13 Er antwortete ihnen: Gebt ihr ihnen zu essen! Sie sagten: Wir haben nicht mehr als '''fünf Brote''' und '''zwei Fische'''; wir müssten erst weggehen und für dieses ganze Volk etwas zu essen kaufen.&lt;br/&gt;
14 Es waren nämlich etwa '''fünftausend''' Männer. Er aber sagte zu seinen Jüngern: Lasst sie sich in Gruppen zu ungefähr fünfzig lagern!&lt;br/&gt;
15 Die Jünger taten so und veranlassten, dass sich alle lagerten.&lt;br/&gt;
16 Jesus aber nahm die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis und brach sie; dann gab er sie den Jüngern, damit sie diese an die Leute austeilten.&lt;br/&gt;
17 Und alle aßen und wurden satt. Als man die übrig gebliebenen Brotstücke einsammelte, waren es '''zwölf Körbe''' voll.
&lt;/blockquote&gt;

===== Evangelium nach Matthäus =====
Auch im vierzehnten Kapitel des Evangeliums nach '''Matthäus''' ist von einem abgelegenen Ort in einer einsamen Gegend die Rede:

&lt;blockquote&gt;
17 Sie sagten zu ihm: Wir haben nur '''fünf Brote''' und '''zwei Fische''' hier.&lt;br/&gt;
18 Er antwortete: Bringt sie mir her!&lt;br/&gt;
19 Dann ordnete er an, die Leute sollten sich ins Gras setzen. Und er nahm die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis, brach die Brote und gab sie den Jüngern; die Jünger aber gaben sie den Leuten&lt;br/&gt;
20 und alle aßen und wurden satt. Und sie sammelten die übrig gebliebenen Brotstücke ein, '''zwölf Körbe''' voll.&lt;br/&gt;
21 Es waren etwa '''fünftausend''' Männer, die gegessen hatten, dazu noch Frauen und Kinder.
&lt;/blockquote&gt;

Etwas abgewandelt taucht die Brotvermehrung mit '''sieben Körben''' auch im fünfzehnten Kapitel des Evangeliums nach '''Matthäus''' auf:

&lt;blockquote&gt;
34 Jesus sagte zu ihnen: Wie viele '''Brote''' habt ihr? Sie antworteten: '''Sieben''' - und ein paar '''Fische'''.&lt;br/&gt;
35 Da forderte er die Leute auf, sich auf den Boden zu setzen.&lt;br/&gt;
36 Und er nahm die '''sieben Brote''' und die '''Fische''', sprach das Dankgebet, brach sie und gab sie den Jüngern und die Jünger gaben sie den Menschen.&lt;br/&gt;
37 Und alle aßen und wurden satt. Und sie sammelten die übrig gebliebenen Stücke ein, '''sieben Körbe''' voll.&lt;br/&gt;
38 Es waren '''viertausend''' Männer, die gegessen hatten, dazu noch Frauen und Kinder.&lt;br/&gt;
39 Danach schickte er die Menge nach Hause, stieg ins Boot und fuhr in die Gegend von Magadan.
&lt;/blockquote&gt;

Der Ort Magadan ist möglicherweise mit dem heutigen Ort Migdal (aramäisch: Magdala) am westlichen Ufer des Sees Genezareth gleichzusetzen.

==== Astronomische Bezüge ====
[[Datei:Sternenhimmel.Pessach.25.3.23.png|mini|rechts|hochkant=2|Sternenhimmel am jüdischen Pessachfest im Jahr 25 nach Christus. Der Vollmond stand hoch über dem Horizont im Süden im Herbstpunkt beim Stern Spica (= &quot;Kornähre&quot;) im Sternbild Jungfrau (Virgo). Gleichzeitig befand sich die Sonne tief unter dem Horizont im Norden in der Nähe des Frühlingspunktes im Sternbild Fische (Pisces).]]
[[Datei:Dendera.09.Jungfrau.Loewe.jpg|mini|rechts|hochkant=2|Das Sternbild Jungfrau (links) mit der Kornähre in der Hand und das Sternbild Löwe (rechts) im ägyptischen Zodiak von Dendera aus der Zeit kurz vor Christi Geburt.]]
[[Datei:Dendera.03.Fische.Wassermann.jpg|mini|rechts|hochkant=2|Das Sternbild Fische (links) und das Sternbild Wassermann (rechts unten) im ägyptischen Zodiak von Dendera aus der Zeit kurz vor Christi Geburt.]]

Zu diesen Bibelstellen sind im Folgenden einige Hinweise mit astronomischen Bezügen aufgeführt. Die [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|Bezugspunkte]] liegen hierbei in der Nähe der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Die_Ekliptik|Ekliptik]]:

* In den Versen im Evangelium nach Johannes ist mehrfach vom '''Brot, das vom Himmel herabkommt''' die Rede.
* Das zur Herstellung von Brot erforderliche Getreide kann durch eine '''Kornähre''' symbolisiert werden. Am Sternenhimmel wird die Kornähre durch den hellen, ekliptiknahen Stern '''Spica''' (α Virginis) im Sternbild '''Jungfrau''' (Virgo) repräsentiert. Der Vollmond stand zum jüdischen Pessachfest beim Stern Spica.
* Alle Pflanzen benötigen für das Gedeihen '''Wasser'''. Das '''Wasser''' wird am Himmel durch die drei Wassersternbilder der Ekliptik '''Fische''' (Pisces), '''Wassermann''' (Aquarius), und '''Ziegenfisch''' (Steinbock, Capricornus) westlich des [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Frühlingspunkt|Frühlingspunktes]] repräsentiert. Diese Sternbilder bilden mit einigen weiteren angrenzenden Wassersternbildern den [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|Urozean am Himmel]] (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Trichter_der_Thuraya|Der Trichter der Thuraya]]). Die Wassersternbilder waren zum Pessachfest in den drei Monaten unmittelbar zuvor von der Sonne durchlaufen worden und befanden sich beim Sonnenuntergang deshalb bereits unterhalb des westlichen Horizonts.
* Das Sternbild '''Fische''' (Pisces) besteht seit der Antike aus '''zwei Fischen'''.
* Zu Lebzeiten von Jesus von Nazareth war der '''Frühlingspunkt''' vom Sternbild Widder (Aries, ursprünglich das Hinterteil des großen Sternbilds [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|Himmelsstier (Taurus caeli)]]) in das Sternbild '''Fische''' (Pisces) gewandert. Inzwischen ist er innerhalb dieses Sternbilds noch weiter nach Westen gewandert. Die Sonne und der Neumond standen zu Beginn des jüdischen Monats Nisan, also dem Monat des jüdischen Pessachfestes, im Sternbild '''Fische'''. Der erste Monat des Jahres Nisan hieß bereits in der mesopotamischen Tradition, als sich der Frühlingspunkt noch im Sternbild Widder (Aries) befand, auf Akkadisch &quot;nisannu&quot; (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|Plejaden-Schaltregeln]]). In der alten jüdischen Tradition war der Nisan deswegen mit dem Sternbild Widder verbunden. Ferner wurde der Widder dem israelitischen Stamm Juda zugeordnet.
* Zu Lebzeiten von Jesus von Nazareth war der '''Herbstpunkt''' vom Sternbild Waage (Libra, ursprünglich die Scheren des großen Sternbilds [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsskorpion|Himmelsskorpion (Scorpio caeli)]]) in das Sternbild Jungfrau (Virgo) gewandert. Inzwischen ist er innerhalb dieses Sternbilds noch weiter nach Westen gewandert. Um 285 nach Christi erreichte der '''Herbstpunkt''' dann die ekliptikale Länge des Sterns '''Spica''' (α Virginis).
* Der '''Frühlingspunkt''' –&amp;nbsp;damals im Sternbild Fische&amp;nbsp;– und der '''Herbstpunkt''' –&amp;nbsp;damals im Sternbild Jungfrau (Virgo) beim Stern Spica&amp;nbsp;– befinden sich immer in genau gegenüber liegenden Punkten auf der Ekliptik. Auf diese Weise umfassen diese beiden ausgezeichneten Punkte den Lebewesenkreis (Zodiak) mit seinen '''zwölf''' Sternbildern sowie die Bahnen aller '''sieben''' Wandelgestirne. Diese beiden Punkte teilten die Ekliptik in '''zwei''' gleichgroße Teile, das Sommerhalbjahr und das Winterhalbjahr. Siehe hierzu auch &quot;[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|Beobachtungen in der Nähe der Ekliptik]]&quot;.
** Die '''fünf Brote''' können also mit den fünf mit bloßem Auge sichtbaren Wandelgestirnen (Planeten) '''Merkur''', '''Venus''', '''Mars''', '''Jupiter '''und '''Saturn''' gleichgesetzt werden.&lt;br/&gt;'''''Anmerkung''': In der Bibel wird in der Regel nicht zwischen Fixsternen und Planeten unterschieden. Für eine Ausnahme siehe 2.&amp;nbsp;Buch der Könige, Kapitel 23, Vers 5 aus dem siebenten vorchristlichen Jahrhundert, wo in der Einheitsübersetzung explizit von &quot;den Wandelsternen&quot; und in der Luther-Bibel von &quot;den Planeten&quot; die Rede ist.&lt;ref&gt;[https://www.bibleserver.com/EU/2.K%C3%B6nige23%2C5 2.&amp;nbsp;Buch der Könige, Kapitel 23, Vers 5], bibleserver.com, Einheitsübersetzung 2016&lt;/ref&gt; Die Vulgata schreibt hier allerdings von den &quot;duodecim signis&quot; (zu Deutsch: &quot;'''zwölf''' Zeichen&quot;), womit die '''zwölf''' Sternzeichen der Ekliptik gemeint sind, durch die die '''sieben''' Wandelgestirne ziehen. Die Septuaginta spricht noch allgemeiner von den &quot;μαζουρωθ&quot; (&quot;mazuroth&quot;) nach dem Hebräischen Wort &quot;מַזָּלָה&quot; (&quot;mazzaroth&quot;), womit allgemein eher Sternkonstellationen und nur im engeren Sinne die Sternzeichen des Zodiaks gemeint sind.''
** Die '''zwei Fische''' können also mit den beiden flächenhaft wahrnehmbaren Wandelgestirnen '''Sonne''' und '''Mond '''gleichgesetzt werden.
** Die Summe der '''fünf Brote''' und der '''zwei Fische''' respektive die '''sieben Brote''' (oder die '''sieben Körbe''') entsprechen der Anzahl der freiäugig sichtbaren '''sieben Wandelgestirne''', die sich entlang der Ekliptiklinie stetig gegenüber dem Fixsternhimmel bewegen. Siehe hierzu auch &quot;[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Zusammenhang_mit_dem_Stier|Zu den Etyma und den Kognaten von &quot;Sieben&quot;, &quot;Stier&quot;, &quot;Gestirn&quot; und &quot;Stern&quot;]]&quot;.
** Die ausgeteilten '''Brote''' und '''Fische''' durchmaßen die gesamte versammelte Menschenmenge, die durch den vollständigen [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|Lebewesenkreis (Zodiak)]] mit den '''zwölf Lebewesenkreiszeichen''' beziehungsweise durch die '''zwölf Körbe''' symbolisiert wird. Der Planet Jupiter, der den Zodiak in zwölf Jahren einmal durchläuft, wurde in Babylonien mit dem babylonischen Hauptgott Marduk gleichgesetzt.
* Insgesamt gibt es am Fixsternhimmel gut 2800&amp;nbsp;Sterne bis zur scheinbaren Helligkeit 5,5&lt;sup&gt;m&lt;/sup&gt; und knapp 8800&amp;nbsp;Sterne bis zur scheinbaren Helligkeit&amp;nbsp;6,5&lt;sup&gt;m&lt;/sup&gt;, die ohne Lichtverschmutzung mit bloßem Auge als einzelne Lichtpunkte gesehen werden können. Diese verteilen sich allerdings in der gesamten Himmelssphäre, so dass von einem Punkt auf der Erdoberfläche aus zu jedem Zeitpunkt immer nur ungefähr die Hälfte davon über dem Horizont steht. An den beiden Polen sind stets nur die Sterne der jeweiligen nördlichen oder südlichen Hemisphäre zu sehen, und am Äquator können im Laufe eines Jahres alle Sterne gesehen werden. Je nach Breitengrad und Zeitpunkt können bei Neumond (kein Streulicht) innerhalb einer wolkenlosen Nacht viertausend bis zu fast siebentausend Sterne beobachtet werden.&lt;ref&gt;Bob King: [https://skyandtelescope.org/astronomy-blogs/how-many-stars-night-sky-09172014/ 9,096 Stars in the Sky—Is that all? How many stars in the sky can you see?], skyandtelescope.org - The essential Guide to Astronomy, 17. September 2014&lt;/ref&gt; Diese Spanne entspricht der Angabe der bei der Brotvermehrung versammelten Menschen, deren Anzahl in den Evangelien mit '''viertausend''' beziehungsweise '''fünftausend''' angegeben ist.
** Im ersten Buch des Alten Testaments ('''Genesis''') wird Abram aus Ur in Mesopotamien bereits das Folgende prophezeit:
&lt;blockquote&gt;
15,5 ''Sieh doch zum Himmel hinauf und zähl die Sterne, wenn du sie zählen kannst! Und er sprach zu ihm: So zahlreich werden deine Nachkommen sein''&lt;br/&gt;
...&lt;br/&gt;
17,5 ''Man wird dich nicht mehr Abram nennen. Abraham, Vater der Menge, wird dein Name sein; denn zum Stammvater einer Menge von Völkern habe ich dich bestimmt.''
&lt;/blockquote&gt;
* Die Gruppen von (ungefähr) '''fünfzig''' oder '''hundert Männern''' entsprechen den Sternbildern, die über den gesamten Himmel verteilt sind. Nach der Festlegung der Internationalen Astronomischen Union (IAU) von 1930 gibt es heute 88&amp;nbsp;Sternbilder, die den Himmel vollständig abdecken. Mit den maximal fast 8800&amp;nbsp;freiäugig sichtbaren Sternen entspricht dies im Mittel also 100&amp;nbsp;Sternen pro Sternbild. Bei 4400&amp;nbsp;freiäugig sichtbaren Sternen wären es 50&amp;nbsp;Sterne pro Sternbild. Dies entspricht genau der Spanne der Gruppenstärke, die im Neuen Testament angegeben sind.
* Das '''Brot''' und der '''Wein''' werden nach der christlichen Lehre bei der Transsubstantiation in den Leib und das Blut des vom '''Himmel''' herabgekommenen &quot;Brot des Lebens&quot; (vergleiche die Rede über das Himmelsbrot von Jesus in der Synagoge von Kafarnaum in Evangelium nach Johannes 6,48–58) gewandelt, das die kosmische Ewigkeit verheißt.

Die Zahlen '''Zwei''', '''Fünf''', '''Sieben''' und '''Zwölf''' stehen in einem einfachen arithmetischen Zusammenhang, bei dem die beiden jeweils vorhergehenden Zahlen der Folge addiert werden:

{| class=&quot;wikitable&quot;
|+
|'''Zahl'''
|'''Summe'''
|'''Anmerkung'''
|-
|'''2'''
|
|Anzahl der freiäugig als '''flächenhaft wahrnehmbaren Wandelgestirne''' ('''Sonne''' und '''Mond'''), siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwei|Zur Zwei]]
|-
|'''5'''
|
|Anzahl der freiäugig als '''punktförmig wahrnehmbaren Wandelgestirne''' '''Merkur''', '''Venus''', '''Mars''', '''Jupiter''', '''Saturn'''
|-
|'''7'''
|= 2 + 5
|Anzahl der freiäugig wahrnehmbaren '''Wandelgestirne''' sowie der '''Tage in der Woche''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Sieben|Zur Sieben]]
|-
|'''12'''
|= 5 + 7
|Anzahl der '''Monate im Jahr''', der '''Lebewesenkreiszeichen des Zodiaks''' sowie der '''Erdenjahre pro Jupiterjahr''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwölf|Zur Zwölf]], vergleiche hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|Der Zodiak]]
|-
|'''19'''
|= 7 + 12
|Anzahl der '''Jahre''' mit '''zwölf Monaten''' und '''sieben Schaltmonaten''' einer '''Meton-Periode''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Neunzehn|Zur Neunzehn]], vergleiche hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|Die Plejaden-Schaltregeln]] und [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Mondzyklen#Der_Meton-Zyklus|Der Meton-Zyklus]]
|}

=== Weitere Bezüge ===
Weitere Bezüge von der Astronomie zur Theologie ergeben sich bei den folgenden Sachverhalten:

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Biblische_Erwähnungen|'''biblische Erwähnungen von Konstellationen''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Der_Stern_von_Bethlehem|'''Der Stern von Bethlehem''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Ochs_und_Esel|'''Ochs und Esel / Krippe / „Ich bin das Alpha und das Omega“''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Biblische_Bezüge|'''Biblische Bezüge zu den Mondhäusern / Mondstationen''']].

== Zur Kosmologie ==
[[Datei:Kosmologisches.Modell.Schwarze.Schale.Rotverschiebung.png|mini|rechts|hochkant=2.5|Ein kosmologisches Modell unseres im Zentrum isotropen und inhomogenen Universums, das von einer undurchsichtigen und massereichen schwarzen Kugelschale umgeben ist. Von der äußeren Region aus betrachtet, ist unser Universum ein gigantisches Schwarzes Loch. Zwischen dem inneren und dem äußeren Bereich der schwarzen Kugelschale ist kein Informationsaustausch möglich. Jegliche Materie, die von innen oder außen in die schwarze Kugelschale gelangt, ist von innen und von außen nicht mehr sichtbar. Sowohl die innere als auch die äußere Grenze der schwarzen Kugelschale stellen demzufolge einen Ereignishorizont dar.]]

Die '''Kosmologie''' beschäftigt sich mit der Struktur, dem Ursprung und der Entwicklung des Universums. Dadurch ergeben sich zahlreiche Bezüge zur beobachtenden '''Astronomie''' und zur '''Astrophysik''', aber auch zur '''Quantenphysik'''.

In der Antike gingen die Menschen noch davon aus, dass sich die Erde im Mittelpunkt der Welt und somit auch in der Mitte des sichtbaren Universums befindet. Dieses geozentrische Weltbild wurde seit dem 16.&amp;nbsp;Jahrhundert, ausgelöst durch die kopernikanische Wende, zunehmend verworfen und durch ein heliozentrisches Weltbild ersetzt. Durch die Erfindung und Verwendung von Fernrohren konnten seit dem Beginn des 17.&amp;nbsp;Jahrhunderts immer mehr Details im Sternenhimmel entdeckt werden. Durch astronomische Beobachtungen ergaben sich immer mehr Indizien für die Tatsache, dass die Erde einmal pro Jahr auf einer Ellipsenbahn die Sonne umrundet und nicht die Sonne die Erde umkreist. Der Philosoph Immanuel Kant (1724–1804) erkannte bereits 1755 in seiner Allgemeinen Naturgeschichte und Theorie des Himmels das innere Wesen unserer Milchstraße. Mit der ersten zuverlässigen Messung der Parallaxe von unserer Erde zum benachbarten Fixstern 61&amp;nbsp;Cygni (&quot;Bessel's Stern&quot;) durch Friedrich Wilhelm Bessel (1784–1846) in Königsberg und der daraus folgenden Berechnung von dessen Entfernung von gut zehn Lichtjahren im Jahr 1838 war die Tatsache, dass die Erde um die Sonne läuft, endgültig bewiesen.

Die Auswertung der astronomischen Beobachtungen hat zu der heute allgemein geteilten Auffassung geführt, dass unser Universum bei einem Urknall entstanden ist und seitdem expandiert. Die Berücksichtigung des Äquivalenzprinzips zwischen schwerer und träger Masse, das zu der von '''Albert Einstein''' (1879–1955) formulierten Allgemeinen Relativitätstheorie führt, brachte '''Alexander Friedmann''' (1888–1925) 1922 zu der theoretischen Vorhersage eines dynamischen Universums. Fünf Jahre später schlussfolgerte der belgische Astronom '''Georges Lemaître''' (1894–1966) aus den von '''Vesto Slipher''' (1875–1969) beobachteten Rotverschiebungen von fernen Galaxien und den von '''Edwin Hubble''' (1889–1953) ermittelten Entfernungen dieser Galaxien, dass das Universum expandiert. Aufgrund dieser Erkenntnis ergibt sich, dass das Universum einen Ursprung mit sehr kleinem Radius gehabt haben muss. Diesen Zustand nannte er &quot;primordiales Atom&quot; beziehungsweise &quot;Uratom&quot;. In der Folgezeit etablierte sich für diesen initialen Vorgang der Begriff &quot;'''Urknall'''&quot; (im Englischen: &quot;'''Big Bang'''&quot;).&lt;ref&gt;Markus Bautsch: ''[https://en.wikibooks.org/wiki/Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell/Brief_historical_review Moving objects in retarded gravitational potentials of an expanding spherical shell / Brief historical review], Wikibook (englisch), 2024, abgerufen am 28. Februar 2026&lt;/ref&gt;

Viele Astrophysiker versuchen heute mit dem sogenannten '''Standardmodell der Kosmologie''' (auch '''ΛCDM-Modell''' beziehungsweise Lambda-CDM-Modell, wobei &quot;CDM&quot; für &quot;cold dark matter&quot; steht, also für &quot;kalte, dunkle Materie&quot;) die Entwicklung des Universums nachzubilden. Hierfür wenden sie das kosmologische Prinzip an, das von zwei grundlegenden Annahmen ausgeht:&lt;ref&gt;Markus Bautsch: ''[https://en.wikibooks.org/wiki/Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell/Preface Moving objects in retarded gravitational potentials of an expanding spherical shell / Preface], Wikibook (englisch), 2024, abgerufen am 28. Februar 2026&lt;/ref&gt;

# Das Weltall sei '''homogen''', was bedeutet, dass es in groben Zügen von jedem Punkt aus gleich aussieht.
# Das Weltall sei '''isotrop''', was besagt, dass es in groben Zügen in jede Richtung gleich aussieht.

Mit diesen Annahmen kann das Modell berechnet werden, und mit diversen zusätzlichen Annahmen stimmt es in vielerlei Hinsicht mit den astronomischen Beobachtungen überein. Zu den zusätzlichen Annahmen gehören die folgenden beiden hypothetischen Größen:

* '''Kalte, dunkle Materie''', die zwar der Gravitation unterläge, aber keine Wechselwirkung mit elektromagnetischer Strahlung zeigt.
* Eine '''kosmologische Konstante''' Λ, die eine '''dunkle Energie''' beschreibt und für die beschleunigte Expansion des Universums verantwortlich sei.

Weder für die Homogenität noch für die Isotropie des Kosmos konnten bislang Belege gefunden werden, und auch für die kalte dunkle Materie und die dunkle Energie konnte bislang keine physikalische Interpretation geliefert werden.

Ferner ist auch die Annahme, dass die Naturkonstanten unveränderliche Werte haben, nicht begründbar. Auf kosmischen Zeitskalen kann es durchaus Änderungen geben, die wir derzeit nicht messen können. Die gilt insbesondere für die Hubble-Konstante, die die Expansionsrate des Universums beschreibt, für die Gravitationskonstante, die die Anziehung zweier Massen beschreibt, oder für die kosmologische Konstante, die die beschleunigte Expansion des Universums beschreibt. In diesem Kontext sei darauf hingewiesen, dass unser Universum genauso groß ist wie ein Schwarzes Loch mit der Masse unseres Universums. Deshalb gehen einige Kosmologen davon aus, dass wir innerhalb eines Schwarzen Loches der Größe und Masse unseres Universums leben könnten.

Siehe hierzu auch: [[:en:Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell|'''Moving objects in retarded gravitational potentials of an expanding spherical shell''']].

Darüber hinaus mehren sich Anzeichen und Hinweise, die gegen die Ergebnisse des Standardmodells der Kosmologie sprechen, beziehungsweise durch weitere Hypothesen, die physikalisch nicht begründet werden können, im Standardmodell berücksichtigt werden müssen. Die folgende unvollständige Liste soll hierzu einige Anhaltspunkte liefern:

* Präzise astronomische Beobachtungen zeigen, dass das Weltall auch auf großen Längenskalen '''nicht homogen''' ist, sondern Strukturen zeigt.
* Präzise astronomische Beobachtungen zeigen, dass das Weltall auch auf großen Längenskalen '''nicht isotrop''' ist (Asymmetrie der kosmischen Hintergrundstrahlung).
* Die Hubble-Konstante hat heute einen anderen Wert als früher (&quot;'''Hubble tension'''&quot;), was mit dem Standardmodell nicht im Einklang steht.
* Das beobachtete Vorkommen des dritten Elements im Periodensystem, also des Alkalimetalls '''Lithium''', ist mindestens dreimal geringer als vom Standardmodell vorhergesagt.
* Die '''Rotverschiebung von fernen Galaxien''' ist deutlich größer als es nach dem Standardmodell möglich wäre.
* Die beobachteten '''Rotationskurven von Spiralgalaxien''' stehen im Widerspruch zu den Ergebnissen des Standardmodells.
* Das Standardmodell ist nicht in der Lage, die Abwesenheit von '''Antimaterie''' im sichtbaren Teil des Universums zu erklären.
* Die im frühen Universum beobachteten '''primordialen Schwarzen Löcher und Galaxien''' mit explodierende '''Supernovae''' sowie dem Vorkommen von '''Sauerstoff''' stehen im Widerspruch zu den Ergebnissen des Standardmodells.

== Zur Astrologie ==
Eine Sonderstellung nimmt die '''{{w|Astrologie}}''' (zusammengesetzt mit dem altgriechischen ἄστρον (&quot;astron&quot;), zu Deutsch „Sternenlehre“) ein. Sie ist ein weiteres Beispiel für eine Disziplin, bei der grundlegende Kenntnisse über die Astronomie eine Voraussetzung sind. Sie versucht, Zusammenhänge zwischen den Konstellationen der Wandelgestirne oder astronomischen Ereignissen am Sternenhimmel mit irdischen Geschehnissen oder Veränderungen herzustellen, insbesondere was bestimmte Konjunktionen und daraus abgeleitete Prophezeiungen betrifft. Sie wurde bereits in Mesopotamien und in anderen alten Kulturkreisen von Astronomen ausgeübt. Noch der Astronom '''{{w|Johannes Kepler}}''' (1571–1630) hat als einer der letzten Astronomen einen wesentlichen Teil seiner Einkünfte durch die Erstellung von Horoskopen bestritten. Aber schon Aristoteles hatte festgestellt und beschrieben, dass die bei bestimmten Konstellationen am Himmel vorhergesagten Ereignisse nicht eingetreten waren.

Vor der Aufklärung haben astrologische Prophezeiungen noch eine große und weitreichende gesellschaftliche Bedeutung gehabt. Als Beispiel seien die Behauptungen des ersten im Kurfürstentum Brandenburg tätigen Astrologen '''{{w|Johannes Carion}}''' (1499–1537) genannt, der für 1524 eine Sintflut vorhersagte, die nicht eingetroffen ist.&lt;ref&gt;{{Literatur |Autor=Markus Bautsch, Friedhelm Pedde |Titel=Vor 500 Jahren: Die Sintflut von 1524 die nicht stattfand |Online=https://wfs.berlin/wp-content/uploads/2024/05/A19-BROplanetA4_40s-feb2024ff_www-rz.pdf |Sammelwerk=Dem Himmel nahe. |WerkErg=Mitteilungen der Wilhelm-Foerster-Sternwarte e.V.|Nummer=19 |Hrsg=Wilhelm-Foerster-Sternwarte e.V. / Zeiss-Planetarium am Insulaner |Ort=Berlin |Datum=2024-02 |Seiten=16–19 |Sprache=de |Abruf=2025-08-03|ISSN=2940-9330}}&lt;/ref&gt; Der Wiener Hofastronom '''{{w|Georg Tannstetter}}''' (1482–1535) sah sich 1523 bemüßigt, die schon lange im Voraus erhitzten und besorgten Gemüter zu beruhigen:&lt;ref&gt;Georg Tannstetter: ''Libellus consolatorius contra opiniones de diluvio et aliis horrendis periculis anni 1523''&lt;/ref&gt;

&lt;blockquote&gt;
Nun hat sich überall, in allen Köpfen, in allen Seelen das Gerücht eingeschlichen:&lt;br/&gt;
die Gelehrten und Weisen sind in ständigem Streitgespräch, andere hingegen sind derart verstört, dass sie ihren Geschäften nicht mehr nachgehen können; sie verkaufen ihre Anwesen, ihre Felder und Besitztümer oder lassen davon ab, Güter zu kaufen, in der Hoffnung, ihr Geld leichter in die sicheren Berge transportieren zu können. Andere wiederum verschieben ihr Heiratsversprechen, kündigen ohne scheinbaren Grund Verträge auf, entziehen sich ihren christlichen Gelübden, arbeiten faul und missmutig auf dem Land und fragen sich, was es denn nütze, Geld und Gut anzuhäufen, wenn doch in kürzester Zeit niemand mehr davon Nutzen ziehen könne.
&lt;/blockquote&gt;

'''→ Siehe auch:'''

* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Definition|'''Konjunktionen''', Abschnitt '''Definition''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Historische_Konjunktionen|'''Historische Konjunktionen''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|'''Beobachtungen in der Nähe der Ekliptik''']].
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

== Einzelnachweise ==
&lt;references&gt;&lt;/references&gt;</text>
      <sha1>2g746kk3u2vc8578nij7uh5v2k07gxo</sha1>
    </revision>
    <revision>
      <id>1088608</id>
      <parentid>1088606</parentid>
      <timestamp>2026-07-04T11:19:10Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <comment>/* Himmelspforte */ Ps. 65</comment>
      <origin>1088608</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="89642" sha1="k8q9al4lrd63iezzssltmtk8jg4f8g8" xml:space="preserve">Viele Bezeichnungen für verschiedene Lehren werden mit der aus dem Altgriechischen stammenden Endung &quot;-logie&quot; (altgriechisch λόγος (&quot;logos&quot;), zu Deutsch „Lehre“) gebildet. Die folgenden Disziplinen sind in diesem Kontext hervorzuheben, da sie insbesondere für die '''{{w|Archäoastronomie}}''' wertvolle wissenschaftliche Ergänzungen zur '''{{w|Astronomie}}''' (aus den altgriechischen Wörtern ἄστρον (&quot;ástron&quot;, zu Deutsch „Stern“) und νόμος (&quot;nómos, zu Deutsch „Gesetz“) zusammengesetzt also „Sterngesetz“) liefern:

* Die '''{{w|Archäologie}}''' (zusammengesetzt mit dem altgriechischen Wort ἀρχαῖος (&quot;archaios&quot;), zu Deutsch „Altertumslehre“) beschäftigt sich mit der kulturellen Entwicklung der Menschheit.
* Die '''{{w|Etymologie}}''' (zusammengesetzt mit dem altgriechischen Wort ἔτυμος (&quot;etymos&quot;), zu Deutsch „Wortherkunftslehre“) untersucht die geschichtliche Herkunft von Wörtern.
* Die '''{{w|Mythologie}}''' (zusammengesetzt mit dem altgriechischen Wort μῦθος (&quot;mythos&quot;), zu Deutsch „Erzählungslehre“), die sich wissenschaftlich mit der Sagenwelt beschäftigt.
* Die '''{{w|Theologie}}''' (zusammengesetzt mit dem altgriechischen Wort θεός (&quot;theós&quot;), zu Deutsch „Gotteslehre“) mit ihren Lehren zum religiösen Glauben und dessen Glaubensdokumenten.
* Die '''{{w|Kosmologie}}''' (zusammengesetzt mit dem altgriechischen Wort κόσμος (&quot;kósmos&quot;), zu Deutsch „Weltenlehre“) ist hingegen eine Lehre, die sich im Laufe der Jahrtausende deutlich verändert hat und sich auch heute noch erheblich weiterentwickelt, da es in der modernen Astronomie und Astrophysik mit zunehmend hohem technischem Aufwand immer wieder zu neuen Erkenntnissen kommt.
* Die '''{{w|Numerologie}}''' (zusammengesetzt mit dem lateinischen Wort numerus, zu Deutsch „Zahlenlehre“) mit ihren mystischen Lehren über die symbolische Zuweisung von Bedeutungen an Zahlen.

Von der Antike bis ins Mittelalter galt die Beherrschung der '''{{w|sieben freien Künste}}''' als Voraussetzung für das Betreiben von Philosophie. Zu den drei &quot;trivialen&quot; Künsten der {{w|Grammatik}}, der {{w|Rhetorik}} und der {{w|Dialektik}} des '''{{w|Trivium|Triviums}}''' wurden die vier Künste der {{w|Musiktheorie}}, der {{w|Arithmetik}}, der {{w|Geometrie}} und der {{w|Astronomie}} zu den Künsten des '''{{w|Quadrivium|Quadriviums}}''' gezählt → siehe hierzu auch [[Quadriviale_Kuriositäten|'''Wikibook ''Quadriviale Kuriositäten''''']].

== Zur Etymologie ==
Die Genesis aus dem Alten Testament greift die Thematik der Verwirrung der einheitlichen Sprache in ihrem elften Kapitel auf, und beschreibt, wie die bereits sternenkundigen Menschen im Norden Mesopotamiens übermütig geworden waren und in Babel einen Turm mit einer Spitze '''bis in den Himmel''' errichten wollten:&lt;ref&gt;[https://www.bibleserver.com/EU/1.Mose11 Genesis 11], Genesis, Kapitel 11, Einheitsübersetzung&lt;/ref&gt;

&lt;blockquote&gt;
1 Die ganze Erde hatte eine Sprache und ein und dieselben Worte.&lt;br/&gt;
2 Als sie ostwärts aufbrachen, fanden sie eine Ebene im Land Schinar und siedelten sich dort an.&lt;br/&gt;
3 Sie sagten zueinander: Auf, formen wir Lehmziegel und brennen wir sie zu Backsteinen. So dienten ihnen gebrannte Ziegel als Steine und Erdpech als Mörtel.&lt;br/&gt;
4 Dann sagten sie: Auf, bauen wir uns eine Stadt und einen Turm mit einer Spitze '''bis in den Himmel'''! So wollen wir uns einen Namen machen, damit wir uns nicht über die ganze Erde zerstreuen.&lt;br/&gt;
5 Da stieg der HERR herab, um sich Stadt und Turm anzusehen, die die Menschenkinder bauten.&lt;br/&gt;
6 Und der HERR sprach: Siehe, ein Volk sind sie und eine Sprache haben sie alle. Und das ist erst der Anfang ihres Tuns. Jetzt wird ihnen nichts mehr unerreichbar sein, wenn sie es sich zu tun vornehmen.&lt;br/&gt;
7 Auf, steigen wir hinab und verwirren wir dort ihre Sprache, sodass keiner mehr die Sprache des anderen versteht.&lt;br/&gt;
8 Der HERR zerstreute sie von dort aus über die ganze Erde und sie hörten auf, an der Stadt zu bauen.&lt;br/&gt;
9 Darum gab man der Stadt den Namen Babel, Wirrsal, denn dort hat der HERR die Sprache der ganzen Erde verwirrt und von dort aus hat er die Menschen über die ganze Erde zerstreut.
&lt;/blockquote&gt;

Es mag weniger verwunderlich sein, dass Schöpfungsmythen oder Berichte über Katastrophen nicht nur einen astronomischen Hintergrund haben, sondern in völlig verschiedenen Kulturen sehr ähnliche Merkmale zeigen, wenn man sich das Folgende bewusst macht: Einige Indizien deuten auf einen für viele Kulturen gemeinsamen Ursprung hin, der auf eine tiefsinnige Betrachtung und Beobachtung des Himmelsgeschehens hindeutet.

Bei bestimmten Wörtern sind die Ähnlichkeiten in vielen lebenden und toten Sprachen so auffällig, dass sie ein gemeinsames Ursprungswort (Etymon) haben und somit Kognaten sein dürften. 

=== &quot;Stern&quot; ===
Bei den Wörtern „Gestirn“ beziehungsweise „Stern“ sind die Ähnlichkeiten in vielen lebenden und toten Sprachen sehr auffällig, und diese Verwandtschaften mögen durch die Wörter für &quot;Stern&quot; in den folgenden Sprachen belegt werden:

* Akkadisch &quot;istar&quot;
* Indogermanisch &quot;ster&quot;
* Griechisch &quot;astro&quot; / &quot;asteri&quot;
* Lateinisch &quot;astrum&quot; / &quot;stella&quot;
* Althochdeutsch &quot;stern(o)&quot;
* Jiddisch &quot;shtern&quot;
* Katalanisch und Spanisch &quot;estrella&quot;
* Portugiesisch &quot;estrela&quot;
* Englisch &quot;star&quot;
* Niederländisch &quot;ster&quot;
* Westfriesisch &quot;stjer&quot;
* Italienisch und Korsisch &quot;stella&quot;
* Rumänisch &quot;stea&quot;
* Sardisch &quot;istedda&quot;
* Maltesisch &quot;stilla&quot;
* Französisch &quot;étoile&quot; aus Altfranzösisch &quot;estoile&quot;
* Galicisch &quot;estrela&quot;
* Walisisch &quot;seren&quot;
* Dänisch und Norwegisch &quot;stjerne&quot;
* Schwedisch &quot;stjärna&quot;
* Isländisch &quot;stjarna&quot;
* Kurdisch &quot;stêrk&quot;
* Gujarati &quot;Tārō&quot;
* Hindi &quot;तारा&quot; (taara)
* Marathi &quot;तारा&quot; (Tārā)
* Nepalesisch &quot;तारा&quot; (Tārā)
* Punjabi &quot;ਤਾਰਾ&quot; (Tārā)
* Singhalesisch &quot;තරුව&quot; (taruva)
* Khmer &quot;តារា&quot; (tara)
* Armenisch &quot;աստղ&quot; (astgh)
* Tadschikisch &quot;ситора&quot; (sitora)
* Hausa &quot;tauraro&quot;
* Krio &quot;sta&quot;

=== &quot;Stier&quot; ===
Eine starke Ähnlichkeit gibt es in vielen Sprachen auch zwischen den Wörtern „Stern“ und „Stier“. Der Stier bezeichnet zudem auch ein bedeutendes und eines der ältesten Sternbilder überhaupt:

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|'''Himmelsstier''']].

* Akkadisch und Assyrisch &quot;šūru&quot;
* Aramäisch &quot;tōra&quot;
* Hebräisch &quot;šǒr&quot;
* Ugaritisch &quot;twr&quot;
* Arabisch &quot;ثور&quot; (&quot;thawr&quot;)
* Griechisch &quot;ταύρος&quot; (&quot;tauros&quot;)
* Lateinisch &quot;taurus&quot;
* Althochdeutsch &quot;stior&quot;
* Italienisch, Katalanisch und Spanisch &quot;toro&quot;
* Galicisch &quot;touro&quot;
* Gallisch &quot;tarvos&quot;
* Französisch &quot;taureau&quot;
* Schwedisch &quot;tjur&quot;
* Dänisch &quot;tyr&quot;
* Irisch und Gälisch &quot;tarbh&quot;
* Wallisisch &quot;tarw&quot;

=== &quot;Horn&quot; ===
Auch die Hörner des Stieres betreffend setzen sich die vielen Ähnlichkeiten fort:

* Akkadisch &quot;carnu&quot;
* Aramäisch &quot;qeren&quot;
* Griechisch &quot;κόρνο&quot; (&quot;korno&quot;)
* Lateinisch &quot;cornu&quot;
* Maltesisch &quot;qrun&quot;*
* Arabisch &quot;قرون&quot; (&quot;qurun&quot;)
* Französisch &quot;corne&quot;
* Italienisch &quot;corne&quot;
* Rumänisch &quot;corn&quot;
* Haitianisch &quot;kòn&quot;

=== &quot;Sieben&quot; ===
Die in vielen Kulturen als heilig angesehene Zahl Sieben taucht im Zusammenhang mit der Astronomie als Anzahl der mit bloßem Auge sichtbaren Wandelgestirne und als Zahl der Hauptsterne in vielen Asterismen auf:

* Sieben Wandelgestirne: Sonne Mond, Merkur, Venus, Mars, Jupiter, Saturn
* Siebengestirn im Himmelsstier: Alkione, Atlas, Electra, Maia, Merope, Taygeta, Pleione
* Sternbild Orion: Beteigeuze, Rigel, Bellatrix, Alnilam, Alnitak, Saiph, Mintaka
* Asterismus Großer Wagen: Alioth, Dubhe, Alkaid, Mizar, Merak, Phekda, Megrez

→ Siehe auch:

* [[Quadriviale_Kuriositäten/_Zahlen#Zur_Sieben|'''Zur Sieben''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Der_Fixsternhimmel#Die_sieben_hellsten_Objekte_der_Ekliptik|'''Die sieben hellsten Objekte der Ekliptik''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Kalenderführung#Die_Siebentagewoche|'''Die Siebentagewoche''']].

Wegen der hohen kulturellen, rituellen oder mythischen Bedeutung gibt es in vielen Kulturen und Sprachen etymologische Übereinstimmungen:

* Akkadisch &quot;sebe&quot;
* Proto-Indoeuropäisch &quot;septḿ̥&quot;
* Hetitisch &quot;sipta&quot;
* Proto-Germanisch &quot;*sebun&quot;
* Althochdeutsch &quot;sibun&quot;
* Hebräisch &quot;sajin&quot; (Buchstabe) oder &quot;scheva&quot; (Wort)
* Etruskisch &quot;semph&quot;
* Maltesisch &quot;sebgħa&quot;
* Arabisch &quot;sabʿa&quot;
* Griechisch &quot;επτά&quot; (&quot;(h)epta&quot;)
* Lateinisch &quot;septem&quot;
* Ungarisch &quot;het&quot;
* Proto-Balto-slawisch &quot;septin&quot;
* Proto-Indo-Iranisch &quot;saptá&quot;
* Katalanisch &quot;set&quot;
* Spanisch &quot;siete&quot;
* Galicisch &quot;sete&quot;
* Lettisch &quot;septiņi&quot;
* Italienisch &quot;sette&quot;
* Französisch &quot;sept&quot;
* Englisch &quot;seven&quot;
* Wallisisch &quot;saith&quot;
* Bosnisch / Kroatisch &quot;sedam&quot;
* Rumänisch &quot;șapte&quot;
* Irisch &quot;seacht&quot;
* Swahili &quot;saba&quot;
* Haitianisch &quot;sèt&quot;

== Zur Mythologie ==
Seit Jahrtausenden blicken Menschen in den Nachthimmel und versuchen, die unzähligen Lichter am Firmament zu deuten. Schon früh begannen sie, die von ihnen erfundenen Sternbilder und die unablässig durch den Himmel ziehenden Wandelgestirne durch Geschichten über Götter, Helden oder andere Wesen zu interpretieren, zu erzählen und zum Teil über Jahrhunderte hinweg zu tradieren. Die '''Mythologie''' spielte dabei eine zentrale Rolle: Sie half nicht nur, eine symbolische Ordnung in den geheimnisvollen Kosmos zu bringen, sondern prägte auch viele der Bezeichnungen und Vorstellungen, die bis heute in der beschreibenden Astronomie überlebt haben.

Die Verbindung zwischen Mythologie und Astronomie ist tief verwurzelt und zeugt vom menschlichen Bedürfnis, das wahrgenommene, aber dennoch unfassbare Universum durch räumliche und zeitliche Vorstellungen sowie durch Erzählungen begreifbar zu machen. Das Geschehen am Himmel musste auf die Menschen vor der Erfindung der Bewegtbilder und des Films in der späten Neuzeit sowohl attraktiv als auch spektakulär gewirkt haben. So konnten verschiedene mythische Gestalten am Himmel durch ihre scheinbaren Handlungen wahrgenommen werden. Durch die Wiederholung solcher Deutungen konnten sich besonders beliebte Mythen im kulturellen Kontext über die Zeit verfestigen, und entsprechende Riten konnten sich etablieren.

Damit war auch eine wesentliche Voraussetzung für den Glauben der Menschen an eine höhere Macht oder mehrere höhere Mächte gegeben. Der Begriff '''Religion''' stammt vom lateinischen Inifiniv &quot;relegere&quot; ab. Dieses Verb bedeutet wörtlich übersetzt &quot;wieder lesen&quot; und meint im Sinne von &quot;überdenken&quot; das bewusste Wahrnehmen von Prophezeiungen oder Omen sowie das nachhaltige Beachten tradierter Vorschriften.

'''→ Siehe:'''

* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Der Urozean''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Sagenwelt|'''Die Plejaden / Sagenwelt''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Mythologie|'''Der Himmelsstier''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Babylonische_Himmelswege|'''Babylonische Himmelswege''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Mithraskult|'''Mithraskult und Tauroktonie''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Höhlenmalerei_in_der_Magura-Höhle|'''Die Höhlenmalerei in der Magura-Höhle''']].

== Zur Theologie ==
Die '''Theologie''' (vom Altgriechischen θεός = theós = Gott und λόγος = lógos = Lehre) ist die Lehre von einem Gott oder von mehreren Göttern. Sie lehrt einen ausgeprägten religiösen Glauben, begründet rituelle Traditionen und deutet die vorhandenen Glaubensdokumente.

[[Datei:Aristoteles.Theologie.png|mini|rechts|Wahrnehmbarkeit und Vergänglichkeit nach Aristoteles]]

Die Theologie des '''{{w|Aristoteles}}''' (384–322) postuliert drei mögliche Substanzen:&lt;ref&gt;Aristoteles: ''Metaphysik'', Kapitel XII (Λ), Philosophische Theologie, Seiten 1069a –1076a&lt;/ref&gt;

{| class=&quot;wikitable&quot;
|+ Mögliche Substanzen nach Aristoteles
! Nummer !! Substanz !! Erläuterung !! Interpretationsbeispiel
|-
| 1. || Die sinnlich wahrnehmbare und vergängliche Substanz || Konkrete Dinge, die nur eine begrenzte Teilhabe an der Ewigkeit haben. || Lebewesen
|-
| 2. || Die sinnlich wahrnehmbare und unvergängliche Substanz || Konkrete Dinge, die eine unbegrenzte Teilhabe an der Ewigkeit haben. || Die sieben Wandelgestirne und die Fixsterne
|-
| 3. || Die sinnlich nicht wahrnehmbare und unvergängliche Substanz || Lebendiger, unbewegter Beweger, der der Ursprung aller anderen Dinge ist. || Gott
|}

Dieses theologische Prinzip wurde später auch von '''{{w|Thomas van Aquin}}''' (1225-1274) in seinen ''Quinque viae ad Deum'' (&quot;Fünf Wege zu Gott&quot;) aufgegriffen:

{| class=&quot;wikitable&quot;
|+ Nach dem ''Quinque viae ad Deum'' (&quot;Fünf Wege zu Gott&quot;) von Thomas von Aquin
! Weg !! Bezeichnung !! Voraussetzung !! Feststellung !! Folgerung
|-
| Via&amp;nbsp;I || Bewegungsbeweis || In der Welt ist überall Bewegung. || Alles Bewegte muss von einem anderen in Bewegung gebracht worden sein. || Der Erstbeweger ist Gott.
|-
| Via&amp;nbsp;II || Kausalitätsbeweis || In der Welt gibt es überall Ursachen und Wirkungen. || Jede Wirkung muss eine Ursache haben. || Die erste Ursache der Welt ist Gott.
|-
| Via&amp;nbsp;III || Kontingenzbeweis || Alles Empirische in der Welt entsteht und vergeht wieder. || Jedes empirische Wesen muss das Sein von einem absoluten Wesen empfangen haben. || Das absolute Wesen ist Gott.
|-
| Via&amp;nbsp;IV || Stufenbeweis || In der Welt gibt es abgestuft gute, wahre und schöne Dinge. || Das absolute Wesen muss die höchste Güte, Wahrheit und Schönheit haben. || Das höchste Gute, Wahre und Schöne ist Gott.
|-
| Via&amp;nbsp;V || Finalitätsbeweis || In der Welt gibt es Ordnung und Gesetzmäßigkeit. || Ordnung und Gesetzmäßigkeit müssen auf einen denkenden Geist zurückgehen. || Dieser Geist kommt von Gott.
|}

Auch '''{{w|Gottfried Wilhelm Leibniz}}''' (1646-1717) lehnt sich in seiner Hypothese von „Gott als letztem und zureichendem Grund der Welt“ daran an.

Auch im 90. Psalm wird dieser Ansatz thematisiert:

&lt;blockquote&gt;
Das vierte Buch&lt;br/&gt;
Der '''ewige''' Gott – der '''vergängliche''' Mensch&lt;br/&gt;&lt;br/&gt;
1 Ein Bittgebet des Mose, des Mannes Gottes. O Herr, du warst uns Wohnung '''von Geschlecht zu Geschlecht'''.&lt;br/&gt;
2 '''Ehe geboren wurden die Berge, ehe du unter Wehen hervorbrachtest Erde und Erdkreis''', bist du '''Gott von Ewigkeit zu Ewigkeit'''.&lt;br/&gt;
3 '''Zum Staub zurückkehren lässt du den Menschen''', du sprichst: Ihr Menschenkinder, kehrt zurück!&lt;br/&gt;
4 Denn tausend Jahre sind in deinen Augen wie der Tag, der gestern vergangen ist, wie eine Wache in der Nacht.
&lt;/blockquote&gt;

Darüber hinaus gibt der vierte Vers einen deutlichen Hinweis auf das Verhältnis zwischen der Länge des viele Jahrtausende dauernden Präzessionszyklus und der Länge eines siderischen Monats: der Mond wandert entlang der Ekliptiklinie an einem Tag genauso weit wie der Frühlingspunkt in tausend Jahren.

→ Siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Präzession|'''Präzession''']].

Der griechische Dichter '''{{w|Aratos von Soloi}}''' in Kilikien (≈310–245) hatte seine astronomischen Kenntnisse vom Astronomen und Mathematiker '''{{w|Eudoxos von Knidos}}''' (geboren nach 390, gestorben nach 338) erhalten. In dem in der Antike verbreiteten Lehrgedicht Φαινόμενα (Phainomena = „Himmelserscheinungen“) von Aratos wird der Sternenhimmel in zahlreichen Hexametern beschrieben. Sein monumentales sechseckiges Grab aus der antiken Stadt Pompeiopolis wurde 2020 in der türkischen Provinz Mersin wiederentdeckt.&lt;ref&gt;Patricia Claus: [https://greekreporter.com/2021/07/11/memorial-tomb-of-ancient-greek-astronomer-aratus-unearthed-in-turkey/ Memorial Tomb of Ancient Greek Astronomer Aratus Unearthed in Turkey], The Greek Reporter, 11. Juli 2021&lt;/ref&gt;

Hier der Beginn des Prologs des Lehrgedichts:

&lt;blockquote&gt;
Εκ Διὸς ἀρχώμεσθα , τὸν οὐδέποτ᾽ ἄνδρες ἐῶμεν&lt;br/&gt;
῎Αῤῥητον . Μεσταὶ δὲ Διὸς πᾶσαι μὲν ἀγυιαὶ ,&lt;br/&gt;
Πᾶσαι δ᾽ ἀνθρώπων ἀγοραί · μεστὴ δὲ θάλασσα ,&lt;br/&gt;
Καὶ λιμένες. πάντη δὲ Διὸς κεχρήμεθα πάντες .&lt;br/&gt;
'''Τοῦ γὰρ καὶ γένος εἰμέν''' · ὁ δ᾽ ἤπιος ἀνθρώποισι&lt;br/&gt;
Δεξιὰ σημαίνει · λαοὺς δ᾽ ἐπὶ ἔργον ἐγείρει ,&lt;br/&gt;
Μιμνήσκων βιότοιο . λέγει δ᾽ , ὅτε βῶλος ἀρίστη&lt;br/&gt;
Βουσί τε καὶ μακέλῃσι · λέγει δ᾽ , ὅτε δεξιαὶ ὧραι ,&lt;br/&gt;
Καὶ φυτὰ γύρῶσαι , καὶ σπέρματα πάντα βαλέσθαι .&lt;br/&gt;
Αὐτὸς γὰρ τάγε σήματ᾽ ἐν '''οὐρανῷ''' ἐστήριξεν ,&lt;br/&gt;
'''Αστρα''' διακρίνας · ἐσκέψατο δ᾽ εἰς ἐνιαυτὸν&lt;br/&gt;
'''᾿Αστέρας''' , οἵ κε μάλιστα τετυγμένα σημαίνοιεν&lt;br/&gt;
᾿Ανδράσιν ὡράων , ὄφρ᾽ ἔμπεδα πάντα φύωνται .&lt;br/&gt;
Τῷ μιν ἀεὶ πρῶτόν τε καὶ ὕστατον ἱλάσκονται .&lt;br/&gt;
Χαῖρε , πάτερ , μέγα θαῦμα , μέγ᾽ ἀνθρώποισιν ὄνειαρ ,&lt;br/&gt;
Αὐτὸς καὶ προτέρη γενεή ! χαίροιτε δὲ , Μοῦσαι&lt;br/&gt;
Μειλίχιαι , μάλα πᾶσαι ! ἐμοί γε μὲν '''ἀστέρας''' εἰπεῖν ,&lt;br/&gt;
Ηἱ θέμις εὐχομένῳ , τεκμήρατε πᾶσαν ἀοιδήν .&lt;br/&gt;
Οἱ μὲν ὁμῶς πολέες τε , καὶ ἄλλυδις ἄλλοι ἐόντες ,&lt;br/&gt;
'''Οὐρανῷ''' ἕλκονται πάντ᾽ ἤματα συνεχὲς αἰεί.&lt;br/&gt;
Αὐτὰρ ὅγ᾽ οὐδ᾽ ὀλίγον μετανίσσεται · ἀλλὰ μάλ' αὕτως&lt;br/&gt;
'''῎Αξων''' οἱ ἐνάρηρεν · ἔχει δ᾽ ἀτάλαντον ἁπάντη&lt;br/&gt;
'''Μεσσηγὺς γαῖαν''' , περὶ δ᾽ '''οὐρανὸν''' αὐτὸν ἀγινεῖ.&lt;br/&gt;
Καί μιν πειραίνουσι δύω '''πόλοι''' ἀμφοτέρωθεν ·&lt;br/&gt;
᾿Αλλ᾽ ὁ μὲν οὐκ ἐπίοπτος · ὁ δ᾽ ἀντίος ἐκ '''Βορέαο''' ,&lt;br/&gt;
Ὑψόθεν Ὠκεανοῖο . Δύω δὲ μιν ἀμφὶς ἔχουσαι&lt;br/&gt;
'''Ἄρκτοι''' ἅμα τροχόωσι · τὸ δὴ καλέονται '''῞Αμαξαι''' .
&lt;/blockquote&gt;

Übersetzung unter Beibehaltung der Hexameter nach dem deutschen Dichter, Übersetzer und Hochschullehrer Johann Heinrich Voss (1751–1826) von 1824:&lt;ref&gt;АРАТОΥ ΦΑΙΝΟΜΕΝΑ ΚΑΙ ΔΙΟΣΗΜΕΙΑ. Des Aratos Sternerscheinungen und Wetterzeichen. Übersetzt und erklärt von Johann Heinrich Voss. Heidelberg bei Christian Friedrich Winter. 1824.&lt;/ref&gt;

&lt;blockquote&gt;
Zeus sei unser Beginn , und niemals bleib' er uns Männern&lt;br/&gt;
Ungelobt. Voll wahrlich des Zeus sind alle des Wandels&lt;br/&gt;
Weg' , und alle Versammlung der Welt ; voll jegliche Meerflut ,&lt;br/&gt;
Jeglicher Port ; ringsum ja des Zeus bedürfen wir alle .&lt;br/&gt;
'''Seines Geschlechts auch sind wir''' ; und Er , mildherzig den Menschen,&lt;br/&gt;
Zeichnet, was frommt, rechtsher ; und zu Tätigkeit weckt er die Völker,&lt;br/&gt;
Mahnend an Lebensbedarf : Er sagt , wann besser dem Pflugstier&lt;br/&gt;
Fuge die Scholl' , und dem Karst ; er sagt , wann schickliche Jahrszeit,&lt;br/&gt;
Dass man die Pflanze behäuf&quot; , und einsenk' allerlei Anwachs .&lt;br/&gt;
Denn selbst hat er die Zeichen am oberen '''Himmel''' befestigt ,&lt;br/&gt;
Und '''Sternbilder''' verteilt ; er hat fürsehend dem Jahrlauf&lt;br/&gt;
'''Sterne''' bestimmt , die den Menschen zumeist annahende Wechsel&lt;br/&gt;
Deuteten jeglicher Zeit , dass in Völligkeit alles erwachse .&lt;br/&gt;
Drum ihn immer zuerst , und zulezt ihn , sühnen sie feiernd.&lt;br/&gt;
Heil , anstaunlicher Vater , den Sterblichen mächtiges Labsal ,&lt;br/&gt;
Du auch , selbst des Geschlechts Ursprung ! Heil , freundliche Musen,&lt;br/&gt;
Heil euch allen gesamt ! doch mir , der , die '''Sterne''' zu melden ,&lt;br/&gt;
Euch , wie geziemt , anfleht , bringt allen Gesang zur Vollendung.&lt;br/&gt;
Jene zugleich , so viele zerstreuete , andere anders ,&lt;br/&gt;
Ziehn mit dem '''Himmel''' einher in ewigem Zuge beständig .&lt;br/&gt;
Doch nie schwanket er selbst um ein weniges; sondern durchaus so&lt;br/&gt;
Bleibt ihm die '''Axe''' geheftet ; die hält gleichschwebend vom Umfang&lt;br/&gt;
Hier '''in der Mitte die Erd'''' , und umher dort dreht sie den '''Himmel''' .&lt;br/&gt;
Sie dann hat zween '''Pol'''' an jeglichem Ende gerichtet :&lt;br/&gt;
Unsichtbar ist jener; doch hier um den '''Boreas''' ragt er&lt;br/&gt;
Ob dem Okeanos hoch. Zwo dem zu den Seiten gestellte&lt;br/&gt;
'''Bärinnen''' rollen umher: drum auch '''Rollwagen''' benamet.
&lt;/blockquote&gt;

'''''Hinweise:'''''
* Die &quot;Axe&quot; beschreibt die Erdachse.
* ''Mit dem &quot;Boreas&quot; ist der Himmelsnordpol gemeint.''
* ''Bei den beiden Bärinnen handelt es sich um die Sternbilder des Großen Bären (Ursa Maior) und des Kleinen Bären (Ursa Minor).''
* ''Die beiden Rollwagen sind bei uns heute die Asterismen Großer Wagen und Kleiner Wagen.''

Der Apostel '''{{w|Paulus von Tarsus}}''' (geboren vor 10, gestorben nach 60) war der bedeutendste Missionar des Urchristentums und kannte diesen Text offensichtlich. Im 17.&amp;nbsp;Kapitel der Apostelgeschichte des Lukas wird ihm ein Zitat aus dem Prolog des Lehrgedichts über die Abstammung der Menschen von Gott in den Mund gelegt.&lt;ref&gt;[https://www.die-bibel.de/bibel/NA28,EUE/ACT.17.28 Apostelgeschichte 17,28], Abschnitt: ''Paulus in Athen'', Novum Testamentum Graece und Einheitsübersetzung&lt;/ref&gt;

&lt;blockquote&gt;
Apostelgeschichte 17,28: '''Τοῦ γὰρ καὶ γένος ἐσμέν.'''
&lt;/blockquote&gt;

&lt;blockquote&gt;
Apostelgeschichte 17,28: '''Wir sind von seinem Geschlecht.'''
&lt;/blockquote&gt;

=== Zahlen in Religionen ===
Die '''Zwei''' steht oft für Gegensätze, wie zum Beispiel Tag und Nacht, Aufgang und Untergang, Sommerhalbjahr und Winterhalbjahr, zunehmender und abnehmender Mond oder obere und untere Kulmination. Eine solche Zweiteilung findet sich oft auch in gegensätzliche Kategorien wieder, die in vielen Disziplinen, insbesondere auch in der Ethik und in Religionen verwendet werden, wie beispielsweise gut und böse, oben und unten, Leben und Tod, Licht und Schatten, Wärme und Kälte oder Himmel und Hölle.

Interessant ist auch die frühgeschichtliche astronomische Auffassung von '''zwei''' mächtigen Gegenspielern, die sich im Sternenhimmel an zwei gegenüberliegenden Seiten befinden, der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|der Himmelsstier]] und der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsskorpion|der Himmelsskorpion]].

→ Siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwei|'''Zur Zwei''']].

Die astronomischen Zahlen '''Sieben''' und '''Zwölf''' werden als heilige Zahlen angesehen. Sie werden in vielfältigen Kontexten in religiösen Texten erwähnt und für viele religiöse Symbole verwendet. Ferner spielt auch die astronomische Zahl '''Vier''' in Religionen eine bedeutende Rolle, wo sie deswegen manchmal ebenfalls als heilige Zahlen angesehen wird:

* '''Vier''' Hauptsterne respektive Hauptsternbilder mit den '''vier''' Himmelsrichtungen und den '''vier''' Jahreszeiten: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Vier_in_Religionen|'''Bedeutung der Vier in Religionen''']].
* '''Sieben''' Wandelgestirne mit den die '''sieben''' Tagen einer Woche beziehungsweise eines Mondviertels: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Sieben_in_Religionen|'''Bedeutung der Sieben in Religionen''']].
* '''Zwölf''' Ekliptiksternbilder, '''zwölf''' Monate pro Jahr, '''zwölf''' Jahre Umlaufzeit des Planeten Jupiter, jeweils '''zwölf''' Stunden Tag und Nacht: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Zwölf_in_Religionen|'''Bedeutung der Zwölf in Religionen''']].

=== Altes Testament ===
In der Bibel wird in der Regel nicht zwischen Fixsternen und Planeten unterschieden. Eine Ausnahme gibt es im 2.&amp;nbsp;Buch der Könige, Kapitel&amp;nbsp;23, Vers&amp;nbsp;5 aus dem siebenten vorchristlichen Jahrhundert, wo in der deutschsprachigen Einheitsübersetzung von &quot;den Wandelsternen&quot; und in der Luther-Bibel von &quot;den Planeten&quot; die Rede ist. Die Vulgata schreibt hier allerdings von den &quot;duodecim signis&quot;, womit sicherlich die zwölf Sternzeichen der Ekliptik gemeint sind, durch die die sieben Wandelgestirne ziehen. Die Septuaginta spricht noch allgemeiner von den &quot;μαζουρωθ&quot; nach dem Hebräischen Wort &quot;מַזָּלָה&quot; (&quot;mazzaroth&quot;), womit vermutlich Sternkonstellationen und im engeren Sinne ebenfalls die zwölf Sternzeichen des Zodiaks gemeint sind:

&lt;blockquote&gt;
'''Septuaginta '''&lt;br/&gt;
5 καὶ κατέπαυσεν τοὺς χωμαριμ, οὓς ἔδωκαν βασιλεῖς Ιουδα καὶ ἐθυμίων ἐν τοῖς ὑψηλοῖς καὶ ἐν ταῖς πόλεσιν Ιουδα καὶ τοῖς περικύκλῳ Ιερουσαλημ, καὶ τοὺς θυμιῶντας τῷ Βααλ καὶ τῷ ἡλίῳ καὶ τῇ σελήνῃ καὶ τοῖς '''μαζουρωθ''' καὶ πάσῃ τῇ δυνάμει τοῦ οὐρανοῦ.&lt;br/&gt;
&lt;br/&gt;
'''Vulgata'''&lt;br/&gt;
5 Et delevit aedituos, quos posuerant reges Iudae ad sacrificandum in excelsis per civitates Iudae et in circuitu Ierusalem, et eos, qui adolebant Baal et soli et lunae et '''duodecim signis''' et omni militiae caeli.&lt;br/&gt;
&lt;br/&gt;
'''Einheitsübersetzung (2016)'''&lt;br/&gt;
5 Auch setzte er die Götzenpriester ab, die von den Königen von Juda bestellt worden waren und die auf den Kulthöhen, in den Städten Judas und in der Umgebung Jerusalems Opfer verbrannt sowie dem Baal, der Sonne, dem Mond, den '''Wandelsternen''' und dem ganzen Heer des Himmels geopfert hatten.&lt;br/&gt;
&lt;br/&gt;
'''Luther-Bibel (2017)'''&lt;br/&gt;
5 Und er setzte die Götzenpriester ab, die die Könige von Juda eingesetzt hatten, um auf den Höhen zu opfern in den Städten Judas und um Jerusalem her; auch die dem Baal geräuchert hatten, der Sonne und dem Mond und den '''Planeten''' und allem Heer am Himmel.&lt;br/&gt;
&lt;/blockquote&gt;

Der Prophet Habakuk erwähnt in seinem Psalm in Kapitel&amp;nbsp;3 aus dem siebenten vorchristlichen Jahrhundert das Konzept der Aufteilung der Ekliptik in Mondstationen respektive in Mondhäuser:

&lt;blockquote&gt;
10 Wenn sie dich sehen, erbeben die Berge,&lt;br/&gt;
das Tosen der Wasser rauscht vorüber; es erhebt die Urflut ihre Stimme,&lt;br/&gt;
hoch oben vergisst die Sonne ihre Strahlen.&lt;br/&gt;
11 '''Der Mond bleibt in der Behausung;'''&lt;br/&gt;
als Beleuchtung schwirren deine Pfeile,&lt;br/&gt;
als heller Schein das Blitzen deiner Lanze.
&lt;/blockquote&gt;

In den folgenden Bibelstellen aus dem Alten Testament spiegeln sich astronomische Vorstellungen in Bezug auf Gott wider:

'''Genesis 1:'''
&lt;blockquote&gt;
1 Im Anfang erschuf Gott '''Himmel''' und Erde.&lt;br/&gt;
2 Die '''Erde''' war wüst und wirr und '''Finsternis''' lag über der '''Urflut''' und Gottes Geist schwebte über dem '''Wasser'''.&lt;br/&gt;
3 Gott sprach: Es werde '''Licht'''. Und es wurde '''Licht'''.
...&lt;br/&gt;
5 Und Gott nannte das Licht '''Tag''' und die Finsternis nannte er '''Nacht'''. Es wurde '''Abend''' und es wurde '''Morgen''': erster Tag.&lt;br/&gt;
...&lt;br/&gt;
14 Dann sprach Gott: Lichter sollen am '''Himmelsgewölbe''' sein, um '''Tag''' und '''Nacht''' zu scheiden. Sie sollen als Zeichen für '''Festzeiten''', für '''Tage''' und '''Jahre''' dienen.&lt;br/&gt;
15 Sie sollen Lichter am Himmelsgewölbe sein, um über die Erde hin zu leuchten. Und so geschah es.&lt;br/&gt;
16 Gott machte '''die beiden großen Lichter''', das große zur Herrschaft über den '''Tag''', das kleine zur Herrschaft über die '''Nacht''', und die '''Sterne'''.
&lt;/blockquote&gt;

'''Psalm 8:'''
&lt;blockquote&gt;
4 Seh ich deine '''Himmel''', die Werke deiner Finger, '''Mond '''und '''Sterne''', die du befestigt.
&lt;/blockquote&gt;

[[Datei:Johannes.Kepler.Coeli.enarrant.gloriam.Dei.png|mini|rechts|Portrait des jungen Johannes Keplers mit dem Motto &quot;Coeli enarrant gloriam Dei.&quot; nach Psalm 19: &quot;Die Himmel erzählen die Herrlichkeit Gottes.&quot;]]

'''Psalm 19:'''
&lt;blockquote&gt;
2 Die '''Himmel''' erzählen die Herrlichkeit Gottes und das '''Firmament''' kündet das Werk seiner Hände.
&lt;/blockquote&gt;

'''Psalm 90:'''
&lt;blockquote&gt;
2 Ehe geboren wurden die Berge, ehe du unter Wehen hervorbrachtest '''Erde''' und '''Erdkreis''', bist du Gott von Ewigkeit zu Ewigkeit.
&lt;/blockquote&gt;

'''Psalm 102:'''
&lt;blockquote&gt;
26 Vorzeiten hast du der Erde Grund gelegt, die '''Himmel''' sind das Werk deiner Hände.
&lt;/blockquote&gt;

'''Psalm 103:'''
&lt;blockquote&gt;
19 Der HERR hat seinen Thron errichtet im '''Himmel''', seine königliche Macht beherrscht '''das All'''.
&lt;/blockquote&gt;

'''Psalm 104:'''
&lt;blockquote&gt;
19 Du machst den '''Mond''' zum Maß für die Zeiten, die '''Sonne''' weiß, wann sie untergeht.
&lt;/blockquote&gt;

'''Psalm 113:'''
&lt;blockquote&gt;
3 Vom '''Aufgang der Sonne''' bis zu ihrem '''Untergang''' sei gelobt der Name des HERRN.&lt;br/&gt;
4 Erhaben ist der HERR über alle Völker, über den '''Himmeln''' ist seine Herrlichkeit.
&lt;/blockquote&gt;

'''Psalm 136:'''
&lt;blockquote&gt;
3 Dankt dem Herrn der Herren, denn seine Huld währt ewig!&lt;br/&gt;
4 Ihm, der allein große Wunder tut, denn seine Huld währt ewig,&lt;br/&gt;
5 der den '''Himmel''' gemacht hat in Weisheit, denn seine Huld währt ewig,&lt;br/&gt;
6 der die Erde gefestigt hat über den Wassern, denn seine Huld währt ewig,&lt;br/&gt;
7 der '''die großen Leuchten''' gemacht hat, denn seine Huld währt ewig,&lt;br/&gt;
8 die '''Sonne''' zur Herrschaft über den '''Tag''', denn seine Huld währt ewig,&lt;br/&gt;
9 den '''Mond''' und die '''Sterne''' zur Herrschaft über die '''Nacht''', denn seine Huld währt ewig.
&lt;/blockquote&gt;

'''Psalm 147:'''
&lt;blockquote&gt;
4 Er bestimmt die Zahl der '''Sterne''' und ruft sie alle mit Namen.
&lt;/blockquote&gt;

'''Psalm 148:'''
&lt;blockquote&gt;
'''Lobpreis auf den Herrn, den König des Kosmos'''&lt;br/&gt;
1 Halleluja! Lobt den HERRN vom '''Himmel''' her, lobt ihn in den Höhen:&lt;br/&gt;
2 Lobt ihn, all seine Engel, lobt ihn, all seine Heerscharen,&lt;br/&gt;
3 lobt ihn, '''Sonne''' und '''Mond''', lobt ihn, all ihr leuchtenden '''Sterne''',&lt;br/&gt;
4 lobt ihn, ihr '''Himmel der Himmel''', ihr Wasser über dem '''Himmel'''!
&lt;/blockquote&gt;

Mit den &quot;Wassern über dem Himmel&quot; können nicht die Wolken unterhalb der Sternensphäre gemeint sein. Vielmehr dürfte es sich um eine Anspielung auf den Urozean beziehungsweise die Urflut handeln (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Urozean''']]). Diese Urflut existierte bereits vor der Erschaffung des Lichts und der Gestirne. Man erinnere sich an den Beginn der Schöpfungsgeschichte in den ersten drei Versen der Bibel (siehe oben).

'''Buch der Weisheit (Weisheit Salomos):'''
&lt;blockquote&gt;
'''Salomos Gebet um Weisheit'''&lt;br/&gt;
9,1 Gott der Väter und Herr des Erbarmens, du hast '''das All''' durch dein Wort gemacht.
&lt;/blockquote&gt;

'''Jesus Sirach 42:'''
&lt;blockquote&gt;
'''Lob Gottes in der Schöpfung'''&lt;br/&gt;
15 Nun will ich der Werke des Herrn gedenken, und was ich gesehen habe, werde ich erzählen: Durch die Worte des Herrn sind seine Werke und durch seinen Segen gab er ihnen ihre Bestimmung.&lt;br/&gt;
16 Die leuchtende '''Sonne''' blickt auf alles hernieder und von der Herrlichkeit des Herrn ist sein Werk erfüllt.&lt;br/&gt;
17 Der Herr gab es selbst den Heiligen nicht, all seine Wunder zu erzählen, der Herr der Herrscher über '''das All''', hat sie gegründet, sodass '''das All''' in seiner Herrlichkeit Bestand hat.&lt;br/&gt;
18 Abgrund und Herz hat er durchforscht und ihre Absichten hat er durchschaut; denn der Höchste kennt alles Wissen und er blickt auf die '''Zeichen der Zeiten'''.&lt;br/&gt;
19 Er tut das Vergangene und das Kommende kund und enthüllt die Spuren des Verborgenen.&lt;br/&gt;
20 Kein Gedanke entgeht ihm und kein einziges Wort bleibt ihm verborgen.&lt;br/&gt;
21 Die Großtaten seiner Weisheit hat er geordnet; wie er ist '''von Ewigkeit und in Ewigkeit'''. Ihm ist weder etwas hinzugefügt noch weggenommen worden und er hat keines Ratgebers bedurft.
&lt;/blockquote&gt;

Auch im nachfolgenden Kapitel lobt Jesus Sirach die Sonne, den Mond und die Sterne in den höchsten Tönen:

'''Jesus Sirach 43:'''
&lt;blockquote&gt;
1 Der Stolz der Höhe ist ein '''Firmament''' von Reinheit, die Gestalt des '''Himmels''' beim Anblick der Herrlichkeit.&lt;br/&gt;
2 Die '''Sonne''' verkündet durch ihr Erscheinen beim Aufgang, ein wunderbares Geschöpf, ein Werk des Höchsten!&lt;br/&gt;
3 Zur '''Mittagszeit''' trocknet sie den Boden aus, wer wird bestehen vor ihrer Glut?&lt;br/&gt;
4 Wer in einen Ofen bläst bei Arbeiten mit Glut - dreimal so stark versengt die '''Sonne''' Berge; sie atmet Feuerdämpfe aus und blendet mit gleißenden Strahlen die Augen.&lt;br/&gt;
5 Groß ist der Herr, der sie gemacht hat, mit seinen Worten beschleunigt er ihren Lauf.&lt;br/&gt;
6 Auch der '''Mond''' hält sich in allem an seinen Zeitpunkt, zur '''Festsetzung der Zeiten''' und als Zeichen auf Dauer.&lt;br/&gt;
7 Vom '''Mond''' geht das Zeichen für einen Festtag aus, ein Gestirn, das abnimmt bis zur Vollendung.&lt;br/&gt;
8 Der Name '''Monat''' kommt vom '''Neumond''', der wunderbar zunimmt beim Wechsel, ein Geschöpf des Heeres in der Höhe, das am '''Himmelsgewölbe''' leuchtet.&lt;br/&gt;
9 Die Schönheit des '''Himmels''' ist der Glanz der '''Sterne''', ein strahlender Schmuck in den Höhen des Herrn.&lt;br/&gt;
10 Durch die Worte des Heiligen stehen sie gemäß ihrer Bestimmung und sie ermüden nie bei ihrer Wache.&lt;br/&gt;
...&lt;br/&gt;
27 Vieles werden wir sagen, aber wir kommen nie an ein Ziel und das Ende der Worte ist: Er ist '''das All'''.
&lt;/blockquote&gt;

'''Jesaja 40:'''
&lt;blockquote&gt;
26 Hebt eure Augen in die Höhe und seht: Wer hat diese '''Gestirne''' erschaffen?&lt;br/&gt;
Der vollzählig herausführt ihr Heer, er ruft sie alle beim Namen.&lt;br/&gt;
Wegen seiner Fülle an Kraft und mächtiger Stärke fehlt kein einziges.
&lt;/blockquote&gt;

Das Buch Baruch gehört zu den späten Schriften des Alten Testaments. Im dritten Kapitel werden das Licht und die Sterne in Bezug auf Gott thematisiert:

'''Baruch 3:'''
&lt;blockquote&gt;
33 Er entsendet das '''Licht''' und es eilt dahin; er ruft es zurück und zitternd gehorcht es ihm.&lt;br/&gt;
34 Froh leuchten die '''Sterne''' auf ihren Posten.&lt;br/&gt;
35 Ruft er sie, so antworten sie: Hier sind wir. Sie leuchten mit Freude für ihren Schöpfer.&lt;br/&gt;
36 Das ist unser Gott; kein anderer gilt neben ihm.
&lt;/blockquote&gt;

Ein Lobpreis auf die Werke, Engel und Mächte Gottes am Gewölbe des Himmels findet sich im '''Buch Daniel''' im dritten Kapitel. Der Text macht inhaltlich eine ähnliche Aussage wie der Lobpreis auf den Herrn, den König des Kosmos in Psalm 148 (siehe oben):

'''Daniel 3:'''
&lt;blockquote&gt;
56 Gepriesen bist du am Gewölbe des '''Himmels''', gerühmt und verherrlicht in Ewigkeit.&lt;br/&gt;
57 Preist den HERRN, all ihr Werke des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
58 Preist den HERRN, ihr '''Himmel'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
59 Preist den HERRN, ihr Engel des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
60 Preist den HERRN, all ihr '''Wasser über dem Himmel'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
61 Preist den HERRN, all ihr Mächte des HERRN; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
62 Preist den HERRN, '''Sonne und Mond'''; lobt und rühmt ihn in Ewigkeit!&lt;br/&gt;
63 Preist den HERRN, ihr '''Sterne am Himmel'''; lobt und rühmt ihn in Ewigkeit!
&lt;/blockquote&gt;

=== Der Himmelsthron ===
Der '''Himmelsthron''' wir in vielen Texten des Alten Testaments als der Sitz Gottes genannt. Hier zunächst einige Erwähnungen in den Psalmen:

&lt;blockquote&gt;
11,4 Der HERR ist in seinem heiligen Tempel, der HERR hat seinen '''Thron im Himmel'''.&lt;br/&gt;
Seine Augen schauen herab, seine Blicke prüfen die Menschen.
&lt;/blockquote&gt;

&lt;blockquote&gt;
33,13 Der HERR blickt herab vom '''Himmel''', er sieht alle Menschen.&lt;br/&gt;
33,14 Von seinem '''Thronsitz''' schaut er nieder auf alle Bewohner der Erde.
&lt;/blockquote&gt;

&lt;blockquote&gt;
89,37 Sein Haus soll bleiben auf ewig, sein '''Thron''' habe Bestand vor mir wie die '''Sonne''';
&lt;/blockquote&gt;

&lt;blockquote&gt;
103,19 Der HERR hat seinen '''Thron''' errichtet im '''Himmel''', seine königliche Macht beherrscht '''das All'''.
&lt;/blockquote&gt;

Im Buch der Weisheit stehen die folgenden beiden Verse:

&lt;blockquote&gt;
9,9 Mit dir ist die Weisheit, die deine Werke kennt und die zugegen war, als du die Welt erschufst. Sie weiß, was wohlgefällig ist in deinen Augen und was recht ist nach deinen Geboten.&lt;br/&gt;
9,10 Sende sie vom heiligen '''Himmel''' und schick sie vom '''Thron''' deiner Herrlichkeit, damit sie bei mir sei und alle Mühe mit mir teile und ich erkenne, was wohlgefällig ist bei dir!
&lt;/blockquote&gt;

Diese Bild von Gottes Thron im Himmel wir auch im Neuen Testament aufgegriffen, wie beispielsweise beim Evangelisten Matthäus (Kapitel 5, Vers 34) oder in der Offenbarung des Johannes, wo im vierten Kapitel die eröffnende Himmelsvision mit dem Abschnitt über &quot;Die Huldigung vor dem Thron Gottes&quot; beginnt:

&lt;blockquote&gt;
1 Danach sah ich und siehe, eine Tür war geöffnet am '''Himmel'''; und die erste Stimme, die ich gleich einer Posaune mit mir reden gehört hatte, sagte: Komm herauf und ich werde dir zeigen, was dann geschehen muss.&lt;br/&gt;
2 Sogleich wurde ich vom Geist ergriffen. Und siehe, '''ein Thron stand im Himmel'''; auf dem Thron saß einer,&lt;br/&gt;
3 der wie ein Jaspis und ein Karneol aussah. Und über dem '''Thron''' wölbte sich ein Regenbogen, der wie ein Smaragd aussah.&lt;br/&gt;
4 Und rings um den '''Thron standen vierundzwanzig Throne''' und auf den Thronen saßen vierundzwanzig Älteste, in weiße Gewänder gekleidet und mit goldenen Kränzen auf dem Haupt.&lt;br/&gt;
5 Von dem Thron gingen Blitze, Stimmen und Donner aus. Und '''sieben lodernde Fackeln brannten vor dem Thron; das sind die sieben Geister Gottes'''.&lt;br/&gt;
6 Und vor dem Thron war etwas wie ein gläsernes Meer, gleich Kristall. Und in der Mitte des Thrones und rings um den Thron waren '''vier Lebewesen''' voller Augen, vorn und hinten.&lt;br/&gt;
7 Das erste Lebewesen glich einem '''Löwen''', das zweite einem '''Stier''', das dritte sah aus wie ein '''Mensch''', das vierte glich einem '''fliegenden Adler'''.&lt;br/&gt;
&lt;/blockquote&gt;

Der achtstrophige Adventshymnus ''Veni redemptor gentium'' (die deutschsprachige Kontrafaktur heißt &quot;Nun komm, der Heiden Heiland&quot;) wird dem Kirchenvater Ambrosius von Mailand (339–397) zugeschrieben. In der fünften Strophe wird mit Bezug auf die Himmelfahrt des Messias der Sitz Gottes erwähnt:

&lt;blockquote&gt;
5,1 Egressus eius a Patre,&lt;br/&gt;
5,2 Regressus eius ad Patrem;&lt;br/&gt;
5,3 Excursus usque ad inferos,&lt;br/&gt;
5,4 Recursus ad '''sedem Dei'''.
&lt;/blockquote&gt;

&lt;blockquote&gt;
5,1 Sein Ausgang ist vom Vater,&lt;br/&gt;
5,2 Seine Rückkehr ist beim Vater;&lt;br/&gt;
5,3 Hinausgelaufen bis zu den Toten,&lt;br/&gt;
5,4 Zurückgelaufen bis zum '''Sitz Gottes'''.
&lt;/blockquote&gt;

Es ist nicht viel Phantasie erforderlich, um den Thron Gottes im '''Himmelsstier''' wiederzuerkennen. Die vierundzwanzig Throne, die sich entlang der '''Ekliptik''' um diesen Thron herum aufreihen, stehen für die vierundzwanzig Stunden eines Tages, und sie sind je zwei für jedes der zwölf Lebewesenkreiszeichen des '''Zodiaks'''. Die als sieben lodernde Fackeln vor dem Thron sind die sieben '''Wandelgestirne''', die als die '''sieben Geister Gottes''' immer wieder durch das '''Goldene Tor der Ekliptik''' in der Sitzfläche des Thrones ziehen. Die '''vier besonderen Lebewesen''' sind die vier Evangelistensymbole bei den vier zoroastrischen '''Königssternen'''.

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|'''Himmelsstier''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Die_Ekliptik|'''Ekliptik''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|'''Zodiak''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|'''Goldenes Tor der Ekliptik''']].

→ Siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Vier_in_Religionen|'''Bedeutung der Vier in Religionen''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Königssterne|'''Königssterne''']].

&lt;gallery caption=&quot;Throne&quot; widths=640 heights=480 perrow=3&gt;
StatueOfEl.png|Rekonstruktion der 1988 in Ugarit ausgegrabenen und auf einem Thron sitzenden Statue vom höchsten ugaritischen Gott El, der als Erschaffer der Welt angebetet wurde.
Aachen_Cathedral_Karlsthron_02.jpg|Thron Karls des Großen aus den 790er Jahren im Aachener Dom.
Himmelsthron.Taurus.Aries.png|Himmelsthron in den Sternbildern Stier (Taurus) und Widder (Aries) vor dem Untergang in Richtung Westen.
&lt;/gallery&gt;

=== Das Lamm ===
Im ersten Kapitel des Evangeliums nach Johannes wird Jesus von Nazareth explizit als &quot;Lamm Gottes&quot; bezeichnet:&lt;ref&gt;[https://www.bibleserver.com/EU/Johannes1%2C29 Johannes 1,29], bibleserver.com, Einheitsübersetzung (2016)&lt;/ref&gt;

&lt;blockquote&gt;
29b Seht, das '''Lamm Gottes''', das die Sünde der Welt hinwegnimmt!&lt;br/&gt;
...&lt;br/&gt;
36b Seht, das '''Lamm Gottes'''!
&lt;/blockquote&gt;

Es handelt sich beim „Lamm Gottes“ (Kirchenlatein: „Agnus Dei“) um ein seit ältester Zeit verbreitetes Symbol für Jesus Christus. Es wird auch als das Osterlamm bezeichnet, das am Ostertag, also kurz nach der Tag-und-Nacht-Gleiche im Frühjahr auferstanden ist. Nach dem Evangelisten Markus wurde die Auferstehung „... am ersten Tag der Woche, früh am Morgen, als eben die Sonne aufging“, also am Ostersonntag während der Morgenröte im Osten entdeckt.&lt;ref&gt;[https://www.bibleserver.com/LUT/Markus16%2C2 Markus 16,2], Einheitsübersetzung, 2016&lt;/ref&gt; Am 40.&amp;nbsp;Tag ist Jesus Christus nach dem Zeugnis der Evangelisten Markus und Lukas in den Himmel aufgefahren. Zu Beginn der Apostelgeschichte wird dieses Ereignis folgendermaßen beschrieben:&lt;ref&gt;[https://www.bibleserver.com/EU/Apostelgeschichte1 Apostelgeschichte 1], Einheitsübersetzung, 2016&lt;/ref&gt;

&lt;blockquote&gt;
7 Er sagte zu ihnen: Euch steht es nicht zu, Zeiten und Fristen zu erfahren, die der Vater in seiner Macht festgesetzt hat.&lt;br/&gt;
8 Aber ihr werdet Kraft empfangen, wenn der Heilige Geist auf euch herabkommen wird; und ihr werdet meine Zeugen sein in Jerusalem und in ganz Judäa und Samarien und bis an die Grenzen der Erde.&lt;br/&gt;
9 Als er das gesagt hatte, wurde er vor ihren Augen emporgehoben und eine Wolke nahm ihn auf und entzog ihn ihren Blicken.&lt;br/&gt;
&lt;/blockquote&gt;

Im altrömischen Glaubensbekenntnis gibt es die Textstelle:

&lt;blockquote&gt;
„ascendit in caelis, sedet ad dexteram Patris“
&lt;/blockquote&gt;

Zu Deutsch:

&lt;blockquote&gt;
„aufgefahren in den Himmel, er sitzt zur Rechten des Vaters“
&lt;/blockquote&gt;

Das '''Lamm''' (astronomisch Widder) befindet sich am nördlichen Sternenhimmel '''zur Rechten''' des Stieres (Taurus). Sowohl der mesopotamische Himmelsstier als auch das altarabische Sternbild Thuraya verbinden diese beiden neuzeitlichen Sternbilder zu einer Einheit. Der Hauptstern im Sternbild Widder (Aries) heißt Hamal, und das arabische Wort &quot;hamal&quot; steht für ein einjähriges Lamm.&lt;ref name=&quot;Adams&quot;&gt;Danielle Adams: [http://onesky.arizona.edu/arab-star-names/the-lamb/ The Lamb – A folkloric celestial complex], Two Deserts, one Sky – Arab Star Calendars&lt;/ref&gt; Der fette Schwanz des Lammes wird durch die '''Plejaden (Siebengestirn)''' markiert.&lt;ref name=&quot;Adams&quot; /&gt; Die Augen des Stieres sind die Sterne '''Aldebaran''' und '''Ain'''. Zwischen dem Kopf des Stieres und den '''Plejaden''' befindet sich das '''Goldene Tor der Ekliptik''', durch das alle Wandelgestirne regelmäßig hindurchziehen.

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Bibelstellen|'''Bibelstellen zum Siebengestirn''']].

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|'''Goldenes Tor der Ekliptik''']].

Der Frühlingspunkt der Sonne, also deren Ort auf der Ekliptiklinie zur Tag-und-Nacht-Gleiche im Frühjahr, ist von der monotheistischen Schöpfung bis zur Geburt des christlichen Gottessohns vom Kopf des Stiers (bei den Sternen '''Aldebaran''' und '''Ain''' im Goldenen Tor der Ekliptik) im heutigen Sternbild Stier (Taurus) bis zum Kopf des Lammes (beim Stern '''Hamal''') im heutigen Sternbild Widder (Aries) nach Westen gewandert. Heute befindet sich der Frühlingspunkt bereits am westlichen Ende des Sternbilds Fische (Pisces), das sich westlich an das Sternbild Widder anschließt.

==== Offenbarung des Johannes ====
In der Offenbarung des Johannes heißt es im 7.&amp;nbsp;Kapitel:

&lt;blockquote&gt;
10b Die Rettung kommt von unserem '''Gott''', der auf dem '''Thron''' sitzt, und von dem '''Lamm'''.&lt;br/&gt;
17a Denn das Lamm in der Mitte vor dem Thron wird sie weiden und zu den Quellen führen, aus denen das '''Wasser des Lebens''' strömt.
&lt;/blockquote&gt;

Wird der '''Thron Gottes''' mit dem Himmelsstier identifiziert (siehe oben), dann sitzt das '''Lamm''' (Aries, Sternbild Widder) westlich und somit rechts vor diesem Thron. Im weiteren Verlauf der Ekliptik nach Westen befinden sich die zusammenhängenden '''Wassersternbilder''' des Urozeans, dem Urquell des Lebens. Es handelt ich um die heutigen Sternbilder Fluss Eridanus, Walfisch (Cetus), Fische (Pisces), Wassermann (Aquarius), Südlicher Fisch (Piscis Austrinus) und Delphin (Delphinus) sowie Steinbock (Capricornus, früher Ziegenfisch).

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Urozean''']].

&lt;gallery caption=&quot;Das Lamm zur Rechten des Stieres&quot; mode=packed widths=800 heights=600&gt;
Himmelsstier.P1117152.jpg|Astrophotographie vom Asterismus Himmelsstier
Himmelsstier.Sternbilder.P1117152.png|Beschriftete Astrophotographie vom Himmelsstier am winterlichen Abendhimmel in Richtung südlicher Meridian. Die Ekliptiklinie verläuft horizontal etwas unterhalb der Bildmitte.
Haende.der.Thuraya.Vollmond.Sterne.P1079912.jpg|Astrophotographie der Himmelsregion mit dem beduinischen Sternbild &quot;Hände der Thuraya&quot; (grüne durchgezogene Linien, Ekliptik rot gepunktete Linie) mit arabisch bezeichneten Sternen. Der Vollmond befindet sich zwischen den Sternbildern Taurus, Aries und Cetus.
Urozean.Wassersternbilder.png|Die zusammenhängenden Wassersternbilder des Urozeans am Sternenhimmel: Fluss Eridanus, Walfisch (Cetus), Fische (Pisces), Wassermann (Aquarius), Südlicher Fisch (Piscis Austrinus), Delphin (Delphinus) sowie Ziegenfisch (Steinbock, Capricornus).
&lt;/gallery&gt;

Interpretiert man das Sternbild &quot;Lamm&quot; (Widder / Aries) als Mittler auf dem ekliptischen Weg vom finsteren kosmischen Urozean im Westen (rechts) zum strahlenden majestätischen Sternbild Stier (Taurus) im Osten (links), ergeben auch andere Bibelstellen in Bezug auf den Sternenhimmel einen tiefen symbolischen Sinn, die in den folgenden Abschnitten aufgeführt sind.

==== Evangelium nach Johannes ====
Die Rede von Jesus an den Jünger Thomas aus dem 14.&amp;nbsp;Kapitel des Evangeliums nach Johannes ist in diesem Zusammenhang interessant:

&lt;blockquote&gt;
6 Jesus sagte zu ihm: Ich bin der Weg und die Wahrheit und das Leben; niemand kommt zum Vater außer durch mich.&lt;br/&gt;
7 Wenn ihr mich erkannt habt, werdet ihr auch meinen Vater erkennen. Schon jetzt kennt ihr ihn und habt ihn gesehen.
&lt;/blockquote&gt;

Alle Wandelgestirne bewegen sich entlang der Ekliptiklinie (Weg) durch das heutige Sternbild Widder (das altarabische Sternbild &quot;Lamm&quot;) im Westen zum [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der-Ekliptik|Goldenen Tor der Ekliptik]] nach Osten im großen Himmelsstier (Vater / Thron).

==== Evangelium nach Markus ====
Im Evangelium nach Markus heißt es:

&lt;blockquote&gt;
14,62 Jesus sagte: Ich bin es. Und ihr werdet den Menschensohn '''zur Rechten der Macht''' sitzen und mit den Wolken des '''Himmels''' kommen sehen.
&lt;/blockquote&gt;

&lt;blockquote&gt;
16,19 Nachdem Jesus, der Herr, dies zu ihnen gesagt hatte, wurde er in den '''Himmel''' aufgenommen und setzte sich '''zur Rechten Gottes'''.
&lt;/blockquote&gt;

==== Evangelium nach Lukas ====
Im Evangelium nach Lukas ist es folgendermaßen formuliert:

&lt;blockquote&gt;
22,69 Von nun an wird der Menschensohn '''zur Rechten der Macht Gottes''' sitzen.
&lt;/blockquote&gt;

==== Evangelium nach Matthäus ====
Auch im Evangelium nach Matthäus findet sich eine entsprechende Stelle:

&lt;blockquote&gt;
26,64 Jesus antwortete: Du hast es gesagt. Doch ich erkläre euch: Von nun an werdet ihr den Menschensohn '''zur Rechten der Macht''' sitzen und auf den Wolken des '''Himmels''' kommen sehen.
&lt;/blockquote&gt;

==== Brief an die Hebräer ====
Im Brief an die Hebräer, dessen Autor unbekannt ist, gibt es etliche entsprechende Stellen:

&lt;blockquote&gt;
'''Gottes Rede in seinem Sohn'''&lt;br/&gt;
1,3 er ist der Abglanz seiner Herrlichkeit und das Abbild seines Wesens; er trägt '''das All''' durch sein machtvolles Wort, hat die Reinigung von den Sünden bewirkt und sich dann '''zur Rechten der Majestät in der Höhe''' gesetzt;&lt;br/&gt;
1,10 Und: Du, Herr, hast vorzeiten der Erde Grund gelegt, die '''Himmel''' sind das Werk deiner Hände.&lt;br/&gt;
1,11 Sie werden vergehen, '''du aber bleibst'''; sie alle veralten wie ein Gewand;&lt;br/&gt;
1,12 du rollst sie zusammen wie einen Mantel und wie ein Gewand werden sie gewechselt. Du aber bleibst, der du bist, und '''deine Jahre enden nie'''.&lt;br/&gt;
1,13 Zu welchem Engel hat er jemals gesagt: Setze dich mir '''zur Rechten''' und ich lege dir deine Feinde als Schemel unter die Füße?
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Die Liturgie des neuen Bundes'''&lt;br/&gt;
8,1 Die Hauptsache bei dem Gesagten aber ist: Wir haben einen solchen Hohepriester, der sich '''zur Rechten des Thrones der Majestät im Himmel''' gesetzt hat,&lt;br/&gt;
8,2 als Diener des Heiligtums und des '''wahren Zeltes''', das der Herr selbst aufgeschlagen hat, nicht ein Mensch.
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Christus als Mittler des neuen Bundes'''&lt;br/&gt;
9,24 Denn Christus ist nicht in ein von Menschenhand gemachtes Heiligtum hineingegangen, in ein Abbild des wirklichen, sondern '''in den Himmel selbst''', um jetzt '''vor Gottes Angesicht''' zu erscheinen für uns;
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Das Opfer Jesu Christi als endgültige Versöhnung mit Gott'''&lt;br/&gt;
10,12 Dieser aber hat nur ein einziges Opfer für die Sünden dargebracht und sich dann '''für immer zur Rechten Gottes''' gesetzt;
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Das Beispiel Jesu Christi'''&lt;br/&gt;
12,2 und dabei auf Jesus blicken, den Urheber und Vollender des Glaubens; er hat angesichts der vor ihm liegenden Freude das Kreuz auf sich genommen, ohne auf die Schande zu achten, und sich '''zur Rechten von Gottes Thron''' gesetzt.
&lt;/blockquote&gt;

==== Erster Brief des Petrus ====
Der erste Brief des Petrus zählt zu den katholischen Briefen des Neuen Testaments. Dort heißt es im letzten Satz über Jesus Christus:

&lt;blockquote&gt;
22 der in den '''Himmel''' gegangen ist; dort ist er '''zur Rechten''' Gottes und Engel, Gewalten und Mächte sind ihm unterworfen.
&lt;/blockquote&gt;

==== Apostelgeschichte ====
Die Apostelgeschichte schließt an das Evangelium nach Lukas an und wird ebenfalls diesem zugeschrieben. Hier kommen der erste bekennende sowie erste berufene Apostel Petrus und der erste christliche Märtyrer Stephanus zu Wort:

&lt;blockquote&gt;
'''Die Pfingstpredigt des Petrus'''&lt;br/&gt;
2,33 '''Zur Rechten Gottes''' erhöht, hat er vom Vater den verheißenen Heiligen Geist empfangen und ihn ausgegossen, wie ihr seht und hört.
&lt;/blockquote&gt;

&lt;blockquote&gt;
'''Steinigung des Stephanus'''&lt;br/&gt;
7,55 Er aber, erfüllt vom Heiligen Geist, blickte zum '''Himmel''' empor, sah die Herrlichkeit Gottes und Jesus '''zur Rechten Gottes''' stehen&lt;br/&gt;
7,56 und rief: Siehe, ich sehe den Himmel offen und den Menschensohn '''zur Rechten Gottes''' stehen.
&lt;/blockquote&gt;

=== Himmelspforte ===
Das Sternbild Widder (Aries) repräsentiert als das Lamm Gottes den nördlichen Pfeiler des Goldenen Tors der Ekliptik. Der fette Schwanz des Lammes wird nach altarabischer Tradition durch das Siebengestirn (Plejaden) gebildet, das heute zu Sternbild '''Stier''' (Taurus) gezählt wird. Der südliche Pfeiler des Goldenen Tors der Ekliptik wird durch die Hyaden und den Stern Menkar im Sternbild Walfisch (Cetus) gebildet. Das Goldene Tor der Ekliptik stellt mit diesen beiden Pfeilern somit eine '''Himmelspforte''' dar, durch die alle Wandelgestirne regelmäßig von Westen aus dem dunklen Urozean der winterlichen Wassersternbilder sowie der Richtung des Sonnenuntergangs nach Osten in das helle Gebiet des Sternenhimmels mit den Frühlings- und Sommersternbildern sowie die Richtung des Sonnenaufgangs treten.

[[Datei:Mars.im.Goldenen.Tor.der.Ekliptik.P1091607.jpg|mini|hochkant=3|zentriert|Der am nordwestlichen Horizont in der Nähe der Ekliptiklinie und im Goldenen Tor der Ekliptik untergehende Mars (rote Scheibe unten halb rechts) drei Tage vor dem Durchqueren der '''Himmelspforte''' zwischen dem Kopf des Himmelsstieres mit dem Sternhaufen der Hyaden (unten links) und den Plejaden nördlich der Ekliptik (rechts unten).]]

Die Genesis berichtet im 28.&amp;nbsp;Kapitel unter der Überschrift &quot;Jakob in Bet-El&quot; (hebräisch בֵּית אֵל „Haus des El“ oder „Haus Gottes“) über einen Traum von Jakob, in dem er eine Treppe zum Himmel (die Himmelsleiter oder Jakobsleiter) sieht, an dessen oberen Ende sich das Tor des Himmels (die Himmelspforte) befindet:

&lt;blockquote&gt;
10 Jakob zog aus Beerscheba weg und ging nach Haran.&lt;br/&gt;
11 Er kam an einen bestimmten Ort und übernachtete dort, denn die Sonne war untergegangen. Er nahm einen von den Steinen dieses Ortes, legte ihn unter seinen Kopf und schlief dort ein.&lt;br/&gt;
12 Da hatte er einen Traum: Siehe, eine Treppe stand auf der Erde, ihre Spitze reichte bis zum '''Himmel'''. Und siehe: Auf ihr stiegen Engel Gottes auf und nieder.&lt;br/&gt;
13 Und siehe, der HERR stand vor ihm und sprach: Ich bin der HERR, der Gott deines Vaters Abraham und der Gott Isaaks. Das Land, auf dem du liegst, will ich dir und deinen Nachkommen geben.&lt;br/&gt;
14 Deine Nachkommen werden zahlreich sein wie der Staub auf der Erde. Du wirst dich '''nach Westen und Osten, nach Norden und Süden''' ausbreiten und durch dich und deine Nachkommen werden alle Sippen der Erde Segen erlangen.&lt;br/&gt;
15 Siehe, ich bin mit dir, ich behüte dich, wohin du auch gehst, und bringe dich zurück in dieses Land. Denn ich verlasse dich nicht, bis ich vollbringe, was ich dir versprochen habe.&lt;br/&gt;
16 Jakob erwachte aus seinem Schlaf und sagte: Wirklich, der HERR ist an diesem Ort und ich wusste es nicht.&lt;br/&gt;
17 Er fürchtete sich und sagte: Wie Ehrfurcht gebietend ist doch dieser Ort! Er ist nichts anderes als das Haus Gottes und das '''Tor des Himmels'''.&lt;br/&gt;
&lt;/blockquote&gt;

El war für die semitischen Ugariter im zweiten vorchristlichen Jahrtausend der Name ihres höchsten Gottes. Ihm wurden die Beinamen „König“, „Freundlicher“ und „'''Stier'''“ verliehen. Diese Symbolik weist auf den Himmelsstier hin. Der Name El wurde von den Israeliten übernommen, und dieser Gott wurde von ihnen mit ihrem einzigen Gott gleichgesetzt. Der Gott El wurde vom Gott Baal verdrängt, der ebenfalls mit Stierhörnern konnotiert war. Er wurde auch als donnernder und Blitze schleudernder Gott dargestellt, was sich in den Mythen des antiken Griechenlands in der Figur des höchsten griechischen Gottes Zeus (Jupiter) widerspiegelt. In diesem Zusammenhang sei auf noch weitere Parallelitäten den verschiedenen Götterkulturen hingewiesen, die sich zum ugaritischen Baal-Zyklus ergeben, der in den keilalphabetischen Texten aus Ugarit (KTU) zu finden ist. Am Schluss dieses Werkes wird die kanaanitische Sonnengöttin Šapšu, die Zweitfrau von El, für die Wiederherstellung und Bewahrung der kosmischen Ordnung zu einem Opfermahl eingeladen, bei der ihr '''Brot und Wein''' dargeboten werden.&lt;ref&gt;Herbert Niehr: ''Der Ba‘al-Zyklus (KTU 1.1-6 + 1.8)'', Gütersloh 2015, S. 236.&lt;/ref&gt; In Psalm&amp;nbsp;65 mit dem Titel &quot;Lobpreis auf den Retter und Schöpfer&quot; werden dem Gott der Israeliten ganz ähnliche Wohltaten zugeschrieben, wie dem Gott Baal in der ugaritischen Religion. Im 10.&amp;nbsp;Psalmvers heißt es beispielsweise:

&lt;blockquote&gt;
10 Du hast für das Land gesorgt, es getränkt, es überschüttet mit Reichtum. Der Bach Gottes ist voller Wasser, gedeihen lässt du ihnen das Korn, so lässt du das Land gedeihen.
&lt;/blockquote&gt;

Jakob war der der erste der drei Erzväter des Volkes Israel und der älteste Sohn des ältesten Sohnes Isaak von Abraham. Abraham war aus dem mesopotamischen Ur über Haran nach Bet-El gezogen, und Jakob ging in dieser Schilderung aus Beerscheba in der Nähe des Ortes Bet-El nach Haran zurück.

Der Apostel Paulus schreibt in seinem zweiten Brief an die Bewohner der griechischen Hafenstadt Korinth zu Beginn des 5.&amp;nbsp;Kapitels mit der Überschrift &quot;Die Hoffnung des Apostels&quot; über das Gebäude hinter der Pforte zum Himmel:

&lt;blockquote&gt;
1 Wir wissen: Wenn unser irdisches Zelt abgebrochen wird, dann haben wir eine Wohnung von Gott, ein nicht von Menschenhand errichtetes '''ewiges Haus im Himmel'''.
&lt;/blockquote&gt;

=== Gedanken zur wundersamen Brotvermehrung ===
==== Evangelien ====
[[Datei:Face de chapiteau figurant la Multiplication des pains, choeur de l'église de Saint-Nectaire, Puy-de-Dôme.jpg|mini|rechts|hochkant=2|Jesus mit vier seiner Jünger mit fünf Broten und zwei Fischen an einem Säulenkapitell in der romanischen Wallfahrtskirche Saint Nectaire auf dem Mont Cornadore in Saint-Nectaire in Frankreich (Département Puy-de-Dôme in der Region Auvergne-Rhône-Alpes).]]

Die wundersame Speisung der mehreren Tausend mit wenigen Broten und Fischen wird in aller vier Evangelien der Bibel erwähnt. Das Ereignis fand auf einem Berg am Ufer des Sees von Galiläa (auch als &quot;See von Tiberias&quot;, &quot;See Genezareth&quot; oder &quot;Galiläisches Meer&quot; bekannt) statt. In der abgelegenen Gegend gab es damals sehr wenig künstliche Lichtquellen, so dass ein ungestörter Anblick des Sternenhimmels möglich war.

===== Evangelium nach Johannes =====
Im sechsten Kapitel des Evangeliums nach '''Johannes''' tauchen bei der Beschreibung der Brotvermehrung durch Jesus zum jüdischen Pessachfest neben einigen weiteren Symbolen mit astronomischer Deutungsmöglichkeit auch die expliziten Zahlen Zwei, Fünf und Zwölf auf:

&lt;blockquote&gt;
9 Hier ist ein kleiner Junge, der hat '''fünf Gerstenbrote''' und '''zwei Fische'''; doch was ist das für so viele?&lt;br/&gt;
10 Jesus sagte: Lasst die Leute sich setzen! Es gab dort nämlich viel Gras. Da setzten sie sich; es waren etwa '''fünftausend''' Männer.&lt;br/&gt;
11 Dann nahm Jesus die '''Brote''', sprach das Dankgebet und teilte an die Leute aus, so viel sie wollten; ebenso machte er es mit den '''Fischen'''.&lt;br/&gt;
12 Als die Menge satt geworden war, sagte er zu seinen Jüngern: Sammelt die übrig gebliebenen Brocken, damit nichts verdirbt!&lt;br/&gt;
13 Sie sammelten und füllten '''zwölf Körbe''' mit den Brocken, die von den '''fünf Gerstenbroten''' nach dem Essen übrig waren.&lt;br/&gt;
...&lt;br/&gt;
31 Unsere Väter haben das '''Manna''' in der Wüste gegessen, wie es in der Schrift heißt: '''Brot vom Himmel''' gab er ihnen zu essen.&lt;br/&gt;
32 Jesus sagte zu ihnen: Amen, amen, ich sage euch: Nicht Mose hat euch das '''Brot vom Himmel''' gegeben, sondern mein Vater gibt euch das wahre '''Brot vom Himmel'''.&lt;br/&gt;
33 Denn das '''Brot''', das Gott gibt, kommt vom '''Himmel''' herab und gibt der Welt das Leben.&lt;br/&gt;
34 Da baten sie ihn: Herr, gib uns immer dieses '''Brot'''!&lt;br/&gt;
35 Jesus antwortete ihnen: Ich bin das '''Brot des Lebens'''; wer zu mir kommt, wird nie mehr hungern, und wer an mich glaubt, wird nie mehr Durst haben.&lt;br/&gt;
...&lt;br/&gt;
48 Ich bin das '''Brot des Lebens'''.&lt;br/&gt;
49 Eure Väter haben in der Wüste das '''Manna''' gegessen und sind gestorben.&lt;br/&gt;
50 So aber ist es mit dem '''Brot''', das vom '''Himmel''' herabkommt: Wenn jemand davon isst, wird er nicht sterben.&lt;br/&gt;
51 Ich bin das '''lebendige Brot''', das vom '''Himmel''' herabgekommen ist. Wer von diesem '''Brot''' isst, wird in Ewigkeit leben. Das '''Brot''', das ich geben werde, ist mein Fleisch für das Leben der Welt.
&lt;/blockquote&gt;

===== Evangelium nach Markus =====
Eine ähnliche Schilderung befindet sich im sechsten Kapitel des Evangeliums nach '''Markus''', wo das Ereignis an einem abgelegenen und einsamen Ort stattgefunden hat:

&lt;blockquote&gt;
38 Er sagte zu ihnen: Wie viele '''Brote''' habt ihr? Geht und seht nach! Sie sahen nach und berichteten: '''Fünf Brote''' und außerdem '''zwei Fische'''.&lt;br/&gt;
39 Dann befahl er ihnen, sie sollten sich in Mahlgemeinschaften im grünen Gras lagern.&lt;br/&gt;
40 Und sie ließen sich in Gruppen zu hundert und zu fünfzig nieder.&lt;br/&gt;
41 Darauf nahm er die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis, brach die '''Brote''' und gab sie den Jüngern, damit sie diese an die Leute austeilten. Auch die '''zwei Fische''' ließ er unter allen verteilen.&lt;br/&gt;
42 Und alle aßen und wurden satt.&lt;br/&gt;
43 Und sie hoben Brocken auf, '''zwölf Körbe''' voll, und Reste von den '''Fischen'''.&lt;br/&gt;
44 Es waren '''fünftausend''' Männer, die von den '''Broten''' gegessen hatten.
&lt;/blockquote&gt;

Die Brotvermehrung auch ein weiteres Mal im achten Kapitel des Evangeliums nach '''Markus''' erwähnt:

&lt;blockquote&gt;
5 Er fragte sie: Wie viele '''Brote''' habt ihr? Sie antworteten: '''Sieben'''.&lt;br/&gt;
6 Da forderte er die Leute auf, sich auf den Boden zu setzen. Dann nahm er die sieben '''Brote''', sprach das Dankgebet, brach die '''Brote''' und gab sie seinen Jüngern zum Verteilen; und die Jünger teilten sie an die Leute aus.&lt;br/&gt;
7 Sie hatten auch noch ein paar '''Fische''' bei sich. Jesus segnete sie und ließ auch sie austeilen.&lt;br/&gt;
8 Die Leute aßen und wurden satt. Und sie hoben die Überreste der '''Brotstücke''' auf, '''sieben Körbe''' voll.&lt;br/&gt;
9 Es waren etwa '''viertausend''' Menschen beisammen. Danach schickte er sie nach Hause.&lt;br/&gt;
...&lt;br/&gt;
19 Als ich die '''fünf Brote''' für die '''Fünftausend''' brach, wie viele '''Körbe voll Brotstücke''' habt ihr da aufgehoben? Sie antworteten ihm: '''Zwölf'''.&lt;br/&gt;
20 Und als ich die '''sieben Brote''' für die '''Viertausend''' brach, wie viele '''Körbe''' voll habt ihr da aufgehoben? Sie antworteten: '''Sieben'''.&lt;br/&gt;
21 Da sagte er zu ihnen: Versteht ihr immer noch nicht?
&lt;/blockquote&gt;

===== Evangelium nach Lukas =====
Ebenso verhält es sich im neunten Kapitel des Evangeliums nach '''Lukas''', wo das Ereignis dem Ort Betsaida (zu Deutsch: „Haus des Fisches“) am See Genezareth zugeordnet ist:

&lt;blockquote&gt;
12 Als der Tag zur Neige ging, kamen '''die Zwölf''' und sagten zu ihm: Schick die Leute weg, damit sie in die umliegenden Dörfer und Gehöfte gehen, dort Unterkunft finden und etwas zu essen bekommen; denn wir sind hier an einem abgelegenen Ort.&lt;br/&gt;
13 Er antwortete ihnen: Gebt ihr ihnen zu essen! Sie sagten: Wir haben nicht mehr als '''fünf Brote''' und '''zwei Fische'''; wir müssten erst weggehen und für dieses ganze Volk etwas zu essen kaufen.&lt;br/&gt;
14 Es waren nämlich etwa '''fünftausend''' Männer. Er aber sagte zu seinen Jüngern: Lasst sie sich in Gruppen zu ungefähr fünfzig lagern!&lt;br/&gt;
15 Die Jünger taten so und veranlassten, dass sich alle lagerten.&lt;br/&gt;
16 Jesus aber nahm die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis und brach sie; dann gab er sie den Jüngern, damit sie diese an die Leute austeilten.&lt;br/&gt;
17 Und alle aßen und wurden satt. Als man die übrig gebliebenen Brotstücke einsammelte, waren es '''zwölf Körbe''' voll.
&lt;/blockquote&gt;

===== Evangelium nach Matthäus =====
Auch im vierzehnten Kapitel des Evangeliums nach '''Matthäus''' ist von einem abgelegenen Ort in einer einsamen Gegend die Rede:

&lt;blockquote&gt;
17 Sie sagten zu ihm: Wir haben nur '''fünf Brote''' und '''zwei Fische''' hier.&lt;br/&gt;
18 Er antwortete: Bringt sie mir her!&lt;br/&gt;
19 Dann ordnete er an, die Leute sollten sich ins Gras setzen. Und er nahm die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis, brach die Brote und gab sie den Jüngern; die Jünger aber gaben sie den Leuten&lt;br/&gt;
20 und alle aßen und wurden satt. Und sie sammelten die übrig gebliebenen Brotstücke ein, '''zwölf Körbe''' voll.&lt;br/&gt;
21 Es waren etwa '''fünftausend''' Männer, die gegessen hatten, dazu noch Frauen und Kinder.
&lt;/blockquote&gt;

Etwas abgewandelt taucht die Brotvermehrung mit '''sieben Körben''' auch im fünfzehnten Kapitel des Evangeliums nach '''Matthäus''' auf:

&lt;blockquote&gt;
34 Jesus sagte zu ihnen: Wie viele '''Brote''' habt ihr? Sie antworteten: '''Sieben''' - und ein paar '''Fische'''.&lt;br/&gt;
35 Da forderte er die Leute auf, sich auf den Boden zu setzen.&lt;br/&gt;
36 Und er nahm die '''sieben Brote''' und die '''Fische''', sprach das Dankgebet, brach sie und gab sie den Jüngern und die Jünger gaben sie den Menschen.&lt;br/&gt;
37 Und alle aßen und wurden satt. Und sie sammelten die übrig gebliebenen Stücke ein, '''sieben Körbe''' voll.&lt;br/&gt;
38 Es waren '''viertausend''' Männer, die gegessen hatten, dazu noch Frauen und Kinder.&lt;br/&gt;
39 Danach schickte er die Menge nach Hause, stieg ins Boot und fuhr in die Gegend von Magadan.
&lt;/blockquote&gt;

Der Ort Magadan ist möglicherweise mit dem heutigen Ort Migdal (aramäisch: Magdala) am westlichen Ufer des Sees Genezareth gleichzusetzen.

==== Astronomische Bezüge ====
[[Datei:Sternenhimmel.Pessach.25.3.23.png|mini|rechts|hochkant=2|Sternenhimmel am jüdischen Pessachfest im Jahr 25 nach Christus. Der Vollmond stand hoch über dem Horizont im Süden im Herbstpunkt beim Stern Spica (= &quot;Kornähre&quot;) im Sternbild Jungfrau (Virgo). Gleichzeitig befand sich die Sonne tief unter dem Horizont im Norden in der Nähe des Frühlingspunktes im Sternbild Fische (Pisces).]]
[[Datei:Dendera.09.Jungfrau.Loewe.jpg|mini|rechts|hochkant=2|Das Sternbild Jungfrau (links) mit der Kornähre in der Hand und das Sternbild Löwe (rechts) im ägyptischen Zodiak von Dendera aus der Zeit kurz vor Christi Geburt.]]
[[Datei:Dendera.03.Fische.Wassermann.jpg|mini|rechts|hochkant=2|Das Sternbild Fische (links) und das Sternbild Wassermann (rechts unten) im ägyptischen Zodiak von Dendera aus der Zeit kurz vor Christi Geburt.]]

Zu diesen Bibelstellen sind im Folgenden einige Hinweise mit astronomischen Bezügen aufgeführt. Die [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|Bezugspunkte]] liegen hierbei in der Nähe der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Die_Ekliptik|Ekliptik]]:

* In den Versen im Evangelium nach Johannes ist mehrfach vom '''Brot, das vom Himmel herabkommt''' die Rede.
* Das zur Herstellung von Brot erforderliche Getreide kann durch eine '''Kornähre''' symbolisiert werden. Am Sternenhimmel wird die Kornähre durch den hellen, ekliptiknahen Stern '''Spica''' (α Virginis) im Sternbild '''Jungfrau''' (Virgo) repräsentiert. Der Vollmond stand zum jüdischen Pessachfest beim Stern Spica.
* Alle Pflanzen benötigen für das Gedeihen '''Wasser'''. Das '''Wasser''' wird am Himmel durch die drei Wassersternbilder der Ekliptik '''Fische''' (Pisces), '''Wassermann''' (Aquarius), und '''Ziegenfisch''' (Steinbock, Capricornus) westlich des [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Frühlingspunkt|Frühlingspunktes]] repräsentiert. Diese Sternbilder bilden mit einigen weiteren angrenzenden Wassersternbildern den [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|Urozean am Himmel]] (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Trichter_der_Thuraya|Der Trichter der Thuraya]]). Die Wassersternbilder waren zum Pessachfest in den drei Monaten unmittelbar zuvor von der Sonne durchlaufen worden und befanden sich beim Sonnenuntergang deshalb bereits unterhalb des westlichen Horizonts.
* Das Sternbild '''Fische''' (Pisces) besteht seit der Antike aus '''zwei Fischen'''.
* Zu Lebzeiten von Jesus von Nazareth war der '''Frühlingspunkt''' vom Sternbild Widder (Aries, ursprünglich das Hinterteil des großen Sternbilds [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|Himmelsstier (Taurus caeli)]]) in das Sternbild '''Fische''' (Pisces) gewandert. Inzwischen ist er innerhalb dieses Sternbilds noch weiter nach Westen gewandert. Die Sonne und der Neumond standen zu Beginn des jüdischen Monats Nisan, also dem Monat des jüdischen Pessachfestes, im Sternbild '''Fische'''. Der erste Monat des Jahres Nisan hieß bereits in der mesopotamischen Tradition, als sich der Frühlingspunkt noch im Sternbild Widder (Aries) befand, auf Akkadisch &quot;nisannu&quot; (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|Plejaden-Schaltregeln]]). In der alten jüdischen Tradition war der Nisan deswegen mit dem Sternbild Widder verbunden. Ferner wurde der Widder dem israelitischen Stamm Juda zugeordnet.
* Zu Lebzeiten von Jesus von Nazareth war der '''Herbstpunkt''' vom Sternbild Waage (Libra, ursprünglich die Scheren des großen Sternbilds [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsskorpion|Himmelsskorpion (Scorpio caeli)]]) in das Sternbild Jungfrau (Virgo) gewandert. Inzwischen ist er innerhalb dieses Sternbilds noch weiter nach Westen gewandert. Um 285 nach Christi erreichte der '''Herbstpunkt''' dann die ekliptikale Länge des Sterns '''Spica''' (α Virginis).
* Der '''Frühlingspunkt''' –&amp;nbsp;damals im Sternbild Fische&amp;nbsp;– und der '''Herbstpunkt''' –&amp;nbsp;damals im Sternbild Jungfrau (Virgo) beim Stern Spica&amp;nbsp;– befinden sich immer in genau gegenüber liegenden Punkten auf der Ekliptik. Auf diese Weise umfassen diese beiden ausgezeichneten Punkte den Lebewesenkreis (Zodiak) mit seinen '''zwölf''' Sternbildern sowie die Bahnen aller '''sieben''' Wandelgestirne. Diese beiden Punkte teilten die Ekliptik in '''zwei''' gleichgroße Teile, das Sommerhalbjahr und das Winterhalbjahr. Siehe hierzu auch &quot;[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|Beobachtungen in der Nähe der Ekliptik]]&quot;.
** Die '''fünf Brote''' können also mit den fünf mit bloßem Auge sichtbaren Wandelgestirnen (Planeten) '''Merkur''', '''Venus''', '''Mars''', '''Jupiter '''und '''Saturn''' gleichgesetzt werden.&lt;br/&gt;'''''Anmerkung''': In der Bibel wird in der Regel nicht zwischen Fixsternen und Planeten unterschieden. Für eine Ausnahme siehe 2.&amp;nbsp;Buch der Könige, Kapitel 23, Vers 5 aus dem siebenten vorchristlichen Jahrhundert, wo in der Einheitsübersetzung explizit von &quot;den Wandelsternen&quot; und in der Luther-Bibel von &quot;den Planeten&quot; die Rede ist.&lt;ref&gt;[https://www.bibleserver.com/EU/2.K%C3%B6nige23%2C5 2.&amp;nbsp;Buch der Könige, Kapitel 23, Vers 5], bibleserver.com, Einheitsübersetzung 2016&lt;/ref&gt; Die Vulgata schreibt hier allerdings von den &quot;duodecim signis&quot; (zu Deutsch: &quot;'''zwölf''' Zeichen&quot;), womit die '''zwölf''' Sternzeichen der Ekliptik gemeint sind, durch die die '''sieben''' Wandelgestirne ziehen. Die Septuaginta spricht noch allgemeiner von den &quot;μαζουρωθ&quot; (&quot;mazuroth&quot;) nach dem Hebräischen Wort &quot;מַזָּלָה&quot; (&quot;mazzaroth&quot;), womit allgemein eher Sternkonstellationen und nur im engeren Sinne die Sternzeichen des Zodiaks gemeint sind.''
** Die '''zwei Fische''' können also mit den beiden flächenhaft wahrnehmbaren Wandelgestirnen '''Sonne''' und '''Mond '''gleichgesetzt werden.
** Die Summe der '''fünf Brote''' und der '''zwei Fische''' respektive die '''sieben Brote''' (oder die '''sieben Körbe''') entsprechen der Anzahl der freiäugig sichtbaren '''sieben Wandelgestirne''', die sich entlang der Ekliptiklinie stetig gegenüber dem Fixsternhimmel bewegen. Siehe hierzu auch &quot;[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Zusammenhang_mit_dem_Stier|Zu den Etyma und den Kognaten von &quot;Sieben&quot;, &quot;Stier&quot;, &quot;Gestirn&quot; und &quot;Stern&quot;]]&quot;.
** Die ausgeteilten '''Brote''' und '''Fische''' durchmaßen die gesamte versammelte Menschenmenge, die durch den vollständigen [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|Lebewesenkreis (Zodiak)]] mit den '''zwölf Lebewesenkreiszeichen''' beziehungsweise durch die '''zwölf Körbe''' symbolisiert wird. Der Planet Jupiter, der den Zodiak in zwölf Jahren einmal durchläuft, wurde in Babylonien mit dem babylonischen Hauptgott Marduk gleichgesetzt.
* Insgesamt gibt es am Fixsternhimmel gut 2800&amp;nbsp;Sterne bis zur scheinbaren Helligkeit 5,5&lt;sup&gt;m&lt;/sup&gt; und knapp 8800&amp;nbsp;Sterne bis zur scheinbaren Helligkeit&amp;nbsp;6,5&lt;sup&gt;m&lt;/sup&gt;, die ohne Lichtverschmutzung mit bloßem Auge als einzelne Lichtpunkte gesehen werden können. Diese verteilen sich allerdings in der gesamten Himmelssphäre, so dass von einem Punkt auf der Erdoberfläche aus zu jedem Zeitpunkt immer nur ungefähr die Hälfte davon über dem Horizont steht. An den beiden Polen sind stets nur die Sterne der jeweiligen nördlichen oder südlichen Hemisphäre zu sehen, und am Äquator können im Laufe eines Jahres alle Sterne gesehen werden. Je nach Breitengrad und Zeitpunkt können bei Neumond (kein Streulicht) innerhalb einer wolkenlosen Nacht viertausend bis zu fast siebentausend Sterne beobachtet werden.&lt;ref&gt;Bob King: [https://skyandtelescope.org/astronomy-blogs/how-many-stars-night-sky-09172014/ 9,096 Stars in the Sky—Is that all? How many stars in the sky can you see?], skyandtelescope.org - The essential Guide to Astronomy, 17. September 2014&lt;/ref&gt; Diese Spanne entspricht der Angabe der bei der Brotvermehrung versammelten Menschen, deren Anzahl in den Evangelien mit '''viertausend''' beziehungsweise '''fünftausend''' angegeben ist.
** Im ersten Buch des Alten Testaments ('''Genesis''') wird Abram aus Ur in Mesopotamien bereits das Folgende prophezeit:
&lt;blockquote&gt;
15,5 ''Sieh doch zum Himmel hinauf und zähl die Sterne, wenn du sie zählen kannst! Und er sprach zu ihm: So zahlreich werden deine Nachkommen sein''&lt;br/&gt;
...&lt;br/&gt;
17,5 ''Man wird dich nicht mehr Abram nennen. Abraham, Vater der Menge, wird dein Name sein; denn zum Stammvater einer Menge von Völkern habe ich dich bestimmt.''
&lt;/blockquote&gt;
* Die Gruppen von (ungefähr) '''fünfzig''' oder '''hundert Männern''' entsprechen den Sternbildern, die über den gesamten Himmel verteilt sind. Nach der Festlegung der Internationalen Astronomischen Union (IAU) von 1930 gibt es heute 88&amp;nbsp;Sternbilder, die den Himmel vollständig abdecken. Mit den maximal fast 8800&amp;nbsp;freiäugig sichtbaren Sternen entspricht dies im Mittel also 100&amp;nbsp;Sternen pro Sternbild. Bei 4400&amp;nbsp;freiäugig sichtbaren Sternen wären es 50&amp;nbsp;Sterne pro Sternbild. Dies entspricht genau der Spanne der Gruppenstärke, die im Neuen Testament angegeben sind.
* Das '''Brot''' und der '''Wein''' werden nach der christlichen Lehre bei der Transsubstantiation in den Leib und das Blut des vom '''Himmel''' herabgekommenen &quot;Brot des Lebens&quot; (vergleiche die Rede über das Himmelsbrot von Jesus in der Synagoge von Kafarnaum in Evangelium nach Johannes 6,48–58) gewandelt, das die kosmische Ewigkeit verheißt.

Die Zahlen '''Zwei''', '''Fünf''', '''Sieben''' und '''Zwölf''' stehen in einem einfachen arithmetischen Zusammenhang, bei dem die beiden jeweils vorhergehenden Zahlen der Folge addiert werden:

{| class=&quot;wikitable&quot;
|+
|'''Zahl'''
|'''Summe'''
|'''Anmerkung'''
|-
|'''2'''
|
|Anzahl der freiäugig als '''flächenhaft wahrnehmbaren Wandelgestirne''' ('''Sonne''' und '''Mond'''), siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwei|Zur Zwei]]
|-
|'''5'''
|
|Anzahl der freiäugig als '''punktförmig wahrnehmbaren Wandelgestirne''' '''Merkur''', '''Venus''', '''Mars''', '''Jupiter''', '''Saturn'''
|-
|'''7'''
|= 2 + 5
|Anzahl der freiäugig wahrnehmbaren '''Wandelgestirne''' sowie der '''Tage in der Woche''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Sieben|Zur Sieben]]
|-
|'''12'''
|= 5 + 7
|Anzahl der '''Monate im Jahr''', der '''Lebewesenkreiszeichen des Zodiaks''' sowie der '''Erdenjahre pro Jupiterjahr''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwölf|Zur Zwölf]], vergleiche hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|Der Zodiak]]
|-
|'''19'''
|= 7 + 12
|Anzahl der '''Jahre''' mit '''zwölf Monaten''' und '''sieben Schaltmonaten''' einer '''Meton-Periode''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Neunzehn|Zur Neunzehn]], vergleiche hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|Die Plejaden-Schaltregeln]] und [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Mondzyklen#Der_Meton-Zyklus|Der Meton-Zyklus]]
|}

=== Weitere Bezüge ===
Weitere Bezüge von der Astronomie zur Theologie ergeben sich bei den folgenden Sachverhalten:

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Biblische_Erwähnungen|'''biblische Erwähnungen von Konstellationen''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Der_Stern_von_Bethlehem|'''Der Stern von Bethlehem''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Ochs_und_Esel|'''Ochs und Esel / Krippe / „Ich bin das Alpha und das Omega“''']].

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Biblische_Bezüge|'''Biblische Bezüge zu den Mondhäusern / Mondstationen''']].

== Zur Kosmologie ==
[[Datei:Kosmologisches.Modell.Schwarze.Schale.Rotverschiebung.png|mini|rechts|hochkant=2.5|Ein kosmologisches Modell unseres im Zentrum isotropen und inhomogenen Universums, das von einer undurchsichtigen und massereichen schwarzen Kugelschale umgeben ist. Von der äußeren Region aus betrachtet, ist unser Universum ein gigantisches Schwarzes Loch. Zwischen dem inneren und dem äußeren Bereich der schwarzen Kugelschale ist kein Informationsaustausch möglich. Jegliche Materie, die von innen oder außen in die schwarze Kugelschale gelangt, ist von innen und von außen nicht mehr sichtbar. Sowohl die innere als auch die äußere Grenze der schwarzen Kugelschale stellen demzufolge einen Ereignishorizont dar.]]

Die '''Kosmologie''' beschäftigt sich mit der Struktur, dem Ursprung und der Entwicklung des Universums. Dadurch ergeben sich zahlreiche Bezüge zur beobachtenden '''Astronomie''' und zur '''Astrophysik''', aber auch zur '''Quantenphysik'''.

In der Antike gingen die Menschen noch davon aus, dass sich die Erde im Mittelpunkt der Welt und somit auch in der Mitte des sichtbaren Universums befindet. Dieses geozentrische Weltbild wurde seit dem 16.&amp;nbsp;Jahrhundert, ausgelöst durch die kopernikanische Wende, zunehmend verworfen und durch ein heliozentrisches Weltbild ersetzt. Durch die Erfindung und Verwendung von Fernrohren konnten seit dem Beginn des 17.&amp;nbsp;Jahrhunderts immer mehr Details im Sternenhimmel entdeckt werden. Durch astronomische Beobachtungen ergaben sich immer mehr Indizien für die Tatsache, dass die Erde einmal pro Jahr auf einer Ellipsenbahn die Sonne umrundet und nicht die Sonne die Erde umkreist. Der Philosoph Immanuel Kant (1724–1804) erkannte bereits 1755 in seiner Allgemeinen Naturgeschichte und Theorie des Himmels das innere Wesen unserer Milchstraße. Mit der ersten zuverlässigen Messung der Parallaxe von unserer Erde zum benachbarten Fixstern 61&amp;nbsp;Cygni (&quot;Bessel's Stern&quot;) durch Friedrich Wilhelm Bessel (1784–1846) in Königsberg und der daraus folgenden Berechnung von dessen Entfernung von gut zehn Lichtjahren im Jahr 1838 war die Tatsache, dass die Erde um die Sonne läuft, endgültig bewiesen.

Die Auswertung der astronomischen Beobachtungen hat zu der heute allgemein geteilten Auffassung geführt, dass unser Universum bei einem Urknall entstanden ist und seitdem expandiert. Die Berücksichtigung des Äquivalenzprinzips zwischen schwerer und träger Masse, das zu der von '''Albert Einstein''' (1879–1955) formulierten Allgemeinen Relativitätstheorie führt, brachte '''Alexander Friedmann''' (1888–1925) 1922 zu der theoretischen Vorhersage eines dynamischen Universums. Fünf Jahre später schlussfolgerte der belgische Astronom '''Georges Lemaître''' (1894–1966) aus den von '''Vesto Slipher''' (1875–1969) beobachteten Rotverschiebungen von fernen Galaxien und den von '''Edwin Hubble''' (1889–1953) ermittelten Entfernungen dieser Galaxien, dass das Universum expandiert. Aufgrund dieser Erkenntnis ergibt sich, dass das Universum einen Ursprung mit sehr kleinem Radius gehabt haben muss. Diesen Zustand nannte er &quot;primordiales Atom&quot; beziehungsweise &quot;Uratom&quot;. In der Folgezeit etablierte sich für diesen initialen Vorgang der Begriff &quot;'''Urknall'''&quot; (im Englischen: &quot;'''Big Bang'''&quot;).&lt;ref&gt;Markus Bautsch: ''[https://en.wikibooks.org/wiki/Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell/Brief_historical_review Moving objects in retarded gravitational potentials of an expanding spherical shell / Brief historical review], Wikibook (englisch), 2024, abgerufen am 28. Februar 2026&lt;/ref&gt;

Viele Astrophysiker versuchen heute mit dem sogenannten '''Standardmodell der Kosmologie''' (auch '''ΛCDM-Modell''' beziehungsweise Lambda-CDM-Modell, wobei &quot;CDM&quot; für &quot;cold dark matter&quot; steht, also für &quot;kalte, dunkle Materie&quot;) die Entwicklung des Universums nachzubilden. Hierfür wenden sie das kosmologische Prinzip an, das von zwei grundlegenden Annahmen ausgeht:&lt;ref&gt;Markus Bautsch: ''[https://en.wikibooks.org/wiki/Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell/Preface Moving objects in retarded gravitational potentials of an expanding spherical shell / Preface], Wikibook (englisch), 2024, abgerufen am 28. Februar 2026&lt;/ref&gt;

# Das Weltall sei '''homogen''', was bedeutet, dass es in groben Zügen von jedem Punkt aus gleich aussieht.
# Das Weltall sei '''isotrop''', was besagt, dass es in groben Zügen in jede Richtung gleich aussieht.

Mit diesen Annahmen kann das Modell berechnet werden, und mit diversen zusätzlichen Annahmen stimmt es in vielerlei Hinsicht mit den astronomischen Beobachtungen überein. Zu den zusätzlichen Annahmen gehören die folgenden beiden hypothetischen Größen:

* '''Kalte, dunkle Materie''', die zwar der Gravitation unterläge, aber keine Wechselwirkung mit elektromagnetischer Strahlung zeigt.
* Eine '''kosmologische Konstante''' Λ, die eine '''dunkle Energie''' beschreibt und für die beschleunigte Expansion des Universums verantwortlich sei.

Weder für die Homogenität noch für die Isotropie des Kosmos konnten bislang Belege gefunden werden, und auch für die kalte dunkle Materie und die dunkle Energie konnte bislang keine physikalische Interpretation geliefert werden.

Ferner ist auch die Annahme, dass die Naturkonstanten unveränderliche Werte haben, nicht begründbar. Auf kosmischen Zeitskalen kann es durchaus Änderungen geben, die wir derzeit nicht messen können. Die gilt insbesondere für die Hubble-Konstante, die die Expansionsrate des Universums beschreibt, für die Gravitationskonstante, die die Anziehung zweier Massen beschreibt, oder für die kosmologische Konstante, die die beschleunigte Expansion des Universums beschreibt. In diesem Kontext sei darauf hingewiesen, dass unser Universum genauso groß ist wie ein Schwarzes Loch mit der Masse unseres Universums. Deshalb gehen einige Kosmologen davon aus, dass wir innerhalb eines Schwarzen Loches der Größe und Masse unseres Universums leben könnten.

Siehe hierzu auch: [[:en:Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell|'''Moving objects in retarded gravitational potentials of an expanding spherical shell''']].

Darüber hinaus mehren sich Anzeichen und Hinweise, die gegen die Ergebnisse des Standardmodells der Kosmologie sprechen, beziehungsweise durch weitere Hypothesen, die physikalisch nicht begründet werden können, im Standardmodell berücksichtigt werden müssen. Die folgende unvollständige Liste soll hierzu einige Anhaltspunkte liefern:

* Präzise astronomische Beobachtungen zeigen, dass das Weltall auch auf großen Längenskalen '''nicht homogen''' ist, sondern Strukturen zeigt.
* Präzise astronomische Beobachtungen zeigen, dass das Weltall auch auf großen Längenskalen '''nicht isotrop''' ist (Asymmetrie der kosmischen Hintergrundstrahlung).
* Die Hubble-Konstante hat heute einen anderen Wert als früher (&quot;'''Hubble tension'''&quot;), was mit dem Standardmodell nicht im Einklang steht.
* Das beobachtete Vorkommen des dritten Elements im Periodensystem, also des Alkalimetalls '''Lithium''', ist mindestens dreimal geringer als vom Standardmodell vorhergesagt.
* Die '''Rotverschiebung von fernen Galaxien''' ist deutlich größer als es nach dem Standardmodell möglich wäre.
* Die beobachteten '''Rotationskurven von Spiralgalaxien''' stehen im Widerspruch zu den Ergebnissen des Standardmodells.
* Das Standardmodell ist nicht in der Lage, die Abwesenheit von '''Antimaterie''' im sichtbaren Teil des Universums zu erklären.
* Die im frühen Universum beobachteten '''primordialen Schwarzen Löcher und Galaxien''' mit explodierende '''Supernovae''' sowie dem Vorkommen von '''Sauerstoff''' stehen im Widerspruch zu den Ergebnissen des Standardmodells.

== Zur Astrologie ==
Eine Sonderstellung nimmt die '''{{w|Astrologie}}''' (zusammengesetzt mit dem altgriechischen ἄστρον (&quot;astron&quot;), zu Deutsch „Sternenlehre“) ein. Sie ist ein weiteres Beispiel für eine Disziplin, bei der grundlegende Kenntnisse über die Astronomie eine Voraussetzung sind. Sie versucht, Zusammenhänge zwischen den Konstellationen der Wandelgestirne oder astronomischen Ereignissen am Sternenhimmel mit irdischen Geschehnissen oder Veränderungen herzustellen, insbesondere was bestimmte Konjunktionen und daraus abgeleitete Prophezeiungen betrifft. Sie wurde bereits in Mesopotamien und in anderen alten Kulturkreisen von Astronomen ausgeübt. Noch der Astronom '''{{w|Johannes Kepler}}''' (1571–1630) hat als einer der letzten Astronomen einen wesentlichen Teil seiner Einkünfte durch die Erstellung von Horoskopen bestritten. Aber schon Aristoteles hatte festgestellt und beschrieben, dass die bei bestimmten Konstellationen am Himmel vorhergesagten Ereignisse nicht eingetreten waren.

Vor der Aufklärung haben astrologische Prophezeiungen noch eine große und weitreichende gesellschaftliche Bedeutung gehabt. Als Beispiel seien die Behauptungen des ersten im Kurfürstentum Brandenburg tätigen Astrologen '''{{w|Johannes Carion}}''' (1499–1537) genannt, der für 1524 eine Sintflut vorhersagte, die nicht eingetroffen ist.&lt;ref&gt;{{Literatur |Autor=Markus Bautsch, Friedhelm Pedde |Titel=Vor 500 Jahren: Die Sintflut von 1524 die nicht stattfand |Online=https://wfs.berlin/wp-content/uploads/2024/05/A19-BROplanetA4_40s-feb2024ff_www-rz.pdf |Sammelwerk=Dem Himmel nahe. |WerkErg=Mitteilungen der Wilhelm-Foerster-Sternwarte e.V.|Nummer=19 |Hrsg=Wilhelm-Foerster-Sternwarte e.V. / Zeiss-Planetarium am Insulaner |Ort=Berlin |Datum=2024-02 |Seiten=16–19 |Sprache=de |Abruf=2025-08-03|ISSN=2940-9330}}&lt;/ref&gt; Der Wiener Hofastronom '''{{w|Georg Tannstetter}}''' (1482–1535) sah sich 1523 bemüßigt, die schon lange im Voraus erhitzten und besorgten Gemüter zu beruhigen:&lt;ref&gt;Georg Tannstetter: ''Libellus consolatorius contra opiniones de diluvio et aliis horrendis periculis anni 1523''&lt;/ref&gt;

&lt;blockquote&gt;
Nun hat sich überall, in allen Köpfen, in allen Seelen das Gerücht eingeschlichen:&lt;br/&gt;
die Gelehrten und Weisen sind in ständigem Streitgespräch, andere hingegen sind derart verstört, dass sie ihren Geschäften nicht mehr nachgehen können; sie verkaufen ihre Anwesen, ihre Felder und Besitztümer oder lassen davon ab, Güter zu kaufen, in der Hoffnung, ihr Geld leichter in die sicheren Berge transportieren zu können. Andere wiederum verschieben ihr Heiratsversprechen, kündigen ohne scheinbaren Grund Verträge auf, entziehen sich ihren christlichen Gelübden, arbeiten faul und missmutig auf dem Land und fragen sich, was es denn nütze, Geld und Gut anzuhäufen, wenn doch in kürzester Zeit niemand mehr davon Nutzen ziehen könne.
&lt;/blockquote&gt;

'''→ Siehe auch:'''

* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Definition|'''Konjunktionen''', Abschnitt '''Definition''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Historische_Konjunktionen|'''Historische Konjunktionen''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|'''Beobachtungen in der Nähe der Ekliptik''']].
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

== Einzelnachweise ==
&lt;references&gt;&lt;/references&gt;</text>
      <sha1>k8q9al4lrd63iezzssltmtk8jg4f8g8</sha1>
    </revision>
  </page>
</mediawiki>