Angenommen, bei Programmstart soll ein Actor an Koordinate (1/2) in der Welt platziert werden. Dann musst du das so auch in der Startmethode (oder einer separaten setup-Methode, die in der Startmethode aufgerufen wird) deines Programms vorgeben.

Praktischerweise gibt es dazu auch schon eine Funktion in Greenfoot, mit der du eine aufgebaute Welt speichern kannst. Sie generiert dir darauffolgend den notwendigen Programmcode (lies hier).

...zur Antwort

a) Statt dem echo-Befehl, kannst du auch noch einmal auf die index.html zurückleiten:

header("Location: URL-to-index.html");

b) Ändere die Endung deiner index.html zu .php und kopiere den PHP-Block aus deinem Skript hinein. Im einfachsten Fall genau dort im body, wo später die Erfolgsmeldung stehen soll. Das action-Attribut des Formulars entfernst du.

Angedeutetes Beispiel:

<!doctype html>
<!-- head ... -->
<body>
  <form method="post">
    <!-- form fields ... -->
    <p class="result">
      <!-- your php block ... -->
    </p>
  </form>
</body>

Den else-Block kannst du entfernen, da du ihn nicht mehr brauchst.

Die Seite wird folgend bei Formularversand neu geladen. Die Daten werden an die selbe Seite geschickt und dann vom PHP-Skript ausgewertet.

...zur Antwort
Kann man Pygame auf dem iPhone installieren?

Man kann PyGame-Spiele auf iOS portieren. Deinem weiteren Text zufolge suchst du aber eigentlich nach einer Python-Entwicklungsumgebung für dein Gerät.

Zwei Optionen wären da replit (in der du auch PyGame installieren kannst) oder Pythonista. Mit letztgenannter App kannst du zwar auch kleine Spiele oder Animationen entwickeln, jedoch nicht mit PyGame.

(...) aber er ist so alt und langsam, das man fast nichts mit ihm anfangen kann (...)

Python/PyGame hat keine hohen Systemanforderungen. Daher wird es da wohl kaum Probleme geben.

...zur Antwort

Für die Speicherung von Nutzereinstellungen (wie Lautstärke, Bildschirmhelligkeit, u.ä.) kannst du PlayerPrefs verwenden.

...zur Antwort

Du kannst einen Texteditor wie Notepad++ oder Sublime Text nutzen, der beim Suchen und Ersetzen reguläre Ausdrücke erlaubt.

Die Semikolons am Zeilenanfang könntest du folgendermaßen mit

^;

aufspüren und die Semikolons am Zeilenende mit

;$
...zur Antwort
Weiß jemand wie man das beheben (...)

Mit FreeConsole löst du dich (bzw. den Prozess deines Programms) von der Konsole. Das heißt, du hast auf sie auch keinen Zugriff mehr. Du müsstest dich erst mit AttachConsole oder AllocConsole an eine Konsole binden, um wieder schreiben zu können.

(...) und vlt. auch welche Bedeutung die Rückgabewerte beider Imports haben?

Der Rückgabewert gibt bei beiden Funktionen jeweils an, ob die Aktion erfolgreich war. In dem Fall muss er ungleich 0 sein.

...zur Antwort

Ja, du darfst Visual Studio hierfür benutzen.

Wenn wir einmal davon ausgehen, dass du die Community Version verwendest, hast du folgende Rechte:

  • Als Einzelperson oder Organisation, die keinem Unternehmen entspricht, darfst du Visual Studio für Entwicklung oder Tests nutzen
  • Du darfst Visual Studio für die Demonstration deiner Anwendungen nutzen

Lies dazu konkret die Lizenzbedingungen. Dort wird unter 1b vii auch der Begriff Unternehmen genauer erklärt.

Des Weiteren solltest du davon absehen, Versprechungen zum Kurs abzugeben, die nicht mit Microsoft abgeklärt sind (bspw.: Werde Microsoft-Entwickler mit diesem Kurs, o.ä.).

...zur Antwort

Für so ein Projekt würde sich C++ in Kombination mit dem JUCE-Framework sehr gut eignen.

