Der-Dennis: Frage zum Wiki-Artikel „Grundlagen der Programmierung“

Beitrag lesen

problematische Seite

Hallo Matthias,

Dies war die Grundlage für die Trennung in Einführung in die Programmierlogik, den ich mit @Der-Dennis zusammen konzipiert habe, und den vorliegenden Artikel.

da fällt mir gerade ein, dass ich noch einen UML-Artikel schuldig bin. In den nächsten Wochen hab ich etwas Luft und werde mich daran setzen.

Ich habe die JavaScript/Tutorials so aufgebaut, dass in der linken Spalte die Grundlagen, die ihr so vermisst habt, stehen:

Grundlagen

Top!

Deshalb halte ich eine Ausgabe mit alert() oder document.write() hier für gerechtfertigt.

Ich finde das auch nach wie vor ok. Es geht hier um absolute Anfänger, da sollte alles so einfach wie möglich gehalten werden. Sowas wie alert hat den Vorteil, dass man direkt etwas sieht. Auch wenn es Dinge wie die Konsole in der heutigen Form früher noch nicht gab, als ich angefangen hab, denke ich, dass mich das nur verwirrt hätte bzw. zu viel des Guten gewesen wäre. Dem Großteil dürfte das heute bestimmt noch ähnlich gehen.

Meiner Meinung nach muss man sich davon verabschieden, dass man etwas direkt nach allen Regeln der Kunst vermitteln kann. Der Grundsatz, dass Leute alles direkt richtig lernen sollen, ist zwar gut; in der Praxis funktioniert das aber nicht. Lernen findet insbesondere am Anfang normalerweise in kleinen Schritten statt. Da werden dann auch Umwege in Kauf genommen, einige Fehler muss jeder mal selbst gemacht haben und auch sonst gibt es viele Irrungen und Wirrungen. Ist doch ok, wenn es um das Lernen geht und am Ende eine neue Erkenntnis steht.

Nehmt als Beispiel die Layout-Tabellen: Klar, die sollten wir nicht in einem Tutorial verwenden, aber es spricht doch nichts dagegen, wenn ein Anfänger das mal ausprobiert. Das geht schnell, ist anschaulich und verständlich. Und wenn am Ende die Erkenntnis steht, dass es in HTML Elemente gibt, die aus Start- (und End-)Tags bestehen und Attribute beinhalten ist es doch auch gut. So könnte man bspw. dann auch hier im Forum vorgehen: Statt „Ach Du Sch****, meine Augen, mach das weg!“ kann man auch sagen: „Du hast also herausgefunden, dass es Elemente gibt und Browser ein Standardverhalten haben, wie sie diese anzeigen. Z.B. kann ich Sachen nebeneinander und untereinander anordnen. Gut, nächster Schritt: Die Elemente haben aber auch eine Semantik. Du solltest also Element XY nehmen. Bei dem Element zeigt der Browser anderes Verhalten, deshalb Flexbox...“ usw. Und am Ende hat er seinen Layouttabellen-Prototypen semantisch korrekt umgesetzt und wieder was gelernt.

Wir dürfen halt nicht vergessen, dass jeder mal bei vollständig Null angefangen hat. Und in Zusammenhang mit HTML ist die erste Erkenntnis, dass es paarweise auftretende Tags gibt. Und das erste Mal fällt man auf die Nase, wenn man ein Bild einbinden will… 😉

Was imho wirklich noch fehlt, wären:

  • ein Tutorial, der anstatt die Konsolen-Methoden nur vorzustellen, das Debuggen anhand einer wirklichen Problemstellung erklärt.
  • ein Tutorial, das Helferfunktionen zur dynamischen Erzeugung von Elementen vorstellt
  • Grundlagen von Strings und Arrays
  • Grundlagen der OOP

JavaScript ist nicht mein absoluter Favorit, aber zumindest für einen ersten Wurf zu Strings, Arrays, OOP sollte es reichen. Nach dem UML-Artikel kann ich da mitarbeiten.

Während viele englische Artikel eine geschätzte Lesezeit von 2-15min erwähnen, werden unsere Tutorials immer länger, weil jeder noch dies und das hinzufügt. Hier sollten wir mehr mit Verlinkungen, evtl auch mit der Hauptartikel-Vorlage arbeiten.

