Für eine Kommunikation zwischen Client (Spieler) und Game Server werden Remote Events benutzt.

Wenn ein Drittservice (z.B. eine Android App) mit dem Game Server kommunizieren soll, bräuchtest du einen Vermittler (eigene Serveranwendung), der Anfragen der App (mit dem GUI) bspw. in einer Queue aufnimmt. Der Game Server wiederum müsste via HttpService periodisch Anfragen an den Vermittler schicken, ob es neue Anweisungen gibt. Der Vermittler könnte daraufhin seine Queue leeren.

...zur Antwort

Du kannst dir GDevelop oder Construct 3 anschauen.

Bevor du damit beginnst, würde ich dir allerdings empfehlen, eine genauere Idee zu entwickeln. Halte sie möglichst einfach. Das heißt, umso mehr individuelle Logiken es beispielsweise pro Level gibt oder umso schwieriger wird es für dich, das Ganze so umzusetzen.

...zur Antwort

Ich würde dir empfehlen, dafür Processing zu nutzen. Es ist eine sehr Java-nahe Sprache, die zum einen dafür entwickelt wurde, um Programmierneulingen einen einfachen Start zu ermöglichen und zum anderen stellt sie dir eine Zeichenfläche mitsamt dazugehörigen Funktionen zur Verfügung.

Bei der Auswahl des Spieles würde ich dir zu einem Minispiel wie Pong, Simon Says, Hangman oder Space Invaders raten. Dafür genügt einfaches Grundlagenwissen (bzgl. Variablen, Operatoren, Arrays, Kontrollstrukturen wie if, while).

...zur Antwort

Ich würde dir definitiv davon abraten, zwei Sprachen gleichzeitig lernen zu wollen.

Es verhält sich wie mit gesprochener Sprache - z.B. Spanisch und Italienisch. Du machst es dir nur selbst unnötig schwer, denn es ist nicht unwahrscheinlich, dass du durcheinanderkommst, was nun zu welcher von beiden Sprachen gehört.

Damit beziehe ich mich nicht nur auf die Syntax, sondern auch das Verhalten einzelner Sprachelemente. Die Zugriffsbereiche von Variablen verhalten sich in Python bspw. völlig anders, als in Lua. Weitere Beispiele wären die Auswertung boolscher Ausdrücke (konkret bezogen auf truthy/falsy), Scoping bei for-Schleifen oder die Indizierung von Arrays.

Fokussiere dich besser erst einmal auf eine von beiden. Je nachdem, bei welcher dein Interesse höher liegt. Wenn du mit der dann einmal sicher unterwegs bist, kannst du dich immer noch mit der anderen befassen.

...zur Antwort

Bezüglich des Designs habe ich ehrlich gesagt nicht das Gefühl, dass du wirklich wusstest, wie du deine Seite richtig aufteilen und die einzelnen Bereiche füllen sollst. So wirkt bereits die Stage mittels der Schriftgröße des Textes erzwungen. Bei der Auflistung deiner Profildaten sind es die übergroßen Abstände zwischen den einzelnen Listenpunkten, die die Seite unnötig strecken.

Meine erste Empfehlung wäre daher: Sammel erst einmal Inhalte, die du wirklich auf der Seite einbinden möchtest und überlege dann nochmals, wie sie präsentiert werden können. Reduziere die Seite auf die Elemente, die es wirklich braucht und gebe ihnen, gewichtet an ihrer Priorität auch nur so viel Platz, wie nötig. Deine Navigation halte ich zum Beispiel für zu übergroß, gemessen an dem, was die Seite an (wenigen) Inhalten letztendlich bietet. Vermutlich wäre eine horizontal zentrierte Navigation besser, die auch nur (neben dem Textlogo) drei Punkte aufnimmt (Über mich, Projekte, Kontakt). Home ist unnötig, denn die Stage bietet doch, bis auf die Einleitung, keinerlei wesentliche Information, als dass ich zu ihr zurückspringen müsste.

Die einzelnen Sektionen würde ich nach einem konsistenten Schema gestalten. Das Styling deiner Überschriften variiert immer wieder. Sei es beim Abstand nach oben, der Schriftgröße oder der horizontalen Ausrichtung. Nicht einmal der Text stimmt mit dem aus der Navigation überein. Hinsichtlich der Schriftart würde ich dir ebenfalls zu Konsistenz raten, vielleicht findest du auch noch eine bessere Option als Times New Roman.