C++ selbst erlaubt dir direkten Systemzugriff, über den du Daten schnell (und konsistent) in Echtzeit verarbeiten kannst (Bsp.: SIMD für DSP-Algorithmen). Es gibt Schnittstellen/Wrapper für low-level APIs mit Audiofunktionalitäten wie CoreAudio, DirectX und OpenAL oder etliche Bibliotheken, die dir beispielsweise bei dem Einlesen oder Schreiben von Audiodaten helfen (z.B. Aquila, Essentia, PortAudio, RtAudio, usw.).

Ein weiterer Vorteil ist, dass du mit C++ objektorientiert arbeiten kannst. So kannst du dein Projekt besser strukturieren.

Das JUCE-Framework wiederum hat bereits verschiedene Funktionalitäten zur Audiohandhabung (siehe hier oder hier) vorimplementiert und zusätzlich gibt es mehrere Bibliotheken aus der Community (schau z.B. hier). Des Weiteren ermöglicht es dir die Entwicklung von (meiner Meinung nach schönen) grafischen Oberflächen (direkt zugeschnitten auf Audiosoftware), die auf verschiedenen Plattformen (Android, iOS, macOS, Windows) portierbar sind.

Alternativ würde sich auch Qt zur Entwicklung der grafischen Oberfläche eignen.

Hinsichtlich einer Vorbereitung für dein Projekt wäre es gut, zunächst mit den C++-Grundlagen (sowie klassenbasierter OOP) vertraut zu werden. Andernfalls macht ein Projektstart noch keinen Sinn.

Richte dir zuerst eine passende Entwicklungsumgebung ein, damit du möglichst früh mit dem, was du lernst üben/experimentieren kannst. Ein paar gute Optionen wären CLion, der QtCreator oder (nur für Windows) Visual Studio.

Bezüglich Lernquellen solltest du solche verwenden, die mindestens C++ 17 behandeln. Online kann ich hierbei auf LearnCpp verweisen. Empfehlenswerte Autoren für feste Literatur sind m.E. Nicolai M. Josuttis, Torsten T. Will, Thomas Theis oder Ulrich Breymann. In diesem Stackoverflow-Beitrag werden noch andere Empfehlungen angebracht.

Solltest du nach Lernkursen (Videos/Tracks) suchen, schau auf Codecademy, Coursera, Educative, in die JetBrains Academy oder auf Udemy.

Zu externen Bibliotheken/Frameworks findest du in der Regel genügend in deren jeweiligen Online-Dokumentationen.

Das ist aber soweit noch längst nicht alles. Zum einen müsstest du dich noch tief in das Thema Audioverarbeitung eingraben (was ziemlich mathematiklastig werden kann) und zum anderen solltest du wissen, wie du deine Anwendung am besten strukturiert aufbauen kannst.

Letzteres betrifft die Softwareplanung. Mach dich zu Architektur-/Entwurfsmustern schlau. Grundsätzlich macht es Sinn, die Anwendung modular nach MVC- oder MVVM-Aufteilung aufzubauen.

Damit du den Überblick nicht verlierst und Einbahnstraßendesign vermeidest, solltest du im Vorfeld analysieren, was du erreichen möchtest, brauchst und wie die benötigten Ressourcen ineinandergreifen. Ein paar Stichworte hierzu wären Anforderungsanalyse und UML (use cases, activities, object-/class-diagram, ...).

Zur Audioentwicklung kann ich dir ebenfalls ein paar nützliche Quellen mitgeben. Du solltest aber auch selbst noch weiter recherchieren.

  • Schau nach Büchern von Will Pirkle
  • ThinkDSP von A. B. Downey
  • The Audio Programming Book von R. Boulanger, V. Lazzarini
  • The Scientist and Engineer’s Guide to Digital Signal Processing von Steven W. Smith, Ph.D.
  • Musimathics, Vol. 2 von G. Loy
  • An Introduction to the Mathematics of Digital Signal Processing von F. R. Moore
  • Auf YouTube findest du einige Videos von der Audio DevCon (ADC), die interessant sein können
...zur Antwort

Groovy ist ganz nett, da du - so wie man es auch von anderen Skriptsprachen kennt - recht schnell und einfach kleine Anwendungen (z.B. Automatisierungsskripte, Unittests) entwickeln kannst. Im Gegensatz zu Java bietet Groovy mehr syntactic sugar (z.B. implizit generierte Getter/Setter, ein stärker ausgebautes switch-case-Konstrukt, Support für truthy-Werte) und generell kann man die Syntax viel schlanker halten.

