Abo
  1. Foren
  2. Kommentare
  3. Software-Entwicklung
  4. Alle Kommentare zum Artikel
  5. › Software-Entwickler…
  6. T…

Ich begreife leider bereits die Grundprinzipien nicht.

  1. Thema
  1. 1
  2. 2
  3. 3

Neues Thema Ansicht wechseln


  1. Re: Ich begreife leider bereits die Grundprinzipien nicht.

    Autor: okidoki 26.09.18 - 11:55

    Nr.1 schrieb:
    --------------------------------------------------------------------------------
    > Ich versuche nun seit 1,5 Jahren über eine zweite Ausbildung zum
    > Fachinformatiker, u.a. Programmierung zu verstehen und eventuelle
    > Erkenntnisse auch anzuwenden. Der Knoten platzt einfach nicht. Für mich
    > ist eine Programmiersprache wie die Darstellung einer Welt, in der alle
    > Naturgesetze, wie ich sie kenne, nichtig sind. Das ist zumindest mein
    > Eindruck.

    Wichtig ist: Nicht mit irgendwelchen GUI-Programmen anfangen, die Scaffolding, Objektorientierung und Events verwenden, wie zum Beispiel Windows-Programme. Ganz einfach funktional/prozedural. Es gibt auch gute Bücher für Kids (kein Witz und keine Polemik!).

    Wenn Du wirklich damit kämpfst, gibt es zwei Möglichkeiten: Entweder Du kniest Dich richtig rein und schaffst es oder Du überlegst, ob Deine Ausbildung die richtige für Dich ist. Das ist ja der Kern mit dem Du Deine Arbeit in Zukunft machen wirst. Wenn das keinen Spaß bringt, überleg einmal ob das das richtige für Dich ist. Ich würde z.B. in einer Uhrmacherausbildung verzweifeln, weil ich nicht der geduldige Typ bin.



    1 mal bearbeitet, zuletzt am 26.09.18 11:57 durch okidoki.

  2. Re: Ich begreife leider bereits die Grundprinzipien nicht.

    Autor: SirFartALot 26.09.18 - 11:58

    ML82 schrieb:
    --------------------------------------------------------------------------------
    > ohne die Vorarbeit anderer, vom Reißbrett bitte!

    Da wuerde er staunen. :)

    "It's time to throw political correctness in the garbage where it belongs" (Brigitte Gabriel)
    Der Stuhlgang während der Arbeitszeit ist die Rache des Proletariats an der Bourgeoisie.

  3. Re: Ich begreife leider bereits die Grundprinzipien nicht.

    Autor: SirFartALot 26.09.18 - 12:01

    Mit welcher IDE oder welchem Editor schreibst du den Code? Das kann im zweiten Fall SEHR viel ausmachen. :)

    "It's time to throw political correctness in the garbage where it belongs" (Brigitte Gabriel)
    Der Stuhlgang während der Arbeitszeit ist die Rache des Proletariats an der Bourgeoisie.

  4. Re: Ich begreife leider bereits die Grundprinzipien nicht.

    Autor: DreiChinesenMitDemKontrabass 26.09.18 - 12:08

    Andere Beitrage nur überflogen.
    Grafiker? und von Ablauf keine Ahnung? Dann wär ein Ablaufdiagramm genau das Richtige.

    Neben der Semantik hat jede Programmiersprache auch eine Syntax. Die muss man auch verstehen. Oft ist es z.B. egal, ob eine Funktion in einer Datei vor oder nach einer anderen geschrieben wurde. In anderen Programmiersprachen muss man auf jedes Leerzeichen achten.

    Hier noch ein paar Dinge, die vielleicht helfen können aber (viel) Zeit benötigen:
    Falls du nicht noch nicht hast, würde ich empfehlen Linux zu installieren, zB Ubuntu oder Mint. Das wird jedoch einige Einarbeitungszeit in Anspruch nehmen. Der Umgang damit wird wahrscheinlich schwieriger sein und du wirst oft suchen müssen, jedoch weißt du dann immer, was genau du getan hast. Dort ist es z.B. auch einfacher Code in einer einfachen Textdatei zu schreiben und ihn mit der console zu compilieren. Dort musst du dann per Hand die einzelnen Teile zusammenfügen. Das hilft dem Verständniss. Zudem gibt es 1000e nützliche Software kostenlos. Aber wie gesagt Umstellung dauert eine Weile und ist kein muss.

    Viele haben ja schon Python genannt. Noch einfacher ist finde ich Matlab. Das ist quasi ein sehr sehr guter Taschenrechner. Übergang von Taschenrechner zu Programmieren am einfachsten. Matlab kostet jedoch Geld. Auch ist es für Mathematiker gemacht und nicht Programmierer. Es hat paar feine Unterschiede zu fast allen Programmiersprachen. Kostenlose alternative heißt Octave. Nicht ganz so nutzerfreundlich. Und nicht zu lange machen/ zu sehr dran gewöhnen, wenn du programmieren lernen willst.

    Als Grafiker sind vielleicht auch Visuelle Programmiersprache etwas fürs Verständniss. Da kenn ich mich aber nicht so aus.
    Für die absoluten Basics gibt es aber ein sehr großes Angebot.
    Ich habe nur mal RPG Maker benutzt. Damit kann man sehr einfach ein 2D Spiel machen. Da lernt man zwar die Basic aber auch sehr viel für Programmierung unnötiges Wissen.

  5. Re: Ich begreife leider bereits die Grundprinzipien nicht.

    Autor: Targi 26.09.18 - 12:44

    Vielleicht ist für dich eine Programmiersprache für Kinder wirklich ein guter Einstieg, Turtle zum Beispiel, oder Niki. Vielleicht hat jemand im Forum noch andere Vorschläge.

    Darin gibt es nur sehr wenige Funktionen, die ablenken könnten und es geht nur darum, simple Kontrollstrukturen (If, Schleifen, etc.) zu erlernen und in die Denkweise hineinzukommen.

    Bei Niki zum Beispiel hast du einen Roboter, der sich auf einem Feld bewegt und nur wenige Befehle, u.a. VOR und DREHELINKS beherrscht. Du kannst dann mit der Zeit immer komplexere Bewegungsmuster basteln. Du kannst NIKI beibringen, sich auch nach rechts zu drehen, indem du DREHERECHTS als 3x DREHELINKS definierst und schon weißt du, was eine Funktion ist. Irgendwann bringst du ihm dann bei, durch ein beliebiges Labyrinth laufen zu können usw.

    Wichtig scheint mir, dass du dir Unterstützung abseits von Foren holst, gewissermaßen Nachhilfe, der dir bei deinen konkreten Problemen helfen kann.

  6. Re: Ich begreife leider bereits die Grundprinzipien nicht.

    Autor: theonlyone 26.09.18 - 12:45

    Es ist gar nicht so schlecht wenn man bei den Grundlagen anfängt anstatt irgendwo einfach rein zu grätschen.


    Maschinencode eben.

    Computer sind nicht wahnsinnig komplex, in ihren absolut einfachsten Operationen.

    Die Sprachen setzen darauf auf und machen komplexere Probleme einfacher zu formulieren und vor allem versucht man Code möglichst wieder zu verwenden, damit man Stück für Stück in deutlich abstrakteren Schritten denken kann als sich in Details zu verlieren.


    Im Beispiel eines Taschenrechners kann man durchaus anfangen das Grundgerüst komplett zu formulieren. Alles in eine Zustand-Maschine zu packen damit Rechen-Regeln eingehalten werden und ein Darstellung der Eingaben und Ergebnisse, bis hin zur Oberfläche mit Buttons.

    Den Taschenrechner an sich muss nur aus zwei Eingaben und einer Operation ein Ergebnis liefern, egal was die Eingabe ist und egal was die Operation ist.
    Das ist der einfachste Taschenrechner und die Bedienung hat damit auch keine netten Features wie "Zurück" / "Löschen einer Eingabe" / Zwischenergebnisse und sonstige Späße.

    Fängt man nun an Klassen zu definieren, hat man eben eine ausführende Klasse "Taschenrechner", Parameterklassen für "Eingabe" und "Operation".
    Das muss man nicht so machen, letztlich ist genau hier die Freiheit des Programmierers und damit des Software-Architekten, wie das System möglichst das widerspiegelt was man unter einem Taschenrechner versteht, ganz grundlegend.

    ----

    Wer mit dem abstrakten Denken nicht zurecht kommt, ist womöglich auch schlichtweg nicht als Programmierer geeignet und hat anderweitige Talente.

    Warum man sich dann so eine Ausbildung oder sogar Studium antun will erschließt sich mir nicht.

    Wer schon grundlegend kein Verständnis hat, der wird sich nur umso schwerer tun bei Themen die auf all dem aufbauen.

    Ziel muss es sein herauszufinden was einem liegt und für was man ein "Talent" hat, das verfolgt man dann weiter.

    Nur weil irgendwer einem gesagt hat "Du musst in die IT, das ist die Zukunft!" , muss das noch lange nichts für jeden sein.

  7. Re: Ich begreife leider bereits die Grundprinzipien nicht.

    Autor: 0xDEADC0DE 26.09.18 - 13:03

    non_sense schrieb:
    --------------------------------------------------------------------------------
    > Mit "richtigen Taschenrechner" meine ich ein Taschenrechner, der auch die
    > Operatorreihenfolge einhält und nicht meint, 1+2*3 wäre 9 sondern 7.

    Das ist Definitionssache, einer meiner früheren Lieblingstaschenrechner für Android kann das auch nicht, sah aber deutlich besser aus und war einfacher zu bedienen, als der von Android selbst.

    Requirements bzw deren Definition sind eben neben der Programmiersprache eben auch sehr wichtig. Ein Einsteigerprojekt wird sicher kein Requirement "Punkt-Vor-Stricht-Support" haben, was nicht heißt, dass man es nicht nachträglich einbauen kann, wenn man fortgeschritten ist.

  8. Re: Ich begreife leider bereits die Grundprinzipien nicht.

    Autor: SirFartALot 26.09.18 - 13:41

    Da du nicht verraetst, um welche Programmiersprache es geht. kann ich nur mal ganz allgemeine Tipps geben:
    - gib Geld aus und kauf dir ein ordentliches Grundlagenbuch, das auch komplexe Sachverhalte einfach erklaeren kann
    - such dir tutorials und bau die nach um mal an funktionierende Codeteile zu kommen, die du auch gleich testen kannst
    - nimm diese Beispiele als Basis und erweitere sie um eigene Ideen und bau das Gelernte mit ein und lerne bei diesem Prozess zu verstehen, was da passiert, und idealerweise auch warum :)

    Du wirst aber nicht drum rum kommen das auch zuhause zu machen. Zeit wirst du auf jeden Fall investieren muessen, aber je besser die Buecher, Docs und Tuts, desto leichter wirds fuer dich. Und wie schon jemand anderes auch sagte, Struktogramme mit Stift und Lineal zeichnen ist sehr hilfreich fuer das Verstaendnis, wie man Ideen in Code umsetzt.

    Just my 0.2$

    "It's time to throw political correctness in the garbage where it belongs" (Brigitte Gabriel)
    Der Stuhlgang während der Arbeitszeit ist die Rache des Proletariats an der Bourgeoisie.

  9. Re: Ich begreife leider bereits die Grundprinzipien nicht.

    Autor: Clown 26.09.18 - 13:42

    So ähnlich habe ich auch angefangen und das würde ich auch wieder weiter empfehlen!
    Klar, Ablaufdiagrammen (und auch UML mittlerweile) macht keiner mehr. Aber für den Einstieg sind sie ein gutes Werkzeug.
    Da ist es dann auch fast egal, ob der nächste Schritt mit einer modernen Scriptsprache oder reinem(, alten) C passiert. Da es ja erst mal darum geht, das bisher gelernte stoisch zu übertragen.

    Obgleich ich noch eine Anmerkung machen möchte: Meines Erachtens macht es Sinn mit einer Sprache anzufangen, die kein umfangreiches Aufsetzen einer Entwicklungsumgebung etc pp benötigt.
    Da OP schrieb, dass HTML/CSS bereits zum Wissensschatz zählen, wäre es in diesem Fall vlt sogar sinnvoll mit Javascript weiter zu machen, da dies nur ein weiterer Schritt in bereits Bestehendes bedeutet.

    Blizzard: "You guys don't have phones?" ~ Bethesda: "You guys don't have friends?" ~ EA: "You guys don't have wallets?"

  10. Re: Ich begreife leider bereits die Grundprinzipien nicht.

    Autor: JensBröcher 26.09.18 - 13:51

    Das Problem ist das viele dieser Kurse viel zu theoretisch und abstrakt sind. Vergiss den ganzen Mist, lade dir Visual Studio Code oder Brackets runter und programmiere erstmal etwas ganz einfaches in Javascript. Konzentriere dich auf die basics. Was sind variables, arrays, functions, objects etc.

    Der Rest kommt dann später von selbst.

  11. Re: Ich begreife leider bereits die Grundprinzipien nicht.

    Autor: a user 26.09.18 - 14:27

    Nr.1 schrieb:
    --------------------------------------------------------------------------------
    > Ich versuche nun seit 1,5 Jahren über eine zweite Ausbildung zum
    > Fachinformatiker, u.a. Programmierung zu verstehen und eventuelle
    > Erkenntnisse auch anzuwenden. Der Knoten platzt einfach nicht. Für mich
    > ist eine Programmiersprache wie die Darstellung einer Welt, in der alle
    > Naturgesetze, wie ich sie kenne, nichtig sind. Das ist zumindest mein
    > Eindruck.
    >
    > Immer wenn ich theoretisch über den Programmablauf nachdenke (Pseudocode,
    > Klassendiagramm usw.), ertappe ich mich erneut dabei, dass ich die Logik
    > anwende, die ich nun mal im Alltag kenne. Das ist aber offensichtlich
    > falsch.
    Das ist jetzt wirklihc nicht böse gemeint, Aber das einzige was hier offensichtlich ist, ist dass dein Verständnis von der Alltagslogik falsch ist. Denn es ist die gleiche wie beim Programmieren.
    > Seltsamerweise sind Fachbücher voll mit Beispielen aus dem Alltag
    > (Gast bestellt bei Kellner, Kellner beauftragt Koch usw.). Das verwirrt
    > mich leider mehr, als es hilft.
    Ich vermute mal, dass dein Problem weniger an deiner Logik liegt, als an was anderem. Aber dazu bräuchte ich mehr Informationen. Wird schwer zu verstehen was dein Problem ist nur so über ein Forum.

    >
    > Ich kann nur jeden warnen, der etwas ähnliches vor hat. Entweder man hat
    > ohnehin schon vorher etwas programmiert oder hat sogar richtig Spaß daran,
    > oder man hat Glück und erkennt in der Ausbildung, das man ein Faible dafür
    > hat. In meiner Klasse ist die knappe Hälfte so hilflos wie ich.
    >
    > Es ist also für mich letztlich egal, welche Programmiersprache es sein
    > soll. Die einzige große Erkenntnis ist: Wenn man keinerlei Vorkenntnisse
    > hat, ist es wichtig, die Sprachen erstmal außen vor zu lassen und intensiv
    > die innere Logik beizubringen.

    Ich werd das Gefühl nicht los, dass du genau das Gegenteil machen solltest: überhaupt nicht über irgendeine Logik nachdenken, sondern erst einmal nur stupide die Sprachkonstrukte lernen und anwenden. Aber das ist schwer so einzuschätzen.

  12. Re: Ich begreife leider bereits die Grundprinzipien nicht.

    Autor: ldlx 26.09.18 - 15:56

    Du hättest z. B. an "irgendeiner Stelle" eine MessageBox einbauen können, die eine "Kennung" sowie eine an der Stelle eingesetzte Variable bzw. ein Objektattribut (ggf. zu String konvertieren) ausgibt. So weißt du a) an welcher Stelle vom Programm die Textstelle getriggert wird und b) erfährst vielleicht schon was über die Variable.
    So etwas ähnliches hatte ich in der Ausbildung auch mal in C++, allerdings mit dem Hintergrund, dass mein Chef zwei seetaugliche Boote hatte - und ein Marine-Navigationsprogramm, das nach dem Reset des Kilometerzählers rückwärts zählte. (ganz grob: um den neuen Kilometerstand zu berechnen wurde alter Stand + zurückgelegte Entfernung gerechnet. Nun wurde die Differenz neuer Kilometerstand - alter Kilometerstand ausgerechnet. Und das dann widerrum auf den alten Kilometerstand addiert und als Wert ausgegeben. All das verteilt über mehrere Funktionen)

  13. Re: Ich begreife leider bereits die Grundprinzipien nicht.

    Autor: non_sense 26.09.18 - 16:33

    0xDEADC0DE schrieb:
    --------------------------------------------------------------------------------
    > Requirements bzw deren Definition sind eben neben der Programmiersprache
    > eben auch sehr wichtig. Ein Einsteigerprojekt wird sicher kein Requirement
    > "Punkt-Vor-Stricht-Support" haben, was nicht heißt, dass man es nicht
    > nachträglich einbauen kann, wenn man fortgeschritten ist.

    Du kannst es nicht einfach so einbauen, ohne die Anwendung komplett neuzubauen. Es reicht nicht, einfach ein paar if-abfragen einzubauen. Der Taschenrechner muss den mathematischen Ausdruck interpretieren, umwandeln und auswerten. Fürs Umwandeln gibt es den Shunting-Yard-Algorithmus, der den Ausdruck von der Infix- in die Postfix-Schreibweise umwandelt, um daraus eine Baumstruktur bauen zu können, der dann auswertbar ist. Das ist komplexer als ein

    switch
    {
    case '+':
    // ...
    break;
    // ...
    }

  14. Re: Ich begreife leider bereits die Grundprinzipien nicht.

    Autor: non_sense 26.09.18 - 16:45

    theonlyone schrieb:
    --------------------------------------------------------------------------------
    > Im Beispiel eines Taschenrechners kann man durchaus anfangen das
    > Grundgerüst komplett zu formulieren. Alles in eine Zustand-Maschine zu
    > packen damit Rechen-Regeln eingehalten werden und ein Darstellung der
    > Eingaben und Ergebnisse, bis hin zur Oberfläche mit Buttons.
    >
    > Den Taschenrechner an sich muss nur aus zwei Eingaben und einer Operation
    > ein Ergebnis liefern, egal was die Eingabe ist und egal was die Operation
    > ist.
    > Das ist der einfachste Taschenrechner und die Bedienung hat damit auch
    > keine netten Features wie "Zurück" / "Löschen einer Eingabe" /
    > Zwischenergebnisse und sonstige Späße.
    >
    > Fängt man nun an Klassen zu definieren, hat man eben eine ausführende
    > Klasse "Taschenrechner", Parameterklassen für "Eingabe" und "Operation".
    > Das muss man nicht so machen, letztlich ist genau hier die Freiheit des
    > Programmierers und damit des Software-Architekten, wie das System möglichst
    > das widerspiegelt was man unter einem Taschenrechner versteht, ganz
    > grundlegend.

    Ein Taschenrechner ist aber kein Zustandsautomat, sondern ein binärer Baum und darum ist ein Taschenrechner eigentlich auch nichts für einen Anfänger, weil da nur was schlechtes bei rauskommen kann, weil man das Problem nicht richtig erkannt hat.

  15. Re: Ich begreife leider bereits die Grundprinzipien nicht.

    Autor: theonlyone 26.09.18 - 16:48

    non_sense schrieb:
    --------------------------------------------------------------------------------
    > 0xDEADC0DE schrieb:
    > ---------------------------------------------------------------------------
    > -----
    > > Requirements bzw deren Definition sind eben neben der Programmiersprache
    > > eben auch sehr wichtig. Ein Einsteigerprojekt wird sicher kein
    > Requirement
    > > "Punkt-Vor-Stricht-Support" haben, was nicht heißt, dass man es nicht
    > > nachträglich einbauen kann, wenn man fortgeschritten ist.
    >
    > Du kannst es nicht einfach so einbauen, ohne die Anwendung komplett
    > neuzubauen. Es reicht nicht, einfach ein paar if-abfragen einzubauen. Der
    > Taschenrechner muss den mathematischen Ausdruck interpretieren, umwandeln
    > und auswerten. Fürs Umwandeln gibt es den Shunting-Yard-Algorithmus, der
    > den Ausdruck von der Infix- in die Postfix-Schreibweise umwandelt, um
    > daraus eine Baumstruktur bauen zu können, der dann auswertbar ist. Das ist
    > komplexer als ein
    >
    > switch
    > {
    > case '+':
    > // ...
    > break;
    > // ...
    > }

    Na klar ist das "simpel".

    Das ist ein Feature für sich, das kommt oben drauf auf den eigentlichen Taschenrechner, den für den Taschenrechner an sich ist das komplett irrelevant.

    Der stink normale Taschenrechner wird immer nur 2 Eingaben und eine Operation haben und rechnet das Ergebnis sofort aus, das Ergebnis kann man dann als Eingabe wieder für die nächste Operation verwenden.
    Ergo gibt es die Problematik der Reihenfolge gar nicht, da man immer nur eine Operation ausführt und fertig.

    Wer den "luxus" will und eine ganze Folge von Operationen am besten noch mit Formeln und Variablen auswerten will der hat schon zahlreiche Extra Features eingebaut die mit einem "normalen" Taschenrechner so rein gar nichts mehr zu tun haben.

    Den da baut man sich schon einen Compiler zusammen, der Regeln und Grammatiken kennen muss.
    Im Grunde auch kein Hexenwerk, den die Algorithmen die man benutzen will sind Probleme der Mathematik die für sich wieder ganz eigene Aufgaben in der Informatik darstellen.
    Am Ende landen diese in Bibliotheken und der Entwickler schaut sich die Implementierung dieser dann nach Möglichkeit nicht mehr an, den das ist ein Detailgrad der komplett am Thema des "Taschenrechners" vorbei geht (und es bringt dem Entwickler auch überhaupt keinen Mehrwert in die "Blackbox" des Algorithmus zu schauen aus der Bibliothek, den es genügt das die Anforderungen erfüllt werden).


    Demnach, einen stink normalen Taschenrechner zu bauen ist durchaus etwas das man im Informatik Grundkurs in Java oder einer Skriptsprache der Wahl einfach mal so an einem Nachmittag machen kann.
    Der kann dann schön Plus, Minus, mit Zwischenergebnissen, mit kleiner GUI wenn man mag und alle sind glücklich und haben was gelernt.

    Wer direkt anfängt komplexe Probleme gleich von Anfang an einzubauen macht sich das Leben einfach viel schwerer und liefert auch eine schlechte Arbeit ab, im Vergleich zu dem was man heute haben will, Iterative Ergebnisse, Agil-Schritt-für-Schritt Features einbauen und nach jedem Feature ein funktionierendes Produkt zu haben ; damit das gut funktioniert muss die Software eben auch so strukturiert sein damit sie Erweiterbar bleibt, ohne das ein Feature direkt die komplette Struktur zerfetzt und man alles neu schreiben soll ; Refactoring ist also immer ein Thema und das lernt man automatisch selbst an trivialen Beispielen wie einem Taschenrechner.



    1 mal bearbeitet, zuletzt am 26.09.18 16:52 durch theonlyone.

  16. Re: Ich begreife leider bereits die Grundprinzipien nicht.

    Autor: theonlyone 26.09.18 - 17:00

    non_sense schrieb:
    --------------------------------------------------------------------------------
    > theonlyone schrieb:
    > ---------------------------------------------------------------------------
    > -----
    > > Im Beispiel eines Taschenrechners kann man durchaus anfangen das
    > > Grundgerüst komplett zu formulieren. Alles in eine Zustand-Maschine zu
    > > packen damit Rechen-Regeln eingehalten werden und ein Darstellung der
    > > Eingaben und Ergebnisse, bis hin zur Oberfläche mit Buttons.
    > >
    > > Den Taschenrechner an sich muss nur aus zwei Eingaben und einer
    > Operation
    > > ein Ergebnis liefern, egal was die Eingabe ist und egal was die
    > Operation
    > > ist.
    > > Das ist der einfachste Taschenrechner und die Bedienung hat damit auch
    > > keine netten Features wie "Zurück" / "Löschen einer Eingabe" /
    > > Zwischenergebnisse und sonstige Späße.
    > >
    > > Fängt man nun an Klassen zu definieren, hat man eben eine ausführende
    > > Klasse "Taschenrechner", Parameterklassen für "Eingabe" und "Operation".
    > > Das muss man nicht so machen, letztlich ist genau hier die Freiheit des
    > > Programmierers und damit des Software-Architekten, wie das System
    > möglichst
    > > das widerspiegelt was man unter einem Taschenrechner versteht, ganz
    > > grundlegend.
    >
    > Ein Taschenrechner ist aber kein Zustandsautomat, sondern ein binärer Baum
    > und darum ist ein Taschenrechner eigentlich auch nichts für einen Anfänger,
    > weil da nur was schlechtes bei rauskommen kann, weil man das Problem nicht
    > richtig erkannt hat.

    Die Zustände sind des trivialen Taschenrechner sind:

    Eingabe1 (1..n) -> Operation (1) -> Eingabe2 (1..n) -> Ergebnis / Eingabe1

    Ganz einfach und mehr soll der auch erst mal gar nicht können, so fängt man eben an, ohne jedes Luxus Feature das man eben immer nachträglich erweitern kann.

    "Was schlechtes" ist das auch nicht, den das Taschenrechner Beispiel der Programmierung soll ja gerade so trivial sein damit man nicht von allen Möglichkeiten überrollt wird.


    Wenn du jetzt Features einbauen willst wie ganze Formeln, Variablen, multiple Zwischenergebnisse, Schleifen und und und , dann baust du eben schon weit weit mehr als einen "Taschenrechner" und es ist sehr gut sehr früh zu lernen diese ganzen Features auch heraus zu kapseln und nicht zu meinen das Produkt Taschenrechner muss all diese Features direkt und in Vollständigkeit direkt mit Version 1 haben , das ist illusorisch, fach fremd und im Zweifel auch richtig gefährlich, wenn jemand so an ein Projekt heran geht (den die Art Projekte werden schlichtweg niemals fertig und liefern nichts funktionierendes ab).



    1 mal bearbeitet, zuletzt am 26.09.18 17:04 durch theonlyone.

  17. Re: Ich begreife leider bereits die Grundprinzipien nicht.

    Autor: dEEkAy 27.09.18 - 01:00

    Lanski schrieb:
    --------------------------------------------------------------------------------
    > non_sense schrieb:
    > ---------------------------------------------------------------------------
    > -----
    > > divStar schrieb:
    > >
    > ---------------------------------------------------------------------------
    >
    > > -----
    > > > Das konnte eine Zeit lang ich glaube nicht einmal der
    > > > Windows-Taschenrechner (oder war das einer aufm Mac? ich erinnere mich
    > > > nicht).
    > > Das Gerücht, dass der Windows-Taschenrechner keine Operatorreihenfolge
    > > einhält, hält sich hartnäckig. Das konnte er schon immer, allerdings
    > nur,
    > > wenn man ihn auf "wissenschaftlich" einstellte.
    >
    > Exakt das wollte ich sagen, bis windows 7 weiß ichs sicher - er kanns nur,
    > wenn man ihn auf wissenschaftlich stellt. :D
    >
    > Aber daran hapert es doch schon oft ... überhaupt auf die Idee kommen ihn
    > mal umzustellen.
    > Wer die Idee nicht kriegt, dem fehlt schon etwas um effektiv zu
    > programmieren meiner Meinung nach.


    Naja, im normalen Modus rechnet der Windows Taschenrechner auch immer nur zwei Sachen zusammen und nutzt das Zwischenergebnis weiter.

    1+2*3 wird da erst in 1+2=3 und dann in 3*3=9 gerechnet.

    Stellt man ihn wissenschaftlich ein, kann man "ordentlich" rechnen.
    1+2*3 wird dann korrekt als 1+(2*3)=7 gerechnet.

  18. Re: Ich begreife leider bereits die Grundprinzipien nicht.

    Autor: a user 27.09.18 - 09:55

    JensBröcher schrieb:
    --------------------------------------------------------------------------------
    > Das Problem ist das viele dieser Kurse viel zu theoretisch und abstrakt
    > sind.
    Ich wünschte mir, die -Menschen, denen das zu abstrakt ist würde niemals hauptberuflich Softwareentwickler werden. Leider ist dem aber nicht so.

  1. Thema
  1. 1
  2. 2
  3. 3