Sollte dir für deine Stage nichts besseres einfallen (und sei es zumindest ein Hintergrundbild, den Willkommenstext würde ich entfernen/in den unteren Text einbinden oder vielleicht als Tagline direkt über dem unteren Text positionieren), zieh stattdessen deine Projekte nach oben. Eines von ihnen kann prominenter vorgestellt werden.

Auf zu auffällige Animationen würde ich des Weiteren verzichten. Ich meine den Hovereffekt bei den Projektteasern, den Hovereffekt bei deinem Dark-Mode-Button sowie den Hovereffekt für die Navigationsbuttons. Letzterer sieht so seltsam aus, sodass ich mir auch vorstellen könnte, dass es vielleicht doch ein Fehler ist und die Elemente schon im Initialzustand eine Umrandung haben sollten.

Hinsichtlich der technischen Umsetzung sind mir folgende, verbesserungswürdige Punkte aufgefallen:

  • Dein HTML-Dokument gibt vor, englische Inhalte zu bieten (lang-Attribut). Deine Texte sind allerdings größtenteils auf Deutsch.
  • Deine Sektionen überdecken sich gegenseitig. So sind zum Beispiel einzelne Projektteaser vollständig von der Kontaktsektion überlagert.
  • Irgendwo sollte sich laut Quelltext noch ein Button zum Ändern des Farbmodus befinden. Er liegt bei mir allerdings außerhalb des sichtbaren Bereichs.
  • Die Seite ist horizontal scrollbar. Dein Foto befindet sich außerhalb des wohl angedachten Inhaltsbereichs.
  • Verzichte wenn möglich auf absolute oder fixe Positionierungen. Die sind mitunter dafür verantwortlich, wieso sich Inhalte gegenseitig überlagern oder komplett aus dem sichtbaren Bereich verschwinden. Und ja, so ist es auch verständlich, dass die Seite trotz ihrer Einfachheit für mobile Endgeräte kaum bedienbar ist. Dein Seitenlayout könntest du einfacher aufbauen (siehe Beispiel unten). Für das Setzen von Abständen genügen im Regelfall margin/padding, wenn (Block-)Elemente nebeneinander positioniert werden müssen, nutze Flexbox oder Grid.
<!doctype html>
<head>
  <title>Example</title>
  <style>
    .wrapper {
      display: flex;
      flex-wrap: wrap;
    }

    .navigation { width: 270px }
    .content { flex: 1 }
  </style>
</head>
<body>
  <main class="wrapper">
  <nav class="navigation"><!-- navigation ... --></nav>
    <div class="content"><!-- content ... --></div>
  </main>
</body>
  • Es gibt offensichtlich noch einen inneren Hovereffekt für die Titel deiner Projektteaser. Bei zu langem Text (Bsp.: Anwaltskanzlei) wird dieser in dem Zustand abgeschnitten.
  • Die Navigationsbuttons springen nicht zu der ihnen zugehörigen Sektion.
  • In dem letzten .infolist li-Element nutzt du einen Endtag </habe>, den es nicht gibt.
  • Für die Infoliste würde sich eine Tabelle lohnen und für die einzelnen Schulstationen eine eigene Liste.
  • h2-Elemente gehören nicht in Buttons. Drehe die Reihenfolge um.
  • Für .picMe wäre ein figure-Element die deutlich passendere Wahl.
  • Beschäftige dich mehr mit HTML5. Ich sehe bei dir sehr viele div-Elemente, für die section, nav, article, ... besser geeignet wären.
  • Die Überschriftenhierarchie ist überarbeitungswürdig. Greife dir bestenfalls nur eine Überschrift als h1 heraus und ordne von da an in der Priorität nach unten. Deine Sektionsüberschriften wären demnach h2. Diese Hierarchie würde ich ebenso im visuellen Styling übertragen (h1 ist präsenter / hat eine höhere Schriftgröße als h2).

Den Inhalt deiner Seite solltest du letzten Endes nochmal auf Rechtschreib- und Ausdrucksschwächen prüfen. So etwas wie "sonstigen Dingen" wirkt etwas unbeholfen.

Der Seitentitel (im head) müsste in die deutsche Sprache übertragen werden und im Kontaktbereich fehlt die Angabe einer ladungsfähigen Adresse. Da du Google Fonts einbindest, aber Webseitenbesucher nicht darauf hinweist, verstößt du außerdem gegen die DSVGO.