Es macht meiner Meinung aber nur Sinn, Groovy als Erweiterung zu Java zu lernen (was es nun ja auch sein soll). Du wirst sie eh meist nur im Java-Umfeld antreffen. Einige Projekte nutzen Groovy direkt im Mix mit der Java-Sprache.

Was einen Umstieg von Java auf Groovy meines Erachtens etwas erschwert, sind Verhaltensunterschiede selbst bei gleichem Code (Beispiele: Der Equality-Operator, String-Literale, Multimethods, Standardsichtbarkeit von Feldern).

...zur Antwort

Bei InOut handelt es sich um eine Klasse, die vom Java Editor vordefiniert wird (siehe hier). Das heißt, in anderen Entwicklungsumgebungen (wie Eclipse, NetBeans, u.ä.) kannst du sie nicht verwenden, sofern du diese Klassendefinition nicht explizit mit in dein Projekt kopierst.

Diese Klasse stellt dir ein paar Methoden zur Verfügung, mit denen du Eingaben vom Konsoleneingabekanal lesen oder Ausgaben in den Konsolenausgabekanal schreiben kannst.

Die Methode readInt gibt zuerst die an sie übergebene Zeichenkette ("Zahl (>=0) : ") in der Konsole aus. Anschließend versucht sie die nächste Eingabe in der Konsole auszulesen und in eine Ganzzahl zu konvertieren. Wenn das klappt, wird die gelesene Zahl in eine Variable namens zahl abgelegt.

...zur Antwort

Beide eignen sich gut für den Fall, wenn man auf schnellem Weg eine einfache grafische Oberfläche (bspw. für Prototypen, Miniutilities/Gadget-Software, u.ä.) zusammenklatschen möchte. Für Entwickler, die noch wenig Erfahrung (vor allem in der Entwicklung von GUIs) haben, sollte ein Einstieg zudem bei beiden nicht schwerfallen.

Im direkten Vergleich ist tkinter besser aufgestellt, wenn es um die Lauffähigkeit auf verschiedenen OS geht. Neben einem nativen Look & Feel kann man auch Themes einsetzen (Standardthemes, eigene Themes oder Themes aus externen Quellen, z.B. ttkthemes).

Windows Forms wiederum bietet im Gegensatz zu tkinter eine größere Auswahl an vorimplementierten Komponenten und du kannst ebenso auf Themes (oder Eigenkreationen) zurückgreifen. Generell ist Windows Forms, aufgrund der zugrundeliegenden .NET-Architektur besser auf die Entwicklung von klassischen Businessanwendungen ausgelegt.

Solltest du Projektideen haben, bei denen die Entwicklung komplexer Oberflächen gefragt ist, die mit einer Vielzahl an Funktionalitäten, evt. etlichen geschachtelten Dialogen oder verschiedenen benutzerdefinierten Komponenten aufwarten (vgl. z.B. mit MS Word), dann würde ich dir empfehlen, eher mit Avalonia UI, MAUI oder WPF zu arbeiten.

Wenn es in Richtung Spieleentwicklung gehen soll (Spiele mit keiner statischen Oberfläche, wie z.B. Schach), wähle wiederum ein Tool, dass sich auf dieses Feld spezialisiert hat (z.B. MonoGame, Panda3D, Unity).

...zur Antwort

Ein Paragraph ist keine Überschrift. Selbst wenn du dessen Aussehen änderst, erlangt es nicht die selbe Bedeutung, wie ein h-Element.

Als die Überschriftenelemente in HTML definiert wurden, hat man sich einfach eine Zahl überlegt, mit der möglichst viele Anwendungsfälle abgedeckt werden können.

...zur Antwort

Mindestens eine deiner Projektabhängigkeiten ist signiert. Sobald du das Projekt zu einer JAR baust, passt die Signatur allerdings nicht mehr, da die anderen Projektbestandteile nicht signiert sind.

Schau einfach deine eingebundenen, externen JARs durch. Mit dem jarsigner aus dem JDK kannst du prüfen, ob eine JAR signiert (bzw. verifiziert) ist oder nicht:

jarsigner -verify someJarFile.jar