Neues Thema Ansicht wechseln


Um zu kommentieren, loggen Sie sich bitte ein oder registrieren Sie sich. Zum Login

Stellenmarkt
  1. Schwarz Dienstleistung KG, Raum Neckarsulm
  2. BWI GmbH, Bonn, Berlin, Strausberg
  3. BWI GmbH, München
  4. OEDIV KG, Bielefeld

Golem pur
  • Golem.de ohne Werbung nutzen

Anzeige
Hardware-Angebote
  1. 279,90€
  2. 229€ (Bestpreis!)
  3. mit Gutschein: NBBX570


Haben wir etwas übersehen?

E-Mail an news@golem.de


Atari Portfolio im Retrotest: Endlich können wir unterwegs arbeiten!
Atari Portfolio im Retrotest
Endlich können wir unterwegs arbeiten!

Ende der 1980er Jahre waren tragbare PCs nicht gerade handlich, der Portfolio von Atari war eine willkommene Ausnahme: Der erste Palmtop-Computer der Welt war klein, leicht und weitestgehend DOS-kompatibel - ideal für Geschäftsreisende aus dem Jahr 1989 und Nerds aus dem Jahr 2019.
Ein Test von Tobias Költzsch

  1. Retrokonsole Hauptverantwortlicher des Atari VCS schmeißt hin