Wie schon von anderen Antwortgebern erwähnt, verrät dein eigener Steckbrief noch nicht so viel relevantes über dich. Einer der wichtigsten Punkte bei einer Bewerbung ist immer die Motivation. Der grundsätzliche Fokus sollte stärker darauf liegen, zu zeigen, wieso du dich für Informatik interessierst.

Die Auswahl deiner Projekte wird für deinen Fall wohl reichen (wenn ich einmal davon ausgehe, dass du noch eine schriftliche, aussagekräftigere Bewerbung verschickst). Allerdings würde ich dich dennoch gern dazu anregen, sie wie deine Seite nochmals zu überarbeiten und auszubauen. Das betrifft unter anderem die Layouts und die Beschriftungen. Das Karteikartensystem funktioniert meines Erachtens überhaupt nicht (die weiße Box rotiert seltsamerweise auf der z-Achse, mehr passiert da nicht), auf der Anwaltskanzlei sind Texte deutlich abgeschnitten (das muss dir doch ebenso aufgefallen sein?).

Anwendungen wie den Timer, das Quiz oder die To-Do-Liste lassen sich ganz sicher noch weiter aufpeppen, denn aktuell sind sie funktional unkreativ. Für einen Leser dürfte es so wirken, als wäre einfach nur eine Standard-0815-Vorschlagsliste aus einem Forenthread kurz abgearbeitet worden. Wenn du mich davon überzeugen wollen würdest, dass dir Webentwicklung/Programmierung Spaß macht, würde ich erwarten, dass du über solche Grundfunktionen (z.B. Countdown) hinausgehst.

...zur Antwort

Du musst nicht alle Funktionen auswendig lernen/können. Bei Bedarf kann man sie nachschlagen (sei es über die Python-Referenz, die Konsole (help) oder mit Hilfe deiner Entwicklungsumgebung).

Einen gewissen Grundschatz dürftest du dir aufgrund häufigen Gebrauchs bestimmter Funktionen so und so zulegen. Ich denke hierbei zum Beispiel an String- und Listenfunktionen.

Generell wäre es förderlich, zumindest einen gewissen Überblick zu haben, was es in der Standardbibliothek so gibt, um im jeweiligen Anwendungsfall gezielter danach suchen zu können. Wenn du beispielsweise Daten in eine Datei schreiben möchtest, hilft es, zu wissen, dass Python ein eigenes Modul mit solchen Funktionen dafür hat und du dafür weder bei Null beginnen, noch unbedingt eine externe Abhängigkeit dazuziehen musst.

...zur Antwort
  1. Folge dem Guide von GitHub: Creating a GitHub Pages site. Beachte, dass serverseitige Technologien (wie z.B. PHP) nicht unterstützt werden.
  2. Eine extra Seite, die sich mit möglichen Gründen für einen 404 Response auseinandersetzt, gibt es ebenso: Troubleshooting 404 errors for GitHub Pages sites. Übliche Problemursachen sind bspw. falsche Dateinamen oder Dateiablageorte. Das HTML-Dokument, welches die Startseite repräsentiert, muss index.html heißen (beachte Groß-/Kleinschreibung) und im von dir angegebenen Rootverzeichnis, auf dem main-Zweig des Repositories liegen.
...zur Antwort

So ein Gitter ist im Grunde nur eine mehrmalige Wiederholung eines einzelnen Rechtecks. Zum einen horizontal, zum anderen vertikal.

Zeichne also zuerst nur ein einziges Rechteck und wiederhole das dann m-Mal (m = 6), um eine einzelne Reihe zu erhalten. Dieser Vorgang wiederum muss n-Mal (n = 4) wiederholt werden, damit das komplette Gitter gezeichnet wird. Zwischen jeder Zeile muss die Turtle einmal neu gesetzt werden. Du kannst dafür setPos nutzen.

setPos(x, y)
...zur Antwort

Bau dir zunächst Grundlagenwissen auf. Entweder mit Büchern oder Online-Lernquellen.

Ein paar, die ich an der Stelle empfehlen kann:

  • JetBrains Academy
  • Programmieren lernen mit Java von Habelitz
  • Java ist auch eine Insel von Ullenboom (gibt es in der 16. Auflage auch als Open Book)
  • Schrödinger programmiert Java von Ackermann
  • Core Java Tutorial by Pankai

Richte dir außerdem gleich zu Beginn eine Entwicklungsumgebung ein, in der du das, was du dir anliest, direkt ausprobieren kannst. IDEs, die sich hierfür gut eignen, wären IntelliJ IDEA, Eclipse oder NetBeans IDE.