Signierte JARs haben in ihrem META-INF-Ordner entsprechend dsa-, rsa- oder sf-Dateien, die beim Build exkludiert werden müssen. Entpacke die JAR und prüfe selbst, welchen Signaturtyp du ausschließen musst.

Sowohl Maven (lies dazu hier):

<excludes>META-INF/*.DSA,META-INF/*.RSA,META-INF/*.SF,...</excludes>

als auch Gradle:

jar {
  from { (configurations.runtime).collect { it.isDirectory() ? it : zipTree(it) } } {
    exclude 'META-INF/*.DSA', 'META-INF/*.RSA', 'META-INF/*.SF', ...
  }
  /* ... */
}

bieten Optionen dazu an.

...zur Antwort

Ich würde es zunächst an einem bildlichen Beispiel beschreiben.

Stell dir vor, du bist Kellner in einem Bierzelt. Du könntest hier nun jedes Maß einzeln transportieren, was dich einige Zeit kosten dürfte. Effektiver wäre es, mehrere Krüge auf einem Tablett zu transportieren, welches so weit gefüllt wird, bis seine Belastungsgrenze ausgereizt ist.

Das Commit-Log wäre in diesem Fall die Kundenbestellliste. Sie sichert ab, dass jeder registrierte Kunde seine Bestellung erhält. Das Tablett stellt die MemTable dar. Es ist ein lokaler Zwischenspeicher, der erst einmal so viel aufnimmt, wie ihm möglich ist. Sobald das Tablett voll ist, werden die Krüge (Daten) zum tatsächlichen Zielsystem transportiert (SSTable) und somit die Bestellung abgeschlossen.

Was ist ein In-Memory-System?

Im Grunde ist damit ein Speicherbereich innerhalb des Arbeitsspeichers gemeint. Also Speicherplatz, der dem Programm (Cassandra) zur Programmlaufzeit zur Verfügung steht.

Der Vorteil an so einem System ist, dass die Daten schneller verarbeitet werden können. Der Computer hat einfachere, schnellere Zugriffsmöglichkeiten auf seinen Arbeitsspeicher.

Allerdings ist der Speicherplatz natürlich begrenzt und nicht persistent (bei Programmbeendigung wird der Bereich neu reserviert und die Daten sind weg). Daher müssen die Daten irgendwann in ein persistentes System übertragen (Speicherung auf der Festplatte/SSTable) werden.

Müsste Cassandra auf diesen Zwischenspeicher verzichten und die Daten stattdessen sofort auf der Festplatte speichern, würden die Schreibvorgänge viel länger dauern. Andersherum bietet der Zwischenspeicher den Vorteil, dass du Daten, die erst kürzlich geschrieben (aber noch nicht persistent gespeichert) wurden, schneller abrufen kannst.

Was ist ein MemTable?

MemTable ist einfach nur der Name für so einen Speicherbereich. Da die Daten im Speicher entsprechend formatiert werden (sodass sie später leichter/schneller in das persistente System übertragen werden können), ist das Wort Table in dem Begriff inkludiert.

Cassandra kann übrigens mehrere MemTables anlegen. Zu jeder Datenbanktabelle gibt es maximal eine aktive MemTable (die aktuelle Schreibvorgänge aufnimmt) und dazu kann es noch mehrere inaktive MemTables geben, die noch darauf warten, weiter befüllt oder geleert zu werden.

Was ist mit "die Daten hält, bis sie voll sind" gemeint?

Einfach gesagt, wartet eine MemTable darauf, einen bestimmten Schwellenwert zu erreichen. Ist die Datenbank z.B. so konfiguriert, dass eine Memtable maximal 5 MB fassen darf, würde sie bei Überbieten dieses Werts ihre Daten an die SSTable abgeben.

Es gibt allerdings noch andere Kriterien/Konfigurationsmöglichkeiten, die bestimmen, wann eine MemTable geleert wird. Du könntest eine Zeitperiode vorgeben (z.B. Speichere alle fünf Sekunden die Daten einer MemTable persistent) und es gibt ein Speicherlimit für das Commit-Log.

...zur Antwort

Ich denke, dass du eine Unterscheidung zwischen Produkten brauchst, die einzeln vorliegen können (z.B. Eier, Salatköpfe, o.ä.; wenn auch da noch eine Unterscheidung zwischen Größen/Mengen möglich ist, z.B. S, M, L, XL) und Produkten, bei denen nur die Totalmenge von Interesse ist (z.B. Mehl, Zucker). Daher ist es schon sinnvoll, die Anzahl separat zu halten.