Ich finde auch und hab das schon mehrfach erwähnt, dass (mich eingeschlossen) viel mehr verlinkt werden sollte. Das ist das WWW! Nehmen wir das Beispiel von oben: Man kann grundsätzlich auch gerne DOM-Methoden verwenden. Da braucht es auch keine weitere Erklärung zu. Ein einfacher Link zu einem DOM-Tutorial ist ausreichend.

Außerdem denke ich auch, dass die Artikel oft zu lang werden, weil wir alles an Ort und Stelle nochmal erklären wollen. Außerdem haben wir viel zu viele „Beachten Sie“, Beschreibungen von Ausnahmen oder „Wenn-Dann-Sonst“-Konstruktionen. Ich denke vor allem – aber nicht nur – bei den Einsteiger-Tutorials müssen wir uns davon verabschieden, jede denkbare Möglichkeit für jeden potenziellen Anwendungsfall und jede Fehlermöglichkeit beschreiben zu wollen. Das werden wir erstens nie schaffen und zweitens sind die Artikel nachher so kompliziert, dass sie zwar völlig richtig sind, aber niemand mehr irgendwas versteht.

Gruß
Dennis

0 173

Frage zum Wiki-Artikel „Grundlagen der Programmierung“

  1. 0
    1. 0
      1. 0
        1. 0
          1. 0
            1. 0
              1. 0
                1. 0
                  1. 0
                  2. 0
                    1. 0
                      1. 0
                        1. 0
                          1. 0
                          2. 2
                            1. 0
                              1. 1
                                1. 0
                                  1. 1
                                    1. 0
                                      1. 0
                                    2. 0
      2. 0
        1. 0
          1. 0
  2. 0
    1. 0
      1. 0
    2. 0
      1. 0
        1. 0
          1. 0

            SelfHTML Experimentierkasten

            1. 0
              1. 0
      2. 2
        1. 0
        2. 0
          1. 0
            1. 0
              1. 0
                1. 0
                  1. 0
                    1. 0
                      1. 0
                2. 0
            2. 0
          2. 3

            Was ein Tutorial ist und was es nicht ist

            1. 0
            2. 0
        3. 2
          1. 0
            1. 0
              1. 0
                1. 0
              2. 0
                1. 0
          2. 0
            1. 0
              1. 0
                1. 0
        4. 1
          1. 0
            1. -1
              1. 0

                Was ist falsch?

                1. 0
              2. 0
                1. 0
                  1. 1
                    1. 0
                      1. 0
                      2. 0
                2. 0
                  1. 0
              3. 0
                1. 0
                  1. 1
                    1. 0
                      1. 0
                        1. 0
                        2. 0
                        3. 1
                          1. 0
                            1. 0
                              1. 0
                                1. 1
                                2. 0
                                  1. 0
                                    1. 1
                                      1. 2
                                3. 0
                  2. 0
                    1. 0
                      1. 0
                  3. 0
                  4. 0
              4. 0

                querySelector vs. getElementById

                1. 1
                  1. 0
                    1. 0
                      1. 0
                        1. 0
                          1. 0
                2. 0
                  1. 0
                    1. 1
            2. 0
              1. 0
                1. 0
              2. -1
                1. 2
                  1. 1
                    1. 0
                      1. 0
                        1. 0
                          1. 1
                            1. 0
                              1. 0
                        2. 0
                        3. 0
                          1. 0
                            1. 0
                          2. 0
                            1. 0
                      2. 0
                        1. 0
                          1. 0
                            1. 0
                              1. 0
                                1. 0
                                  1. 2
                                    1. 0
                                  2. 0
                          2. 1
                            1. 0
                              1. 0
                                1. 0
                                2. 0
                                3. 0
                                  1. 0
                                4. 0
                                  1. 0
                              2. 0
                                1. 0
              3. 3
                1. 0
                  1. 0
                    1. 0
                    2. 0
                      1. 0
                      2. 0
                        1. 7

                          Schreiben redundanter Artikel ist besser als folgenloses Mäkeln

                          1. 0
                            1. 0
                              1. 0
                          2. 1
                            1. 0
                              1. 0
                        2. 2
                          1. 0
                    3. 0
                      1. 0
                        1. 0
                          1. 0
                            1. 0
                              1. 4
                                1. 0
                              2. 3

                                Treffer, Schiff versenkt

                                1. 0
              4. 0
                1. 0
            3. 1
              1. 0