So lange du nicht halbwegs sicher im Umgang mit OOP bist, würde ich dir raten, noch nicht mit Webentwicklung zu beginnen. Du brauchst es, um mit den Webframeworks, die es für Java bereits gibt, arbeiten zu können.

Dabei gibt es übrigens eine relativ große Auswahl: Javalin, Play, Quarkus, Spring, Struts, ... oder du beschäftigst dich mit der Jakarta EE-Spezifikation. Die wohl populärste Wahl in dieser Liste wäre Spring. Im professionellen Bereich ist es nicht selten, dass man auf dieses Framework trifft.

Neben der jeweiligen Online-Dokumentation würde ich dir für harte Literatur empfehlen, nach Büchern des Manning-Verlags sowie von Apress und Packt zu schauen. Online kannst du einiges auf Baeldung und JournalDev finden. Speziell zu Jakarta EE kannst du dir noch das Tutorial der Eclipse Foundation herausgreifen.

...zur Antwort

Für eine Eigenentwicklung ist es am einfachsten, Beiträge zusammen mit einer Metainformation abzuspeichern, die den Veröffentlichungsstatus (ja/nein oder vielleicht feingliedriger: In Prüfung/Bestätigt/Abgelehnt) bestimmt. Dazu kann man sich auch leicht ein Nutzerinterface zur Verwaltung bauen. Wenn das über den gleichen Webserver wie die Webseite ausgeliefert werden soll, kann eine Basic Authentication den Zugriff absichern.

Bei der Ausgabe von Beiträgen musst du dann noch eine Prüfung einbauen, die je Beitrag dessen Status betrachtet und dementsprechend entscheidet, ob er gerendert werden darf oder nicht.

Im Regelfall würde ich dir jedoch empfehlen, bestehende (Foren-)Software zu nutzen (alternativ ein CMS, mit dem man mittels Nutzerrollen Inhalte ausblenden kann), die solche Funktionalitäten bereits integriert hat. Gegenüber dem oben genannten ersten Ansatz ist so eine Implementation weiterentwickelt und schon getestet.

...zur Antwort

Die Option für MonoBehaviour Script ist richtig. Das ist die Standardbasisklasse für C#-Skripte in Unity.

...zur Antwort
Wie kann ich dieses Skript für Controller und Handy machen?
local Player = game.Players.LocalPlayer
local Character = Player.Character or Player.CharacterAdded:wait()
local UserInputService = game:GetService("UserInputService")
local Stamina = 100
local Running = false
local SprintSpeed = 30
local WalkSpeed = 16

script.Parent.PlayerName.Text = Player.Name
script.Parent.PlayerThumb.Image = "rbxthumb://type=AvatarHeadShot&id=" ..Player.UserId.. "&w=420&h=420"
Character:WaitForChild("Humanoid"):GetPropertyChangedSignal("Health"):connect(function()
  script.Parent.HealthBar.Bar.Size = UDim2.new(math.floor(Character.Humanoid.Health) / 100, 0, 1, 0)
end)
UserInputService.InputBegan:Connect(function(key)
  if key.KeyCode == Enum.KeyCode.LeftShift then
    Running = true
    Character.Humanoid.WalkSpeed = SprintSpeed

    while Stamina > 0 and Running do
      Stamina -= 1
      --print(Stamina)

      if Stamina == 0 then
        script.Parent.StaminaBar.Bar.Visible = false
      else
        script.Parent.StaminaBar.Bar:TweenSize(UDim2.new(Stamina / 100, 0, 1, 0), "Out", "Linear", 0)
      end

      wait()

      if Stamina == 0 then
        Character.Humanoid.WalkSpeed = WalkSpeed
      end
    end
  end
end)
UserInputService.InputEnded:Connect(function(key)
  if key.KeyCode == Enum.KeyCode.LeftShift then
    Running = false
    Character.Humanoid.WalkSpeed = WalkSpeed

    while Stamina < 100 and not Running do
      script.Parent.StaminaBar.Bar.Visible = true
      Stamina += 1
      --print(Stamina)
      script.Parent.StaminaBar.Bar:TweenSize(UDim2.new(Stamina / 100, 0, 1, 0), "Out", "Linear", 0)
      wait()

      if Stamina == 0 then
        Character.Humanoid.WalkSpeed = WalkSpeed
      end
    end
  end
end)

Ich will, dass man auf Controller RB/R1 drückt und auf Handy soll es eine Taste auf dem Bildschirm (GUI) geben.

Es ist übrigens in Roblox Studio mit Lua geschrieben.