Es sei denn, das Haltbarkeitsdatum soll mit einbezogen werden. In dem Fall sollte jedes Produkt als einzelne Instanz vorrätig sein.

Wenn er sonnst noch Verbesserungsvorschläge habt, gerne raus damit :)
  1. Entscheide dich für nur eine Sprache: Deutsch oder Englisch
  2. Du schreibst groceries öfter falsch
  3. Getter und Setter haben in einem Klassendiagramm eigentlich nichts zu suchen
  4. Die Anzahl/Menge bedarf keiner Abstraktion, es ist einfach nur eine Zahl (wobei ich nach obiger Logik eine Ganzzahl nutzen würde)
  5. Ich sehe aktuell nicht, wozu Household abgebildet werden müsste. Dem Programm kann es doch egal sein, ob sich ein Realnutzer die Wohnung mit anderen teilt oder nicht. Jeder Nutzer hat ein eigenes Lebensmittellager.
  6. Fridge ist kein so passender Name für ein Lebensmittellager. Ebenso stellt FoodEntry doch einen einzelnen Zutateneintrag im Rezept dar, statt eines Prüftools für die Verfügbarkeit von Produkten im Lager.
  7. Vermeide Namensdopplungen wie recipe_title in Recipe (das Attribut sollte stattdessen nur title heißen)
  8. Die Assoziationen solltest du nochmal überarbeiten. Manche haben mehrmalige Beschriftungen, bei denen ich nicht immer wüsste, was sie denn nun ausdrücken sollen (z.B. +wg). Andere wie +Rezeptabgleich sollen wohl logische Aktionen verdeutlichen (was eine Methode übernehmen würde, keine Assoziation).
...zur Antwort

Hol dir die Websettings deines Webview und vergib anschließend ein paar Rechte.

  • setAllowFileAccess
  • setJavaScriptEnabled

Schau in der Referenz am besten noch weiter, ob es noch weitere relevante Setter gibt.

...zur Antwort
Minecraft 1.20.4 - Eclipse Programmierung, kann keine Imports machen?

Ich möchte mit Java ein Plugin für 1.20.4 programmieren und habe mir ein Code von ChatGPT schreiben lassen.

package de.diamanthoe.plugin;

import org.bukkit.Material;

import org.bukkit.Particle;

import org.bukkit.command.Command;

import org.bukkit.command.CommandSender;

import org.bukkit.command.CommandExecutor;

import org.bukkit.configuration.ConfigurationSection;

import org.bukkit.configuration.file.FileConfiguration;

import org.bukkit.entity.Player;

import org.bukkit.inventory.Inventory;

import org.bukkit.inventory.ItemStack;

import org.bukkit.inventory.meta.ItemMeta;

import org.bukkit.plugin.java.JavaPlugin;

import org.bukkit.Location;

public class NaviSystem extends JavaPlugin implements CommandExecutor {

  @Override

  public void onEnable() {

    // Register commands

    getCommand("navi").setExecutor(this);

  }

  @Override

  public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {

    if (!(sender instanceof Player)) {

      sender.sendMessage("Dieser Befehl kann nur von Spielern ausgeführt werden.");

      return true;

    }

    Player player = (Player) sender;

    if (cmd.getName().equalsIgnoreCase("navi")) {

      if (args.length >= 1) {

        if (args[0].equalsIgnoreCase("save")) {

          if (args.length >= 2) {

            savePoint(args[1], player.getLocation());

            sender.sendMessage("Punkt gespeichert unter: " + args[1]);

          } else {

            sender.sendMessage("Verwendung: /navi save [Name]");

          }

        } else {

          if (args.length >= 3) {

            try {

              double x = Double.parseDouble(args[0]);

              double y = Double.parseDouble(args[1]);

              double z = Double.parseDouble(args[2]);

              Location target = new Location(player.getWorld(), x, y, z);

              createParticleTrail(player, target);

            } catch (NumberFormatException e) {

              sender.sendMessage("Ungültige Koordinaten.");

            }

          } else {

            sender.sendMessage("Verwendung: /navi <x y z>");

          }

        }

      } else {

        sender.sendMessage("Verwendung: /navi <x y z>");

      }

    }

    return true;

  }

