#lost · 2016-02-15

362 Nachrichten · Seite 1 von 2 · Original-CSV herunterladen

  1. Svenskagrummel
  2. Svenskabtw: ACK kann auch i80 und Z80 ;)
  3. JonathanJa, klar, aber dann kann der vermutlich x86-spezifische Sachen weniger gut ;)
  4. Svenskanaja
  5. Svenskaminix wurde damit programmiert
  6. Svenskadann wird der das schon können
  7. Svenskaoder anders gesagt
  8. Svenskaes gibt bücher, in denen beschrieben ist, wie man mit ACK ein i86-betriebssystem programmiert :-D
  9. Jonathan:D
  10. Svenskaeins davon steht bei mir im schrank ^^
  11. Svenskahmm. ich vermute mal, dass windows mit FAT32 umgehen kann
  12. Svenskaqemu (mit win2k) gestartet, -hdb /dev/sdb
  13. Svenskamerke: windows mag FAT32 auf dem blockdevice nicht :(
  14. Jonathan:(
  15. Svenskamerke ferner: win2k mag android-tablets auch per usb nicht als MSC einbinden
  16. Jonathan:D
  17. JonathanWegen dem FAT32: Vermutlich will W2K ne Paritionstabelle sehen
  18. Svenskaja
  19. Svenskaauf disketten nicht, aber auf festplatten schon
  20. JonathanJoa
  21. Svenska...grml.
  22. JonathanHmm?
  23. JonathanBin mal weg, gute Nacht ;)
  24. masterq32huhu
  25. kevinMoin
  26. masterq32ich hatte am wochenende noch eine idee, was meine programmiersprache ein wenig von anderen abheben kann:
  27. masterq32compiletime-spezifikationen
  28. masterq32also sowas wie: parameter >= 0, returnValue > 0
  29. kevinAlso Zusicherungen?
  30. masterq32genau
  31. kevinWenn du die auch noch statisch geprüft bekommst, wär das eine nette Sache
  32. masterq32statische prüfung auf jeden Fall
  33. masterq32also für das meiste
  34. masterq32und dann muss ich wohl noch irgendeine art von fehlerbehandlung reinbauen :D
  35. masterq32aber wäre durchaus ne praktische sache
  36. masterq32speichermanagement überleg ich mir grade
  37. kevinWenn dein Compiler nicht schlau genug ist, zu verstehen, welche Werte alles möglich sind, könnte es halt passieren, dass man relativ viele Fälle, die es gar nicht gibt, abfangen muss
  38. masterq32ja
  39. kevinWenn das überhand nimmt, wäre es doof. Ein paar /* just to make gcc happy */ gibt es ja auch heute schon.
  40. masterq32:D
  41. kevinInsofern, in Grenzen nicht schlimm
  42. masterq32http://pastebin.com/tPrLUbK7
  43. masterq32grade hab ich sowas im kopf
  44. kevin? ist der Rückgabewert?
  45. masterq32ja
  46. masterq32hab im moment noch keine bessere idee dafür :D
  47. masterq32eventuell auch
  48. masterq32WITH ...
  49. masterq32RETURNS ? > 0
  50. masterq32BEGIN
  51. kevinWäre es nicht toll, mehrere Rückgabewerte zu unterstützen?
  52. masterq32wäre durchaus eine überlegung wert
  53. kevinIst natürlich die Frage, wie man das unterstützt. Ob return dann mehrere Parameter nimmt, oder eher Pascal-artig mit benannten Rückgabewerten.
  54. masterq32hmm
  55. kevinBenannt hätte den Vorteil, dass du weißt, was statt ? stehen muss ;-)
  56. kevinHm... Hast du by-reference-Parameter
  57. kevinDann wäre es vermutlich geschickt, with in ein explizites vorher/nachher aufzuteilen
  58. masterq32hm?
  59. masterq32ah jetzt
  60. masterq32WITH INITIAL x > 0
  61. masterq32WITH FINAL x < 0
  62. masterq32BEGIN
  63. masterq32x = -x;
  64. masterq32END
  65. kevinZum Beispiel
  66. masterq32hmm
  67. masterq32muss ich mir noch überlegen, ob ich by-ref supporte
  68. kevinKein by-ref hieße auch keine Pointer
  69. masterq32yep
  70. kevinAuch nicht auf Objekte
  71. masterq32bin grade eh noch am überlegen, wie ich das speichermanagement mache
  72. masterq32hast du mal C# programmiert?
  73. kevinHm, nicht wirklich
  74. masterq32java? :D
  75. kevinC# nur genug, um ein paar Bugs im Compiler zu reporten. *g*
  76. masterq32lolwut? :D
  77. kevinWobei ich da eigentlich nur versucht habe, von anderen geschriebenen Studienprojektcode auf Mono zum laufen zu bringen
  78. kevinDie Bugs waren schön verteilt, ein paar in Mono, ein paar bei Microsoft
  79. masterq32ouha, krass :D
  80. kevinHat aber gezeigt, wie angenehm es ist, wenn die Sprache eine Spec hat *g*
  81. masterq32ja :D
  82. kevinUnd zu deiner Frage - Java, wegen Studium halt, aber ja, kenne ich einigermaßen
  83. masterq32okay
  84. masterq32dann kennst du ja das typische objekt-referenz-verhalten
  85. kevinJo
  86. masterq32C# hat zudem noch "struct" als gegenstück zu "class"
  87. masterq32struct wird immer kopiert, nie referenziert
  88. kevinDas ist ja lustig^Wkaputt
  89. kevinGibt es dann noch ein Gegenstück zu int, dass immer referenziert statt kopiert wird? ;-)
  90. masterq32ja
  91. masterq32int? value;
  92. masterq32bzw. ne
  93. masterq32nicht ganz
  94. kevinOh, hm. int? hätte ich intuitiv als nullable gelesen...
  95. masterq32ja
  96. masterq32stimmt auch
  97. masterq32ne, C# kennt kein Integer :D
  98. masterq32müsste man selber machen
  99. masterq32außer man bezieht sich auf parameter, dann hat man ja out und ref
  100. kevinAh
  101. masterq32ja
  102. masterq32out garantiert eine zuweisung an einen wert:
  103. masterq32int i; someFunc(out i); // i hat jetzt einen wert
  104. kevinUnd wieso gibt es dann struct, wenn ref zusammen mit class dasselbe tun sollte?
  105. kevinHalt, andersrum
  106. masterq32weil sowas:
  107. masterq32Vector2 a, b;
  108. masterq32a = new Vector2(1,2); b = a; a.x = 3; // b.x==1
  109. kevinHmm...
  110. masterq32bei class hast du am ende b.x == 3
  111. kevinJo
  112. masterq32ich fände es irgendwie geil, wenn man das ganze konzept noch weiter treiben könnte
  113. masterq32also sowas wie:
  114. kevinEgal, zurück zu deiner Sprache - meinst du wirklich, du kommst damit aus, dass Funktionen keine Objekte modifizieren können?
  115. kevinKommst du dann nicht bei was funktionalem raus?
  116. masterq32ja, ziemlich
  117. masterq32also nein, ich komme wahrscheinlich nicht damit aus
  118. masterq32darum mach ich mir ja grade gedanken
  119. masterq32was halt geil wäre:
  120. masterq32das verhalten von C# mit struct und class nicht pro typ sondern pro variable
  121. masterq32VARIABLE x IS REF Struct;
  122. masterq32VARIABLE x IS Struct;
  123. kevinDu willst explizite Pointerderefenzierung, glaube ich ;-)
  124. masterq32hm, warum soll ich das nicht implizit können? ;)
  125. kevinHm, anders
  126. kevinDu willst, dass du für einen Pointer sagen kannst, ob der Default dereferenzieren oder direkt den Pointer ansprechen ist
  127. kevinTrifft es das?
  128. kevinUnd dann zwei Schlüsselwörter, die das jeweils andere Verhalten lokal bei einem Zugriff erzeugen
  129. masterq32jain
  130. kevinHm... Oder VARIABLE x IS Struct AT ptr; und VARIABLE ptr IS REF ptr; oder so?
  131. masterq32hm, das versteh ich jetzt nicht :D
  132. kevinDas letzte ich auch Quatsch, muss REF x sein
  133. kevin*ist
  134. kevinKeine Ahnung, ich dachte halt, eine Variable, für die ich zwar eienn Pointer habe, die aber kopiert wird, ist wie eine normale lokale Variable. Also könnte man sie auch so deklarieren und nur dazusagen, wo sie liegt.
  135. kevinWenn ich auf den Pointer zugreife, kopiere ich die Referenz, wenn ich auf die "lokale" Variable, die durch den Pointer initialisiert ist, zugreife, ändere ich den Inhalt
  136. masterq32http://pastebin.com/jTSEYvzv
  137. masterq32das hier war umgefähr mein gedanke
  138. kevinJetzt hast du den int natürlich schön in eine struct verpackt
  139. kevinLass ihn mal draußen
  140. masterq32okay :D
  141. kevinWas bedeutet r0 = d0 dann? Wert oder Referenz?
  142. masterq32referenz
  143. kevinUnd wie mache ich Wert?
  144. masterq32genau das frage ich mich grade auch noch :D
  145. kevinDeswegen würde ich explizit r0 = @d0 oder so machen
  146. masterq32für referenz oder kopie? :D
  147. kevinOder &d0 wenn du C lieber magst
  148. masterq32ah :D
  149. masterq32finde das @ hier sympathischer
  150. masterq32r0 = @d0; # r0 is at d0
  151. masterq32macht ja irgendwie sinn beim lesen
  152. kevinJo, fand ich auch immer logischer (@ ist Pascal, falls dir das nicht bewusst ist)
  153. masterq32ah :D
  154. kevinUnd andersrum vielleicht sogar *r0 = d0 (oder r0^, wenn wir bei Pascal bleiben, aber das macht meiner Meinung auch nicht mehr Sinn ;-))
  155. kevinUnd r0 = d0 ist halt ein Typfehler
  156. masterq32ich finde referenzsemantik (r0 = @d0) besser als pointersemantik (r0^= d0)
  157. masterq32zudem würde ich gerne doppelte indirektion vermeiden
  158. masterq32also referenzen auf referenzen
  159. masterq32wenn man sowas zwingend notwendig hat, sollte man das in eine structure kapseln
  160. kevinWenn r0 = d0 ein Fehler sein sollte (was ich stark befürworten würde, weil sonst wird es fehleranfällig mit vergessenem @), brauchst du irgendwie sowas wie r0^, um auf den Wert zuzugreifen
  161. masterq32ja
  162. masterq32aber referenzen sollten sich imho verhalten wie normale variablen
  163. masterq32also ist r0 = d0; für mich einfach die sinnvolle zuweisung von d0 an den referenzierten wert in rß
  164. masterq32*r0
  165. kevinHm, okay.
  166. kevinDann musst du aber @r0 = @d0 machen, damit es Sinn ergibt
  167. masterq32hmm
  168. masterq32ja, muss ich mal gucken
  169. masterq32ist aber definitiv ein guter vorschlag
  170. kevinGibt es dann überhaupt noch einen Unterschied zwischen Referenzen und "normalen" Variablen, außer dass letztere halt automatisch Speicher zugewiesen bekommen?
  171. kevinOder anders gesagt, spräche etwas dagegen, bei einer normalen lokalen Variablen @x = ... zu machen?
  172. masterq32hm
  173. masterq32hmmm
  174. masterq32hmmmmmmmmmmmmmmmmmmmmmmmmmmmmm
  175. kevin*g*
  176. masterq32also einfach alles immer als referenzsemantik? :D
  177. kevinJo, warum nicht?
  178. masterq32nur einmal mit versteckter allokation
  179. kevinWäre schön einheitlich
  180. masterq32ja, durchaus
  181. kevinFalls der erste Zugriff ist, bevor eine Adresse zugewiesen ist, macht der Compiler eine Stackallokation, sonst halt nicht
  182. masterq32jou
  183. masterq32damit brauch ich aber auch nen GC.....
  184. masterq32gefühlt
  185. kevinHm?
  186. masterq32explizites speichermanagement steigt einem da glaube ich relativ schnell übern kopf
  187. kevinDu meinst, wenn man eine lokale Variable in eine globale Datenstruktur packt ist es doof?
  188. masterq32ja
  189. masterq32was ja durchaus passieren kann....
  190. kevinJo. Ich glaube, das ist der Trick bei Java, warum primitive Datentypen immer by value sind. ;-)
  191. masterq32jap^^
  192. masterq32aber ich denke da kann man nen workaround im design finden
  193. masterq32raise-to-heap wäre ne option
  194. kevinWenn dein Compiler mit Zusicherungen statisch umgehen kann, kriegt er bestimmt auch raus, ob irgendwas auf den Stack kann ;-)
  195. masterq32sollte, ja :D
  196. masterq32wait :D
  197. masterq32man bekommt ja eh mit, wann variablen irgendwo hin zugewiesen werden, von daher... :D
  198. kevinJo
  199. kevinHm, bei Funktionen fehlt noch was, um zu sagen, ob man by-value oder by-ref will
  200. masterq32FUNCTION fn(x IS INTEGER, y IS INTEGER);