...zum Beitrag

Über die Properties des UserInputService kannst du prüfen, welche Steuerungsmöglichkeiten (Touchpad, Gamepad, Tastatur, Maus, ...) dem Nutzer derzeit offenstehen.

Mit dieser Information kannst du eine Abfrage einbauen, die einen Button auf der Oberfläche anzeigen soll oder nicht. Ich denke, dass man hierfür die Transparenz setzen und das Element als nicht-interaktionsfähig setzen kann. Dem Button (bzw. dessen benötigten Events) ordnest du im Anschluss noch deine Event Handler zu.

Bezüglich des RB-Buttons musst du lediglich prüfen, ob der Nutzer den entsprechenden KeyCode (ButtonR1) getriggert hat.

...zur Antwort

Magento ist mehr auf mittelgroße bis große Projekte ausgelegt. Das heißt, es lohnt sich vor allem dann, wenn wir von einem Shop reden, der Produkte im (tendentiell zweistelligen) Tausenderbereich handhabt und täglich auch auf tausende Nutzer reagieren muss.

Die verschiedenen Prozesse, die so ein System verwalten bzw. lauffähig halten sollen (sei es das schwergewichtige Laminas-System selbst, Elasticsearch, Caching-Systeme wie Redis und Varnish) sind RAM-hungrig. Du solltest daher mehr RAM einplanen, als bei einer Shopware-Instanz. Magento benötigt ebenso mehr Speicherplatz, sowohl aufgrund der komplexeren Kernanwendung, als auch für Laufzeitdaten (Caches, Logs) und externe Dienste (Redis, Elasticsearch, MySQL).

Shopware wiederum eignet sich besser für kleine bis mittelgroße Shopanwendungen. Die Anwendung ist leichtgewichtiger und du brauchst keine Elasticsearch-Instanz.

...zur Antwort

Wenn man einmal vom Beziehen theoretischer Lernquellen (wie e-Books, Videokurse von Udemy/YouTube/..., Online-Tutorials) absieht, wäre die App Pascal N-IDE noch die naheliegendste Lösung. Sie bietet im Grunde die selben Möglichkeiten, wie die unzähligen Online-Compiler-Dienste (OnlineGDB, JDoodle, etc.): Du kannst kleine Konsolenübungen erstellen.

Zum Erlernen von Lazarus solltest du allerdings auch mit der Lazarus IDE arbeiten. Die ist nur auf Desktop-OS verfügbar. Das Gleiche gilt für die IDE von Embarcadero Delphi, um das an der Stelle gleich einmal vorwegzugreifen. Des Weiteren sind Workarounds (wie Remote-Zugriff via AnyDesk Remote-Desktop) meines Erachtens zu unhandlich, als das sie empfehlbar wären.

Ich würde dir generell dazu raten, mit einem Desktopgerät zu lernen. Theorie und Praxis sollten zeitlich möglichst beeinander liegen. Das heißt, wenn du dir etwas anliest, wäre es gut, dass darauffolgend auch frei ausprobieren zu können. Ein SmartPhone bietet jedoch von grundauf eine schlechte Basis für eine gute Entwicklungsumgebung.

Nichtsdestotrotz gibt es Lernapps wie Hyperskill, Mimo, Programming Hero oder Sololearn, die du dir anschauen kannst. Sie bieten Kurse für verschiedene Programmiersprachen (z.B. C++, Java, JavaScript). Pascal-basierte Sprachen sind nicht dabei.

...zur Antwort

Eine sehr einfache Lösung bietet Google Sites. Du kannst aus einer Liste an Templates wählen und deine Inhalte via Drag&Drop einbauen. Die Templates richten sich nach einem Gridsystem, welches je nach Bildschirmgröße entsprechend umbricht. Um eine Domain musst du dich allerdings selbst kümmern.

Ein paar weitere Optionen wären Carrd oder WordPress.

Die letztgenannte Option ist die flexibelste unter den dreien. Du kannst die Anwendung mit verschiedenen Plugins externer Anbieter erweitern, es gibt eine viel größere Auswahl an Themes und du kannst auch selbst entscheiden, über welchen Dienstleister (z.B. All-Inkl, Alfahosting, o.ä.) du die Seite hosten möchtest.

...zur Antwort

Überlege dir zuerst einmal, was du überhaupt erreichen möchtest, mit welchen Anforderungen/Regeln das in Verbindung steht, welche Entitäten und Aktionen damit im Verbund liegen.

