Comments by "p11" (@porky1118) on "ThePrimeTime" channel.

  1. 122
  2. 33
  3. 29
  4. 25
  5. 20
  6. 16
  7. 15
  8. 12
  9. 9
  10. 8
  11. 8
  12. 7
  13. 6
  14. 6
  15. 5
  16. 5
  17. 5
  18. 5
  19. 5
  20. 4
  21. 4
  22. 4
  23. 4
  24. 4
  25. 3
  26. 3
  27. 3
  28. 3
  29. 3
  30. 3
  31. 3
  32. 3
  33. 3
  34. 3
  35. 3
  36. 3
  37. 3
  38. 3
  39. 3
  40. 3
  41. 2
  42. 2
  43. 2
  44. 2
  45. 2
  46. 2
  47. 2
  48. 2
  49. 2
  50. 2
  51. 2
  52. 2
  53. 2
  54. 2
  55. 2
  56. 2
  57. 2
  58. 2
  59. 2
  60. 2
  61. 2
  62. 2
  63. 2
  64. 2
  65. 2
  66. 2
  67. 2
  68. 2
  69. 2
  70. 2
  71. 2
  72. 2
  73. 2
  74. 2
  75. 2
  76. 1
  77. 2:45 Lisp was my first real programming language. I learned most of programming using Game Maker with its own programming language GML. And also RenPy. Around the same time, I was learning Java at school, but it was very basic. I also tried to program games using Java, but didn't get very far. After school I tried C++ with old OpenGL, but I didn't even know of the stl or libs in general yet. I was looking into a bunch of languges, and then got stuck with go for a little. I liked it very much at first, but the lack of generics quickly made me lose interest. And then I stumbled upon Common Lisp. It seemed so minimalistic, and I liked that. (I liked to think about minimalistic langugaes anyway, both programming and spoken languages) At first I didn't think, it was possible to prograam using this. I couldn't see if something was a function or a definition or whatever. So I bought a book, the Land of Lisp. It took me a while to get into it, but soon I thought, I'd never want to use a different language. I was using it almost exclusively for at least three years, except in university. Whenever I saw shortcomings, I thought they could be fixed using macros or something. I played around with a few other languages, often lisp inspired. What annoyed me most was that Lisp was so high level, and I couldn't trust the compiler to optimize stuff for me. I just want my stuff efficient by default. Nowadays I'm mostly using Rust, but there is a Language, which has the real Lisp experience how I would have liked it before. Scopes. It's basically Lisp, but with more powerful macros to make it more like C++ in some ways (for generic types). It has a Rust inspired borrow checker. The low level stuff is lower level than C (there's a distinction between local variables and values). Syntax is indentation based like python. And the general feel is a little like Lua (multiple value semantics).
    1
  78. 1
  79. 1
  80. 1
  81. 1
  82. 1
  83. 1
  84. 1
  85. 1
  86. 1
  87. 1
  88. 1
  89. 1
  90. 1
  91. 1
  92. 1
  93. 1
  94. 1
  95. 1
  96. 1
  97. 1
  98. 1
  99. 1
  100. 1
  101. 1
  102. 1
  103. 1
  104. 1
  105. 1
  106. 1
  107. 1
  108. 1
  109. 1
  110. 1
  111. 1
  112. 1
  113. 1
  114. 1
  115. 1
  116. 1
  117. 1
  118. 1
  119. 1
  120. 1
  121. 1
  122. 1
  123. 1
  124. 1
  125. 1
  126. 1
  127. 1
  128. 1
  129. 1
  130. 1
  131. 1
  132. 1
  133. 1
  134. 1
  135. 1
  136. 1
  137. 1
  138. 1
  139. 1
  140. 1
  141. 1
  142. 1
  143. 1
  144. 1
  145. 1
  146. 1
  147. 1
  148. 1
  149. 1
  150. 1
  151. 1
  152. 1
  153. 1
  154. 1
  155. 1
  156. 1
  157. 1
  158. 1
  159. 1
  160. 1
  161. 1
  162. 1
  163. 1
  164. 1
  165. 1
  166. 1
  167. 1
  168. 1
  169. 1
  170. 1
  171. 1
  172. 1
  173. 1
  174. 1
  175. 1
  176. 1
  177. 1
  178. 1
  179. 1
  180. 1
  181. 1
  182. 1
  183. 1
  184. 1
  185. 1
  186. 1
  187. 1
  188. 1
  189. 1
  190. 1
  191. 1
  192. 1
  193. 1
  194. 1
  195. 1
  196. 1
  197. 1
  198. 1
  199. 1
  200. 1
  201. 1
  202. 1
  203. 1
  204. 1
  205. 1
  206. 1
  207. 1
  208. 1
  209. 1
  210. 1
  211. 1
  212. 1
  213. 1
  214. 1
  215. 1
  216. 1
  217. 1
  218. 1
  219. 1
  220. 1
  221. 1
  222. 1
  223. 1
  224. 1
  225. 1
  226. 1
  227. 1
  228. 1
  229. 1
  230. 1
  231. 1
  232. 1:35 Yay, Lisp! I think he has a point there. Lisp was my first programming language, I really got into. It seemed so weird at first. Everything just looked the same, no matter if it was a function call, a macro call, control flow, type definitions or function definitions. But the different syntax is just an abstraction for humans. It's not necessary. Before I only used Java in school. And I did a bunch of programming in GML (Game Maker) to create many unfinished games. Then I started to get into C++ for Graphics Programming (with old OpenGL), and also tried a few others, one of them being Go. But I never really used a standard library. But when I got into Lisp, I really learned all of the language features, including the more obscure non-standardized ones like the CLOS MOP, and I also used a package manager for the first time (quicklisp). I used Common Lisp for around 3 years almost exclusively. Whenever I didn't like something about the language I thought, I could simply fix it by using macros, preventing me from really getting into other languages, especially if they weren't S-Expression based. Aferwards I had another phase, where I tried a bunch of PLs, most of them being inspired by Lisp, like Stanza, Dale, Scopes, and also started to get into Rust. I still think Scopes has potential to be the best programming language. It's basically Lisp, but using an indentattion based syntax, being more low level than C, having a borrow checker, havnig three kinds of macros, useful multiple value return semantics like Lua. Basically Common Lisp, but everything is better. I think, the best programming language is basically Rust, but with S-Expression based intermediate format. I think, the programming language should not be monolithic, but be devided into two layers: The semantic layer and the syntax layer. The semantic layer defines the core features, and it's defined in S-Expressions. It only is about thinks like if it's statically or dynamically typed (by default), if it's garbage collected, does it have classes, interfaces, etc, a borrow checker, etc. The syntax layer is just a syntax, which could work for different languages. It is just a different format for S-Expressions. So a C-like syntax, a python-like syntax, a node based visual language, a voice based programming language, etc. all map some format to the same S-Expression format. I hope, this will happen to Rust one day, too.
    1
  233. 1
  234. 1
  235. 1
  236. 1
  237. 1
  238. 1
  239. 1
  240. 1
  241. 1
  242. 1
  243. 1
  244. 1
  245. 1
  246. 1
  247. 1
  248. 1
  249. 1
  250. 1
  251. 1
  252. 1
  253. 1
  254. 1
  255. 1
  256. 1
  257. 1