IRC Logs for #lost


2021-05-23

00:34:06 Core_ joined the channel
02:04:24 LittleFox: Core_, je nach definition
02:04:47 LittleFox: also, gerade sitze ich vor einer eigenen sprache um syscalls und services zu definieren - das wird dann nach C übersetzt
02:09:16 LittleFox: aber ist halt wirklich nur deklaration
02:09:28 LittleFox: ansonsten kenne ich aber zumindest die theorie hinter compilerbau ^^
02:09:44 LittleFox: (und register allocation hab ich hier auch schon)
08:09:31 Core_: Ok, dieser Part interessiert mich.
08:12:46 Core_: Ich wollte die SPS Programmiersprachen auf einem Mikrocontroller ausführen lassen. Jetzt stand zur Auswahl Bytecode und ein Interpreter oder halt direkt in Maschinencode übersetzen, was performanter wäre.
08:14:53 Core_: Diese Sprachen sollten aber auch in einer Runtime auf einem RPI ausführbar sein.
08:19:28 Core_: Jetzt hab ich gelesen, dass der GCC auch eine Zwischensprache als Front End um unterschiedliche Sprachen einfach zu kompilieren. Die Zwischensprache heißt GIMPLE. Hast du damit schon Erfahrungen gemacht ?
09:13:15 CubeCoder joined the channel
09:13:22 CubeCoder: moin
09:24:43 Core_: hey
09:28:47 CubeCoder: wenn ich was in assembler an eine speicheradresse schreiben will (in meinem fall bei 0xb8000 für die bildschirmausgabe) wie kann ich das machen? muss ich die adresse erst in ein register laden?
09:34:01 Core_: Soweit ich weiß, sieht die CPU jede Hardware als "RAM" an. Du musst einfach nur dein gewünschten Wert in die Speicheradresse 0xb8000 schreiben. Jetzt weiß ich aber nicht wie man das in ASM macht.
09:35:02 Core_: Wenn dein Bildschirm eine spezielle Schnittstelle hat, z.B. UART, SPI, I2C, dann muss du erstmal einen Treiber für die Schnittstelle zum Bildschirm schreiben.
09:37:17 CubeCoder: ne der hat keine spezielle schnittstelle man muss eben nur werte (char-code und color) zu der genannten stelle (0xb8000) schreiben. in c weiß ich wie ich es mache aber eben nicht in asm...
09:38:19 Core_: Welchen Compiler benutzt du für Assembler ?
09:39:34 CubeCoder: programmiere ein betriebssystem und nutzte zig als crosscompiler da ich faul bin und windows benutze :D
09:40:29 CubeCoder: naja ich versuch eher eins zu programmieren aber auch eher um zu verstehen wie die untersten prozesse funktionieren
09:42:03 Core_: Programmierst du in C oder ASM dein OS ?
09:43:53 CubeCoder: eigentlich in c aber den ersten (winzigen) "schritt" muss man ja mit asm machen um den c code auf zu rufen und wollte jetzt mal schauen wie das was ich bisher in c gemacht habe (was nicht viel ist) mit reinem asm gehen würde...
09:44:45 Core_: Dann solltest du erstmal ASM lernen :D
09:45:15 Core_: Um Daten auf eine Speicheradresse zu verschieben brauchst du den mov Befehl
09:46:53 Core_: Du kannst mit dem mov Befehl Werte oder Daten aus einem Register zu einer Speicheradresse verschieben
09:47:22 Core_: mov 0xb8000, 11
09:47:40 CubeCoder: ja hatte ich mir fast schon gedacht aber da weiß ich dann nicht wie ichdie einzelnen zeilen und spalten anspreche...
09:48:03 CubeCoder: muss ich dann 0xb8000 immer weiter führen also dann 0xb8001
09:48:06 CubeCoder: und so weiter?
09:55:47 Core_: http://www.brackeen.com/vga/
09:56:23 Core_: Am einfachsten geht das über die VGA Schnittstelle, hier ist alles relativ gut erklärt
09:57:20 Core_: Du musst wissen wie der Video RAM aufgebaut ist, also welche Adresse was macht
09:58:51 CubeCoder: ja es geht mir hier ja nicht um vga bzw. den video mode sondern um den text mode...
10:04:27 CubeCoder: kann auch sein dass ich gerade absolut dumm bin...
10:09:20 Core_: https://wiki.osdev.org/Text_mode
10:16:39 CubeCoder: ja genau das in c weiß ich ja schon wie das geht mir fällt es nur schwer das in assembler zu machen also mit mov kommt zum beispiel ein fehler... (wobei ich auch nicht weiß ob das so wie ich das gemacht habe richtig ist)
11:03:20 Core_: https://wiki.osdev.org/%22zig_cc%22_Cross-Compiler
11:03:31 Core_: https://wiki.osdev.org/Bare_Bones_with_NASM
11:03:46 Core_: https://www.nasm.us/
11:04:27 Core_: So wie ich das verstanden hab, benutzt der zig compiler die nasm-Syntax
11:05:08 xq: huhu
11:05:48 xq: Hey, hat jemand von euch schonmal eine eigene Programmiersprache entwickelt ?
11:05:50 xq: jo, hab ich
11:06:14 xq: ich werd jetzt die textwand danach nicht lesen, worum gehts denn grobb?
11:07:48 Core_: @xq ich hatte nur gefragt ob jemand seine Programmiersprache an den gcc angeknüpft hat.
11:08:02 xq: ah
11:08:07 xq: ne, hab mit GIMPLE keine Erfahrung
11:08:09 Core_: Also das man seine Sprache dann in GIMPLE
11:08:13 xq: ich würde behaupten, LLVM ist einfacher
11:08:21 xq: die API ist schon sehr nice
11:08:23 Core_: Ja hab ich auch schon gelesen :D
11:09:18 xq: ich hab halt nur ne VM-Sprache bisher gebaut, noch kein "echtes" Codegen mit register allocation
11:10:03 Core_: Ich möchte halt eine genormte SPS-Programmiersprache für den Atmega übersetzen und da Bytecode zu langsam für den Controller wäre, ist ein direktes übersetzen in Maschinencode performanter
11:10:11 xq: jo
11:10:19 xq: was soll die so können?
11:10:26 xq: ggf. ist AVR-Assembler einfach einfacher zu erzeugen als GIMPLE
11:10:39 Core_: Genau und deswegen wollte ich den gcc dafür missbrauchen
11:11:15 Core_: Das Problem ist, dass diese Sprache auch in einer Runtime auf einem RPI laufen sollte
11:11:28 xq: ah
11:11:37 xq: was für features hast du?
11:11:43 xq: pointer? malloc?
11:11:44 xq: strings?
11:11:50 xq: oder ist alles statisch bekannt?
11:12:14 Core_: Das muss ich mal noch in der Norm nachschauen
11:12:49 Core_: Als Vorlage dient die IEC 61131, der Teil 3 der Norm beschreibt die Sprache
11:12:52 xq: weil wenn es wirklich nur irgendwie "setze variable auf wert X"
11:13:09 xq: also integer-wert wäre
11:13:15 Core_: Strings und pointer gibt es dort wahrscheinlich auch
11:13:16 xq: dann würde ich ehrlich gesagt einfach AVR-Assembler raushusten
11:13:50 Core_: Arrays, sowie statische ist die Sprache auch
11:14:08 Core_: Structs auch
11:14:34 Core_: Speicherallokation wird automatisch durchgeführt
11:15:14 xq: speicherallokation?
11:15:19 Core_: also malloc gibt es meines Wissens nicht in der SPS-Programmierung
11:15:47 xq: okay, das gut
11:17:19 xq: ist das dann structured text?
11:17:38 Core_: Die SPS-Programmierer programmieren ja nur mit Bildchen und wenn textbasiert, dann nur in einer Sprache angelehnt an Pascal
11:18:04 xq: jo, das ist structured text
11:19:29 Core_: https://infosys.beckhoff.com/index.php?content=../content/1031/tcplccontrol/html/tcplcctrl_plc_data_types_overview.htm&id=7365416610509907248
11:19:41 Core_: genau
11:20:52 xq: LOL
11:20:57 xq: mein dad hat mir grade genau den link geschickt :D
11:21:28 xq: strings sind fixed-size
11:21:51 Core_: Jetzt musste ich bei der Arbeit eine ganze Anlage mit C/C++ programmieren auf einem Controllino und das war schwerer als in einer SPS-Programmiersprache
11:21:54 xq: sieht aus als müsste man sich das alles selber fummeln
11:22:17 xq: von daher: das sieht mir aus, als könntest du da direkt AVR assembler raushusten
11:22:22 Core_: Ist dein dad SPS-Programmierer
11:22:24 Core_: ?
11:22:38 xq: Freiberuflicher Software-Entwickler
11:22:43 xq: macht ab und an mit Beckhoff kram
11:22:57 Core_: Aso, das ist ja cool
11:23:11 Core_: Ich programmier momentan alles mögliche
11:23:54 Core_: von C/C++, Python, SPS und demnächst LabVIEW
11:24:26 xq: joa, nice
11:24:41 xq: CubeCoder hat sich dein Problem gelöst?
11:25:15 CubeCoder: nah nicht so richtig glaube ich bin mal wieder zu dumm dafür xD
11:25:36 xq: *unerfahren
11:25:39 xq: woran scheiterts?
11:27:10 CubeCoder: also will halt einen buchstaben auf der textausgabe haben und dafür muss ich ja an die adresse 0xb8000 den charcode setzten (für stelle x=0, y=0) aber der move befehl will das irgendwie nicht...
11:27:18 xq: ah
11:27:20 xq: mit asm?
11:27:24 CubeCoder: jap
11:27:49 CubeCoder: hab das bisher so: movl [0xb8000], 0x41
11:27:56 xq: hm
11:27:57 xq: denk dran:
11:28:00 xq: du musst noch die farbe setzen
11:28:07 xq: movl schreibt 1,2 oder 4 byte?
11:28:12 xq: müssten 4 sein, oder?
11:28:18 CubeCoder: jap eig schon
11:28:30 xq: damit setzt du zwei chars, einen auf 0x41 (schwarz/schwarz) und einen auf 0x00 (schwarz/schwarz)
11:28:36 xq: damit solltest du: nix sehen
11:29:00 CubeCoder: ja ne das ist noch gar nicht das problem
11:29:05 xq: okay?
11:29:26 CubeCoder: der compiler (zig) sagt: invalid operand for instruction für den wert 0x41
11:29:58 xq: achso
11:30:16 xq: du schreibst intel-syntax für clang, der frisst nur lecker at&t syntax :D
11:30:41 CubeCoder: okay das heißt...?
11:31:21 xq: movl $65, 753664
11:31:21 CubeCoder: da muss ein $ vor?
11:31:22 xq: schreib mal das
11:31:26 CubeCoder: okay
11:31:37 xq: movl $64, 0xB8000
11:32:00 xq: movl $0x40, 0xB8000
11:32:01 xq: das hier ist richtig
11:32:16 xq: at&t hat "left to right", also links input, rechts output
11:32:24 xq: alle anderen assembly-syntaxen, die ich kenne, haben links output, rechts input
11:32:49 CubeCoder: yay funktioniert danke :D
11:33:02 CubeCoder: ich komme bei den syntaxen immer voll durcheinander :D
11:33:31 xq: gz :)
11:34:08 xq: ich bin mal n bisschen draußen
11:34:11 xq: laters! o/
11:34:17 CubeCoder: jup hf
11:34:23 Core_: bye
12:03:34 Paddy joined the channel
13:59:42 xq: re
15:37:25 Core_: hey
16:46:08 CubeCoder: hab mal so ne frage braucht man für in und out (also bei den COMs/Ports) schon interrupts?
16:53:08 xq: nope
16:53:28 xq: man braucht generell für wenig interrupts
16:53:40 xq: im endeffekt nur für preemptives multithreading
16:56:44 xq: obs gut ist: nich wirklich, aber es geht
17:10:09 Core_: Die Hardware kümmert sich bei den COM Ports um das Zwischenspeichern der Daten beim Senden und Empfangen
17:10:26 xq: jo, aber du kannst den FIFO trotzdem überrennen
17:10:33 xq: muss man vorher pollen, ob schon gesendet werden ann
17:10:42 Core_: genau
17:12:19 Core_: Bei Mikrocontrollern ist der Buffer sehr klein und deswegen muss man dort mit Interrupts arbeiten, wenn du während dem warten auf Daten noch Berechnungen durchführst
17:12:29 xq: am PC auch
17:12:30 xq: :D
17:12:57 Core_: Ja dort ist aber Buffer viel größer :D
17:13:17 Core_: und die CPU ist schneller :D
17:16:47 xq: der buffer ist afaik nicht sonderlich groß beim Seriellport
17:16:50 xq: außer du nutzt QEMU
17:16:54 xq: weil dort ist der buffer *fake*
17:17:19 CubeCoder: der grund meiner frage: ich habe irgendetwas mit out und in verhauen weil der immer sagt: conflicting types for 'outb' dabei habe ich nur eine methode und schon überall geschaut ob ich im header oder so noch ne weiter definition habe...
17:18:01 xq: hm?
17:18:07 xq: zeig mal die outb-funktion
17:18:41 CubeCoder: ist eig einfach nur das: asm volatile ("outb %0, %1" : : "a" (data), "Nd" (port));
17:19:27 xq: fehlermeldung bitte auch einmal komplett
17:19:31 xq: und funktion drumrum
17:19:51 CubeCoder: error: conflicting types for 'outb'
17:19:51 CubeCoder: void outb(int port, int data)
17:20:41 CubeCoder: https://hastebin.de/maluyupatu.m
17:21:41 xq: data sollte nur 8 bit groß sein, nicht 32
18:55:54 CubeCoder: achso also ein short?
18:56:21 CubeCoder: ne sry ein char
18:57:33 xq: uint8_t
18:57:43 xq: benutze bitte kein long/int/short/char
18:57:47 xq: das ist alles nur kak
18:57:48 xq: *kaka
18:57:53 CubeCoder: okay :(
18:58:18 CubeCoder: weil damit der sinn entfremdet wird oder warum?
18:58:43 xq: nein
18:58:53 xq: weil die C-Typen scheiße definiert sind
18:59:05 xq: und du erst mal compiler und compilerflags angucken musst, u zu wissen, wie groß "int" ist
18:59:11 xq: int32_t ist einfacher zu lesen
18:59:18 CubeCoder: aso
18:59:22 xq: und dokumentiert, dass du hier wirklich 32 bit auf jeder plattform haben willst
18:59:36 CubeCoder: was macht eig das t da am ende also warum schreibt man das da noch hin?
19:00:01 xq: weil der C-Standard sagt, dass alle im C-Standard enthaltenen Typen auf "_t" enden
19:00:12 xq: und alles, was darauf endet, für den standard reserviert ist
19:00:18 CubeCoder: aso
19:00:19 xq: du darfst also nicht deine Typen mit "_t" beenden
19:00:34 CubeCoder: okay...
19:32:29 CubeCoder: ähm fehler bleibt...
19:38:01 xq: hm
19:38:23 xq: sicher, dass du outb nicht doppelt definiert hast?
19:38:35 xq: kannst du mal *die ganze* fehlerausgabe deines compilers pasten?
19:38:48 xq: also nicht das, was deine potentielle IDE ausgibt
19:39:49 CubeCoder: ja eig sicher https://hastebin.de/vabulolewo.lua
19:42:36 CubeCoder: okay wait
19:43:01 xq: note: previous implicit declaration is here
19:43:03 xq: da stehts doch
19:43:05 xq: LESEN!
19:43:33 LittleFox: hm?
19:43:45 LittleFox: as in, I fluently read machine code?
19:44:15 xq: nein, as in "das was der compiler dir auf stdout ausgibt"
19:44:48 CubeCoder: hä was steht da?
19:45:11 LittleFox: aso, ja klar
19:45:15 LittleFox: was sonst o_O
19:45:33 CubeCoder: wait
19:45:35 CubeCoder: wtf
19:45:42 xq: CubeCoder:
19:45:44 xq: lese folgende sätze:
19:45:46 xq: warning: implicit declaration of function 'outb' is invalid in C99
19:45:46 LittleFox: warum ist das lua
19:45:48 LittleFox: :D
19:45:51 xq: error: conflicting types for 'outb'
19:45:55 xq: note: previous implicit declaration is here
19:46:00 xq: und ich rede von *lesen*
19:46:03 xq: nicht "kurz angucken"
19:46:12 LittleFox: vor allem auch die warnungen
19:46:15 LittleFox: die sind noch relevanter
19:46:19 LittleFox: fix die warnungen, das fixt dir auch den rest
19:46:33 xq: jop
19:46:37 CubeCoder: ja da steht das die da conflicten und dann das eine vorherige deklaration da ist
19:46:41 xq: exakt
19:46:46 xq: und was für eine deklaration?
19:46:51 CubeCoder: outb
19:46:54 LittleFox: *meld meld meld*
19:46:56 LittleFox: neiin
19:46:57 LittleFox: *meld*
19:47:02 CubeCoder: :(
19:47:02 LittleFox: ok,
19:47:06 xq: LittleFox: ich weiß, dass du das weißt <3
19:47:08 LittleFox: also, ja, es geht um outb
19:47:11 LittleFox: aber das ist nicht das relevante
19:47:14 LittleFox: finde das relevante wort
19:47:19 LittleFox: auch im zusammenhang mit den warnungen
19:47:23 xq: sind ja nicht mehr so viele übrig *grins*
19:47:24 LittleFox: die haben auch das wort
19:47:29 LittleFox: und es ist nicht function
19:47:40 LittleFox: (oh das ist ja in den notes gar ne)
19:47:54 xq: jaja, aber notes zeigen IDEs nicht an
19:47:55 xq: wel dumm
19:47:59 LittleFox: O_o
19:48:03 xq: JA.
19:48:04 LittleFox: da gibts doch bestimmt nen knopf
19:48:06 LittleFox: sogar VS hat den
19:48:09 xq: ^^
19:48:17 xq: ich hab in jeder IDE was vermisst
19:48:24 xq: ich code selbst C# mit "Ausgabe" mittlerweile statt Fehlerliste
19:49:27 CubeCoder: okay ich weiß nicht was für ein wort ihr meintet aber utb und inb mussten vor den aufruf
19:49:32 LittleFox: ..
19:49:35 xq: "implicit"
19:49:36 LittleFox: das wort ist implicit"
19:49:42 xq: da war nicht mehr viel wort übrig
19:49:43 LittleFox: das ist das gegenteil von explicit
19:49:53 LittleFox: erkläre uns die bedeutung dieser wörter
19:50:14 LittleFox: (CTRL+D, "Starting default target", *RATTERRATTERRATTER*)
19:50:58 CubeCoder: ähm
19:51:52 CubeCoder: implicit ist, dass der das vor dem aufruf braucht und explizit nach dem aufruf??!
19:51:55 LittleFox: nein
19:51:57 LittleFox: duden
19:51:58 LittleFox: jetzt
19:53:17 CubeCoder: ey das wird nur im bildungssprachlichen gebrauch genutzt woher soll ich das denn wissen? xD
19:53:51 xq: Frau Deutschlehrerin, darf ich gehen?
19:54:02 xq: wenn man was nicht kennt, guckt man es nach
19:54:07 xq: so tut programmieren
19:54:28 CubeCoder: echt tut das so?
19:54:34 CubeCoder: wusst ich gar nicht
19:54:40 xq: tja
19:54:49 xq: es scheint so, als wäre das der fall, ja
19:55:04 LittleFox: " Frau Deutschlehrerin, darf ich gehen?"
19:55:09 LittleFox: erst wenn CubeCoder das verstanden hat!
19:55:12 xq: mist.
19:55:17 CubeCoder: xDD
19:55:24 LittleFox: wenn CubeCoder das nicht herausfindet klärt ihr als Klasse das sicher unter euch
19:55:27 CubeCoder: dann leide ich wenigstens nicht alleine
19:55:38 CubeCoder: shit
19:55:40 CubeCoder: hilfe mama
19:55:52 xq: Nein, es gibt keinen Telefonjoker!
19:56:01 CubeCoder: fck
19:56:03 LittleFox: .. das war nicht warum nach hilfe gerufen wurde :D
19:56:05 LittleFox: oder?
19:56:11 LittleFox: eher so, klassenkeile angesagt
19:56:13 LittleFox: dachte ich
19:56:18 CubeCoder: ne eig nicht xD
19:56:31 LittleFox: hm
19:57:06 LittleFox: muss ich die klassenkeile wohl explizit ansagen statt sie zu implizieren
19:57:22 CubeCoder: xDD
19:57:52 CubeCoder: okay back to topic
19:58:22 CubeCoder: implizeren heißt doch in sich tragen bzw halt das es etwas vorraussetzt
19:58:28 xq: LittleFox: LUL
19:58:41 xq: CubeCoder: fast
19:58:54 xq: also, der zweite teil ist nah dran, aber noch falsch
19:59:56 LittleFox: was setzt es den voraus?
20:00:10 CubeCoder: das es deklariert ist
20:00:13 LittleFox: (dabei hab ich doch gerade gar kein azubi...)
20:00:16 LittleFox: nein
20:00:42 CubeCoder: x gilt: Wenn x die Eigenschaft A besitzt, dann besitzt es auch die Eigenschaft B (Wikipedia)
20:00:52 LittleFox: ich glaube das hilft dir nicht
20:00:55 CubeCoder: shit
20:01:34 xq: aber ja, das ist die definition von "Implikation" in theoretischer Informatik
20:02:06 CubeCoder: impliziert = bedeuten?
20:02:17 xq: nein
20:02:19 xq: du rätst
20:02:23 LittleFox: du sollst nicht raten
20:02:34 xq: ich helf dir mal
20:02:35 xq: https://www.duden.de/suchen/dudenonline/impliziert
20:02:56 CubeCoder: ja da bin ich schon drauf
20:02:58 LittleFox: https://www.duden.de/rechtschreibung/implizit
20:03:00 LittleFox: lol
20:03:15 LittleFox: implizit #^ trifft es sehr gut
20:03:18 LittleFox: #^
20:03:20 LittleFox: ...
20:03:21 LittleFox: #1
20:03:49 xq: jo
20:04:23 CubeCoder: bin ich jetzt erlöst?
20:04:40 xq: nein :D
20:04:48 CubeCoder: :(
20:05:06 LittleFox: hast du es verstanden?
20:05:12 CubeCoder: ja
20:05:25 LittleFox: also, mit der frage ob du jetzt erlöst bist, hättest du das ja durchaus implizieren können
20:05:30 LittleFox: und nun hast du es explizit gesagt
20:05:31 LittleFox: hm
20:05:34 LittleFox: dann erklär es nochmal
20:05:36 LittleFox: mit eigenen worten
20:05:38 CubeCoder: also ich hatte es vorher implizit und jetzt habe ich es explizit weil ich es davor geschrieben habe oder?
20:05:49 LittleFox: definiere "es"
20:05:49 xq: soweit korrekt, ja
20:05:59 CubeCoder: die funktion outb
20:06:40 CubeCoder: imagine durch os programmierung deutsch lernen
20:07:03 xq: jo, ist wichtig
20:07:09 xq: Programmierer müssen korrekt formulieren können
20:07:18 xq: Sowohl Code, aber vorallem auch präzise Dokumentation
20:07:33 CubeCoder: gut also das ich deutsch als prüfungsfach im abi nehme
20:07:53 LittleFox: vor allem musst du halt auch fehlermeldungen verstehen können
20:07:55 LittleFox: generell text
20:07:59 LittleFox: spezifikationen genau so
20:08:03 LittleFox: genauso*
20:08:09 LittleFox: ach whatever, scheiß auf deutsch
20:08:13 LittleFox: same with specs
20:08:13 LittleFox: so
20:08:14 CubeCoder: xDD
20:08:48 LittleFox: aaaaah
20:08:59 LittleFox: über LF OS kernel 1 bluescreen code gestolpert
20:09:02 LittleFox: der ist so schlimm xD
20:15:19 xq: oh no!
20:15:29 xq: CubeCoder: englisch bringt dich weiter beim coden als deutsch
20:15:32 xq: *sehr viel* weiter
20:15:45 xq: faktor 4-8 im gehalt weiter, wenn du ins ausland guckst
20:16:08 CubeCoder: ja ach wer braucht schon geld xDD
20:17:34 CubeCoder: warte unsigned sind immer positiv oder?
20:17:39 xq: nein
20:17:47 LittleFox: well
20:17:50 xq: ich weiß, was du meinst, aber die aussage ist falsch
20:17:51 LittleFox: der wert an sich schon
20:17:54 LittleFox: aber
20:17:56 xq: LittleFox: that depends
20:17:57 LittleFox: .
20:17:57 CubeCoder: okay dann habe ich wieder irgendwo scheiße gebaut
20:18:07 CubeCoder: warte
20:18:08 xq: CubeCoder: denk nochmal über deinen Satz nach ;)
20:19:31 CubeCoder: ach ihr seid doch doof
20:19:42 LittleFox: hach ja ... meinen ausbildungsplatz damals bekam ich weil ich zur bewerbung ne CD beigelegt hab
20:19:48 LittleFox: mit programmierbeispielen was ich schon gemacht hab
20:19:59 LittleFox: LF OS mit drauf - wo das meiste komplexe ausm lowlevel wiki war x)
20:20:11 xq: LittleFox: das ist trotzdem ne gute Beigabe
20:20:18 xq: CubeCoder: weißt du jetzt, was ich meine?
20:21:21 CubeCoder: ne aber bestimmt wieder weil irgendetwas auf der welt passiert ist was nur du mitbekommen hast...
20:22:08 CubeCoder: gefällt dir: unsigned integer können keine negativen zahlen beinhalten. besser?
20:22:24 LittleFox: hm das wäre das gleiche in grün
20:22:28 CubeCoder: och
20:22:33 CubeCoder: ahhhhhhhhhhhhhhh
20:22:36 CubeCoder: hilfe
20:22:37 LittleFox: außer xq argumentiert nun dass 0 nicht positiv ist
20:23:04 xq: 0 ist nicht positiv
20:23:11 xq: positiv ist "x > 0"
20:23:16 CubeCoder: ich habe hier viel zu wenige emojis um mich auszudrücken
20:23:28 xq: Anfänger! 😂
20:23:41 CubeCoder: also gefällt dir mein zweiter versuch besser?
20:24:14 CubeCoder: 😭
20:24:29 xq: jap.
20:24:33 xq: hab nix auszusetzen
20:24:52 CubeCoder: okay "bestimmt wieder weil irgendetwas auf der welt passiert ist was nur du mitbekommen hast..." lag ich doch richtig
20:25:23 xq: hm?
20:25:57 CubeCoder: ja irgendwelche kleinigkeiten an die du wieder rumnörgelst... 😭😭
20:26:27 CubeCoder: *denen
20:26:27 LittleFox: xq floats widersprechen dir
20:26:42 LittleFox: da gibts +0 und -0
20:27:29 xq: das ist aber nur eine encoding-geschichte
20:27:42 xq: darum gibts ja float-normalisierung
20:27:46 CubeCoder: sagt man dann
20:30:18 LittleFox: hmja ok
20:38:15 core_mobile joined the channel
20:38:22 Paddy joined the channel
20:39:51 xq: ich kann erfolgreich Schrift auf PC und Android rendern
20:39:54 xq: WASM hängt noch
20:40:03 CubeCoder: nice
20:40:04 xq: CubeCoder: viel erfolg noch!
20:40:07 CubeCoder: danke
20:40:11 xq: https://cdn.discordapp.com/attachments/271060591026634752/846112908776701952/sexy.png
20:40:29 CubeCoder: ah ja xD
20:45:17 core_mobile joined the channel
20:51:28 core_mobile joined the channel
20:57:44 CubeCoder: jmd ne idee warum mein char * nicht "überschrieben wird?"
20:57:54 CubeCoder: * "überschrieben"
20:58:46 CubeCoder: mache einfach char * str = "hi oder so"; und dann str[0] = 'l'; aber das funktioniert nicht
20:58:57 CubeCoder: sollte doch eigentlich oder?
21:08:02 core_mobile joined the channel
21:14:49 Core joined the channel
21:17:16 LittleFox: moin Core
21:17:34 LittleFox: hab den backlog nicht gelesen, aber iwas war da mit eigener sprache
21:17:43 LittleFox: falls da noch was offen ist ^^
21:23:24 CubeCoder: bb
22:29:16 Core joined the channel