Um das einmal kurz an dem Beispiel Erstellen eines Pac-Man-Spiels zu verdeutlichen:

  • Spielziel ist das Sammeln aller Punkte auf dem Spielfeld
  • Das Spielfeld besteht aus Block- und begehbaren Feldern
  • Es gibt sammelbare Punkte
  • Es gibt Power-Ups, die die Geister für eine gewisse Zeit verwundbar machen
  • Es gibt Geister, die auf dem Spielfeld patrouillieren und Pac-Man fressen können, sofern sie aktuell nicht verwundbar sind
  • Es gibt die Spielfigur Pac-Man, die in alle begehbaren Richtungen gesteuert werden kann, Punkte frisst und ebenso nach Aufnahme eines Power-Ups für eine bestimmte Zeit Geister

Aus dieser Beschreibung kann man schon einiges über die Gestaltung der Spielwelt, der vorhandenen Akteure und ihren Aktionen/Anwendungsfällen sowie Beziehungen zueinander ableiten.

Die einzelnen Aktionen und Regelprüfungen kannst du anschließend genauer im Ablauf planen. Mache das mit eigenen Worten (Stichpunkte, Pseudocode) oder erstelle Programmablaufpläne. Fange nur nicht sofort mit einer Implementation in Lua an, so verstrickst du dich nur. Es ist besser, erst einmal nur einen logischen Lösungsweg (Algorithmus) zu finden. Später kann man ihn in Lua übersetzen.

Wenn es Schritte in deinem Lösungsweg gibt, die du noch als zu schwierig für eine direkte Übersetzung in Lua betrachtest, dann versuche, diese nochmals in kleinere Arbeitsschritte zu zerlegen. Zum Teil wird es auch schon Funktionen seitens Roblox geben, die dir Teilarbeit abnehmen.

Sich diese Vorgehensweise zu eigen zu machen und so komplexe Systeme aufzubauen, erfordert ganz klar praktische Übung und ebenso Einarbeitung in die Roblox-API. Ich würde dir daher empfehlen, dir vorerst kleine Übungen herauszusuchen. Minispiele wie Pong, Breakout, Asteroids, Snake, Space Invaders, Pac-Man eignen sich meines Erachtens sehr gut. Auch das Bauen von Teilkomponenten (z.B. eine Lebensanzeige, ein Inventar, ein Highscore) dürfte eine gute Idee sein.

Für den konkreten Einstieg in Roblox solltest du definitiv das Developer Portal nutzen. Über die offizielle Webseite findest du viele nützliche Ressourcen (Lernplattform, Dokumentation/API Referenz, Forum, ...).

...zur Antwort

In erster Linie richtet es sich an der Zielgruppe / der Zielplattform aus. Wenn die Anwendung zum Beispiel als mobile App zur Verfügung stehen soll, wäre es wohl naheliegend, mit kivy oder PySide zu arbeiten.

Wenn die Anwendung explizit für Desktop-Geräte ausgerichtet werden soll, würde ich dir PySide empfehlen. Das Projekt beinhaltet unter anderem auch Klassen wie QWebView oder QNetworkRequest, um eine Google Map einzubinden oder HTTP-Requests zu verschicken. Zu Ersterem findest du vermutlich auf GitHub auch schon Projekte, die dir noch mehr Implementationsarbeit abnehmen können.

Ansonsten wäre es nicht abwegig, darüber nachzudenken, eine Webanwendung zu bauen. Entweder mit einer öffentlich erreichbaren Webseite, wobei sich Flask (Python-Framework) für das Backend empfehlen würde, oder als Desktopanwendung, die ihre grafische Oberfläche über einen Standalone-Webbrowser ausspielt. Die Kommunikation zwischen Front- und Backend könnte über einen in der Anwendung fest integrierten Webserver laufen. In Eel findest du bereits so eine Grundstruktur.

Die grafische Oberfläche könntest du in den beiden zuletzt genannten Fällen mit HTML, CSS und JavaScript bauen. Bibliotheken/Frameworks (grommet, MUI, React, Vue, ...) können das Ganze noch weiter vereinfachen, fordern aber natürlich zusätzliche Einarbeitungszeit.

...zur Antwort
Kann mir einer sagen was genau Functions bringen (...)

Mittels Funktionen kannst du:

1) Deinen Code in einzelne Sektionen unterteilen und somit einfacher/besser lesbar strukturieren. Dabei erledigt eine Funktion bestenfalls nur eine spezifische Aufgabe.