Internetprovider: P(y)ures Chaos
Internetprovider
P(y)ures Chaos

95 Prozent der Kunden des Internetproviders Pyur bewerten die Leistung auf renommierten Bewertungsportalen mit der Schulnote 6. Ein Negativrekord in der Branche. Was steckt hinter der desaströsen Kunden(un)zufriedenheit bei der Marke von Tele Columbus? Ein Selbstversuch.
Ein Erfahrungsbericht von Tarik Ahmia

  1. Bundesnetzagentur Nur 13 Prozent bekommen im Festnetz die volle Datenrate

SSD-Kompendium: AHCI, M.2, NVMe, PCIe, Sata, U.2 - ein Überblick
SSD-Kompendium
AHCI, M.2, NVMe, PCIe, Sata, U.2 - ein Überblick

Heutige SSDs gibt es in allerhand Formfaktoren mit diversen Anbindungen und Protokollen, selbst der verwendete Speicher ist längst nicht mehr zwingend NAND-Flash. Wir erläutern die Unterschiede und Gemeinsamkeiten der Solid State Drives.
Von Marc Sauter

  1. PM1733 Samsungs PCIe-Gen4-SSD macht die 8 GByte/s voll
  2. PS5018-E18 Phisons PCIe-Gen4-SSD-Controller liefert 7 GByte/s
  3. Ultrastar SN640 Western Digital bringt SSD mit 31 TByte im E1.L-Ruler-Format

  1. Indiegames-Rundschau: Killer trifft Gans
    Indiegames-Rundschau
    Killer trifft Gans

    John Wick Hex ist ein gelungenes Spiel zum Film, die böse Gans sorgt in Untitled Goose Game für Begeisterung und in Noita wird jeder Pixel simuliert: Die Indiegames des Monats sind abwechslungsreich und hochwertig wie selten zuvor.

  2. Archer2: Britischer Top-10-Supercomputer nutzt AMDs Epyc
    Archer2
    Britischer Top-10-Supercomputer nutzt AMDs Epyc

    Der Archer2 soll 2020 die höchste CPU-Leistung aller Supercomputer weltweit erreichen und es dank Beschleunigerkarten in die Top Ten schaffen. Im System stecken fast 12.000 Epyc-7002-Chips und Next-Gen-Radeons.

  3. Corsair One: Wakü-Rechner erhalten mehr RAM- und SSD-Kapazität
    Corsair One
    Wakü-Rechner erhalten mehr RAM- und SSD-Kapazität

    Mit dem i182, dem i164 und dem i145 aktualisiert Corsair die One-Serie: Die wassergekühlten Komplett-PCs werden mit doppelt so viel DDR4-Speicher und doppelt so großen SSDs ausgerüstet.


  1. 08:10

  2. 18:25

  3. 17:30

  4. 17:20

  5. 17:12

  6. 17:00

  7. 17:00

  8. 17:00