  private void createParticleTrail(Player player, Location target) {

    Location playerLocation = player.getLocation();

    player.spawnParticle(Particle.REDSTONE, playerLocation, 0, target.getX(), target.getY(), target.getZ(), 10);

  }

  private void savePoint(String name, Location location) {

    FileConfiguration config = getConfig();

    config.set("points." + name + ".world", location.getWorld().getName());

    config.set("points." + name + ".x", location.getX());

    config.set("points." + name + ".y", location.getY());

    config.set("points." + name + ".z", location.getZ());

    saveConfig();

  }

  private void openPointsGUI(Player player) {

    Inventory gui = getServer().createInventory(null, 9, "Gespeicherte Punkte");

    ConfigurationSection pointsSection = getConfig().getConfigurationSection("points");

    if (pointsSection != null) {

      for (String pointName : pointsSection.getKeys(false)) {

        ConfigurationSection pointConfig = pointsSection.getConfigurationSection(pointName);

        if (pointConfig != null) {

          String worldName = pointConfig.getString("world");

          double x = pointConfig.getDouble("x");

          double y = pointConfig.getDouble("y");

          double z = pointConfig.getDouble("z");

          ItemStack pointItem = createPointItem(worldName, x, y, z);

          gui.addItem(pointItem);

        }

      }

    }

    player.openInventory(gui);

  }

  private ItemStack createPointItem(String worldName, double x, double y, double z) {

    ItemStack item = new ItemStack(Material.COMPASS);

    ItemMeta meta = item.getItemMeta();

    meta.setDisplayName(worldName + " - " + x + ", " + y + ", " + z);

    item.setItemMeta(meta);

    return item;

  }

}

Das Problem ist, dass da total viel rot unterstrichen wird, was wahrscheinlich auf die Imports zurückzuführen ist. Die Imports selbst sind teilweise ebenso rot interstrichen (org.bukkit).

Ich benutze das JDK 17 und Java SE 1.8.

...zur Frage
(...) was wahrscheinlich (...)

Lies die dazugehörigen Fehlermeldungen. Dann brauchst du nicht raten.

Bukkit selbst kann leicht via Maven integriert werden.

https://mvnrepository.com/artifact/org.bukkit/bukkit

...zur Antwort

Du sollst sechs Rechtecke mit der draw_rectangle-Funktion zeichnen. Das heißt, du benötigst sechs Aufrufe der Funktion, bei denen du jeweils andere Argumente übergibst. Ein Argument steht für die Breite, eines für die Höhe.

Beispiel:

draw_rectangle(100, 200)

Die teleport-Funktion wird dazu dienen, zu einer bestimmten Koordinate auf dem Zeichenfeld zu springen. So kannst du also auch immer den Startpunkt bestimmen, von dem aus draw_rectangle anfangen soll, zu zeichnen.

Wie/wo teleport definiert wird, musst du allerdings selbst nachschauen. Vielleicht soll sie sogar noch implementiert werden.

Deine Definition von draw_rectangle ist übrigens noch unvollständig. Ein Rechteck besteht aus vier Seiten. Du zeichnest nur zwei.

...zur Antwort

Lade deine Seite im Browser, führe die notwendigen Trigger aus, die für dein Skript notwendig sind (Buttonklicks oder was auch immer) und schau dann in die Browserkonsole, ob dir Fehler hinsichtlich des Skripts ausgegeben werden. Es könnte beispielsweise sein, dass das Skript aufgrund einer falschen Pfadangabe nicht geladen werden kann oder der Zeitpunkt seiner Ausführung falsch ist.

Wenn du diesbezüglich nicht fündig wirst, dann schau dir in den Webentwicklungstools deine JS-Datei an (in Chromium-basierten Browsern unter dem Tab Sources, in Firefox unter dem Tab Debugger). Es könnte sein, dass dein Browser noch eine alte Version deines Skripts lädt (hänge in dem Fall einfach eine Versionsnummer an den Pfad im src-Attribut, z.B. path/to/script.js?v=1). Andernfalls solltest du den integrierten Debugger der Entwicklungstools nutzen, um herauszufinden, welchen Weg der Programmfluss bei Ausführung des Skripts wählt.

...zur Antwort