Wenn du später in deinem Programm etwas an dem Verhalten der implementierten Funktionalität ändern möchtest, wird es dir leichter fallen, diese Stelle wiederzufinden.

Mit dem Funktionsnamen kannst du zudem Code-Blöcke sprachlich zusammenfassen (Bsp.: Ein Code-Block, der einen Spielcharakter laufen lässt, könnte in eine Funktion run). Beim Lesen des Codes ist es dann einfacher, durch den Funktionsnamen bei ihrem Aufruf zu erfassen, was dort gemacht wird. Man muss nicht zwingend den Code lesen, der in der Funktion steht, um es zu verstehen.

2) Code-Wiederholungen vermeiden, denn du brauchst nun ja nur noch die Funktion aufrufen.

(...) was genau macht Return (...)

Wenn eine Funktion etwas berechnet, kann sie nach Abschluss ein Ergebnis zurückgeben.

Beispiel:

function get_sum(summand1, summand2)
  local result = summand1 + summand2
  return result
end

sum1 = get_sum(2, 3)
print(sum1) -- 5
sum2 = get_sum(4, 9)
print(sum2) -- 13

Die Ergebnisse der jeweiligen Aufrufe werden in diesem Fall in Variablen gespeichert und dann weiterverarbeitet (auf der Konsole ausgegeben).

...zur Antwort
Macht es noch Sinn, Python mit Tigerjython zu lernen, das auf Python 2 basiert?

Der Fokus von TigerJython liegt darauf, Anfängern einen tendentiell spielerischeren Einstieg in erste allgemeine Konzepte der Programmierung (z.B. Variablen, Kontrollstrukturen; erste Ansätze für Problemlösungen) zu geben. Bestimmte Python-Features werden bewusst nicht unterstützt, um zum einen das Entwicklungsumfeld einfach zu halten und zum anderen, da der Fokus nicht auf Python selbst liegt. Stattdessen gibt man eigene Module (wie gturtle) für ein abgestecktes Spielfeld vor, um es Anfängern erlauben, schnell und einfach zu (visuell) motivierenden Erfolgen zu kommen.

Demzufolge würde ich TigerJython für einen grundsätzlichen Einstieg in die Programmierung noch empfehlen. Für Python hingegen solltest du mit aktuellen Lernquellen für Python 3 in einem Python-Entwicklungsumfeld arbeiten.

Wie schwer ist es von Python 2 auf Python 3 umzusteigen?

Ich halte es nicht für schwer. Es gibt zwar ein paar Unterschiede in der Syntax oder dem Verhalten von Funktionen (Bsp.: In Python 3 liest die input-Funktion immer Strings ein, der Divisionsoperator liefert stets eine Fließkommazahl zurück, alle Strings sind standardmäßig Unicode, die print-Funktion erfordert Klammern für die Parameterliste), doch die sind überschaubar. Gerade für jemanden, der noch nicht viel mit Python 2 programmiert hat, sollte eine Umgewöhnung keinerlei Probleme bereiten.

Die gleiche Einschätzung habe ich für einen Umstieg von TigerJython auf Python 3. Neben den oben erwähnten Unterschieden kommen zwar noch verschiedene Features hinzu (z.B. Lambda-Ausdrücke, Generatoren, Dekoratoren, Typannotationen), aber keine besonderen Differenzen, die alles was du bisher gelernt hast, wieder komplett auf den Kopf werfen.

Nichtsdestotrotz würde ich dir empfehlen, dir passende Lernquellen zu Python 3 herauszusuchen und die auch von Anfang bis Ende durchzugehen.

Ein paar Quellen, die ich hierbei empfehlen kann:

  • Natürlich die offizielle Dokumentation: python.org (dort findest du auch Downloads, weitere empfohlene Einstiegsreferenzen, usw.)
  • Die Kurse auf Hyperskill
  • RealPython (eine Plattform, die Artikel zu den unterschiedlichsten Tools oder Anwendungsgebieten von Python beinhaltet)
  • Bücher von Apress, O'Reilly, packt, Rheinwerk oder Springer

Als Entwicklungsumgebung kannst du PyCharm nutzen. Alternativen wären Thonny (explizit für Anfänger) oder ein entsprechend konfiguriertes VS Code.

Mich interessiert erstmal nur, wie Programmierung funktioniert, also die Konzepte dahinter.

Dafür ist TigerJython wie schon geschrieben, eine passende Wahl.

Es gibt aber auch noch Alternativen:

  • WebTigerJython (ist mehr auf Python 3 ausgerichtet)
  • Das turtle-Modul in Python (Einstieg; Referenz)
  • Processing.py
...zur Antwort

Wenn man responsive/adaptive Seitenlayouts entwickeln möchte, sollte man für die Umsetzung schon gut im Voraus planen:

  • Es gibt viele Endgeräte mit unterschiedlichen Bildschirmgrößen. Welche gehören nun zur tatsächlichen Zielgruppe?
  • Liegt der Fokus eher auf den Support mobiler oder Desktop-Geräte?
  • Was für ein Grid wird für das geplante Layout genutzt? Inwiefern verhält es sich bei Verringern der Bildschirmbreite (werden z.B. erst Abstände zwischen Spalten reduziert, ändern Spalten ihre Reihenfolge, wie viel Spalten sollen je Bildschirmbreite auf einer Zeile liegen, etc.)?
  • Welche Inhalte müssen je Bildschirmgröße ihre Darstellungsform ändern?

Anhand der Beantwortung solcher Fragen kann man beispielsweise besser entscheiden, welche Breakpoints es braucht / welche Größenbereiche man außer Acht lassen kann und welcher Entwicklungsansatz (mobile-first / desktop-first) sich beim Bau der Webseite eignet. Bei manchen Inhalten, die je Bildschirmgröße ihre Darstellungsform ändern, kann es sogar notwendig (oder einfacher) sein, mit unterschiedlichen Strukturen im Markup zu arbeiten. Vielleicht macht es bei bestimmten Inhalten/Funktionen (z.B. eingebettete Applikationen, iFrames) auch Sinn, sie für eine bestimmte Größe komplett herauszunehmen, da sie evt. schlecht bedienbar sind oder zu viel Ladezeit fordern (also mehr Nachteile für den Nutzer bringen).

In deiner Situation ist es für einen Anfänger sicherlich einfacher, auf Themes (für CMS) oder Templates zurückzugreifen. Letztere findet man leicht via Suchmaschine (z.B. mit dem Suchquery: free html templates responsive). Ergebnisseiten sind beispielsweise HTML5 UP! oder ThemeWagon. Letzten Endes braucht man in diese dann nur noch seinen Inhalt einsetzen und evt. kleine nachträgliche Anpassungen (Farben, Schriften) vornehmen.

Ein weiteres Hilfsmittel könnten CSS-Frameworks sein, die ein Grid vorimplementieren. Es genügen an der Stelle also bereits minimalistische Frameworks wie Milligram oder Skeleton. Alternativ kannst du dir natürlich ein eigenes Grid-System schreiben. Schau dir hierzu auch CSS Grid und Flexbox an.

Wenn man diese Grid-Implementation dann von Anfang an durchgängig / konsistent beim Erstellen des Markups berücksichtigt, sollte ein großer Teil leicht erledigt sein.

Sollte es zwischen mobiler und Desktopansicht zu viele und große Unterschiede geben und deiner Meinung nach zu schwierig gestalten, dies unter einen CSS-Hut zu bringen, kannst du ebenso darüber nachdenken, zwei unterschiedliche Seiten auszuliefern (unterschiedliches HTML/CSS/JS je Gerät). Den Redirect auf die richtige Version kannst du auf unterschiedlichen Wegen implementieren:

  • serverseitig mittels eigener Dispatcher-Implementation; zur Prüfung des Geräts kann der User Agent aus dem Request ausgelesen werden
  • serverseitig mittels Konfiguration des Webservers (der User Agent dient erneut als Kriterium für die Weiche)
  • wenn es einen Proxy/CDN gibt, kann auch der die Umleitung übernehmen
  • clientseitig via JavaScript (entweder man prüft den User Agent oder die Fensterbreite)
  • ganz einfach: Binde im Headerbereich deiner Seite einen Link ein, der auf die jeweils andere Seitenversion verweist

Auf http://detectmobilebrowsers.com/ findest du für unterschiedliche Fälle ein paar Skripte, die du nutzen kannst.

Dieser Lösungsweg wäre meines Erachtens aber nur ein Notfallplan, denn er birgt auch Probleme. Wenn die Weiche nicht greift, weil ein Seitenbesucher (Crawler eingeschlossen) einen falschen User Agent übermittelt, landet der initial auf der falschen Seite. Bei einem clientseitigem Redirect (via JS oder Link) braucht ein Nutzer womöglich mehr Zeit, um auf die richtige/für ihn gut nutzbare Seitenversion zu gelangen.

...zur Antwort