| 00:06:12 | filwit | Araq: if you have a moment, check out my language goals: https://gist.github.com/PhilipWitte/5017538 |
| 00:06:25 | filwit | Araq: i would like to know your input on my design ideas |
| 00:06:37 | filwit | Araq: you know a lot, and I value your opinion |
| 00:07:15 | filwit | Araq: one of the ideas, is that there's only one, simple way to do things.. even templates and type deduction |
| 00:07:35 | filwit | Araq: meaning, there's no special or extra syntax required |
| 00:08:42 | filwit | Araq: eg, no need for 'proc foo[S, T](s: S, t: t)" just "proc foo(s, t)" for generic types, or "proc foo(s:int, t:text)" for specialization |
| 00:09:54 | filwit | Araq: anyways, if you have any comments or criticisms, i would like to know. If you're busy or don't care to take a look, i understand that as well. |
| 00:10:09 | Araq | sorry, I'm reading it now |
| 00:10:28 | filwit | Araq: i really just wanted to show you some of my thoughts on "the perfect language", to let you know where I'm coming from when we argue about this kind of thing |
| 00:10:46 | Araq | for a start get rid of 'uint' for age please |
| 00:11:06 | Araq | unsigned arithmetic is almost always absurd |
| 00:11:26 | Araq | you want some 'nat' instead or even '0..150' |
| 00:11:59 | filwit | yes, the 'uint' is debatable, and I've looked a Nimrod a lot as an influence here |
| 00:12:34 | filwit | i like the idea of "limited types" that is, 'int' - integer, 'dec' - decimal, 'num' - int or dec |
| 00:13:03 | filwit | so: func foo(i:int, n:num) can be used like: foo(0, 1) or foo(0, 0.2) |
| 00:13:25 | filwit | so 'uint' would just be a "limited" version of an 'int' |
| 00:13:32 | Araq | ah ok |
| 00:14:01 | Araq | how do you do this: |
| 00:14:17 | Araq | proc p[T](s: seq[T], x: T) |
| 00:14:46 | filwit | good question, idk |
| 00:14:48 | Araq | note that you can't have that type constraint in your syntax |
| 00:15:06 | Araq | you can do it ML-like though: |
| 00:15:26 | * | q66 quit (Remote host closed the connection) |
| 00:15:26 | Araq | func p(s: seq['a], x: 'a) |
| 00:15:31 | filwit | the syntax there is debatable, but i would imagine something like: func p(s:*[], x:type(s)) |
| 00:16:03 | Araq | but it's not type(s), it is basetype(s) |
| 00:16:08 | Araq | or something like that |
| 00:16:19 | filwit | yes, your ideas are good |
| 00:16:32 | Araq | ML does that better |
| 00:16:39 | filwit | ML? |
| 00:16:51 | filwit | meta-language? |
| 00:17:00 | filwit | meta-list? |
| 00:17:29 | Araq | anything that starts with a ' is an implicitly declared type variable |
| 00:17:46 | Araq | so you don't have those annoying [] |
| 00:17:53 | filwit | the main point, it to try and eliminate the special syntax as much as possible, and make general generic programming "feel" like dynamic programming |
| 00:18:36 | filwit | Araq: well, in my design, a "dynamic array" (sequence) is decared like: var i : int[] |
| 00:18:54 | Araq | but thats a special syntax :P |
| 00:19:15 | filwit | yes, actually i'm glad you brought that up |
| 00:19:21 | filwit | i was thinking about this |
| 00:19:29 | filwit | see, you have to have syntax like this: |
| 00:19:37 | filwit | somevar = x[2] |
| 00:19:58 | filwit | array syntax, but... you have all kinds of different containers |
| 00:20:09 | filwit | List, DynamicList, LinkedList, etc |
| 00:20:24 | filwit | so my idea, was to have something like a "list type" |
| 00:20:28 | filwit | var x = int[] |
| 00:20:33 | filwit | var x = int[4] |
| 00:20:38 | Araq | IEnumerable? ;-) |
| 00:20:40 | filwit | var x = int[Linked] |
| 00:21:03 | filwit | where 'Linked' is a user (stdlib) defined 'iteration' type |
| 00:21:30 | filwit | and presents a LinkedList access to a standard '[]' syntax |
| 00:21:35 | filwit | i'm not sure it would work though |
| 00:21:54 | filwit | sorry, what exactly do you mean by: IEnumerable ? |
| 00:22:08 | Araq | nah, forget it |
| 00:22:16 | filwit | oh, okay |
| 00:22:22 | Araq | I thought you were about to re-invent it :P |
| 00:22:28 | filwit | oh, i see |
| 00:22:51 | filwit | also, something to note |
| 00:23:06 | filwit | 'func's can be "global", but only seen by their internal modules |
| 00:23:22 | filwit | and you don't have to "import" anything |
| 00:23:35 | Araq | yeah I dislike that |
| 00:23:36 | filwit | you just use the type, based on it's name |
| 00:23:44 | filwit | why, exactly? |
| 00:24:01 | Araq | it makes much harder to figure out a module's dependencies |
| 00:24:08 | filwit | and do you mean you dislike no-global-funcs? or no-imports? |
| 00:24:20 | Araq | I dislike the no-imports |
| 00:24:35 | Araq | it encourages that everything simply imports everything |
| 00:24:49 | Araq | aka circular dependencies |
| 00:25:06 | filwit | that would be easily fixed with compiler options |
| 00:25:06 | Araq | C# code is full of them as OO actually encourages it |
| 00:25:16 | filwit | (to find dependencies that is) |
| 00:25:54 | filwit | and, since you're "compiling" all the files anyways, and there's no need for forward declaration, i don't see why it would be a problem |
| 00:26:17 | filwit | really, i wanted "type" to be the core way you access stuff |
| 00:26:31 | * | fowl quit (Read error: Connection reset by peer) |
| 00:26:31 | filwit | so if you see "Console.write" you know to look for the "Console" type |
| 00:27:01 | * | fowl joined #nimrod |
| 00:27:06 | filwit | but you don't have to embed that into a module, which some arbitrary name, and then remember which module the type "console" was in |
| 00:27:09 | filwit | just to use it |
| 00:27:18 | filwit | all you have to remember is 1 name in my system |
| 00:27:36 | filwit | instead of 2 as in.. every other language |
| 00:28:20 | filwit | anyways, thanks for your input |
| 00:28:26 | filwit | i appriciate you taking the time |
| 00:28:36 | filwit | appreciate |
| 00:29:13 | filwit | i'm glad you did though, so if we ever argue about something, you have a better idea of where I'm coming from. |
| 00:29:29 | * | fowl quit (Read error: Connection reset by peer) |
| 00:29:34 | Araq | func += (n) { x, y, z, w += n } # what does this do? |
| 00:29:43 | Araq | I mean the x, y, z |
| 00:30:02 | filwit | it's sugar for: x += n; y += n; etc... |
| 00:30:02 | * | fowl joined #nimrod |
| 00:30:22 | filwit | that part is debatable |
| 00:30:26 | Araq | ah I see |
| 00:30:36 | Araq | when you do it, it's "sugar" :P |
| 00:30:36 | filwit | but i have a lot of "sugar" ideas on how to simplify things |
| 00:31:00 | filwit | yes, lol |
| 00:31:07 | filwit | mine is restricted |
| 00:31:09 | Araq | when I do it, it's a hard to learn inconsistency :P |
| 00:31:25 | filwit | and it's logical, for instance you can do this: (andrew, philip).greet() |
| 00:32:27 | filwit | Araq: the problem is you don't define any rules at all on Nimrods expressivness (except in that you can't express OOP :P) |
| 00:33:00 | filwit | and so it's hard to remember where something came from, or what's available to specific types |
| 00:33:14 | filwit | the problem is complicated by forced UFCS |
| 00:33:22 | Araq | 1. you can express OOP easily in Nimrod |
| 00:33:29 | Araq | I told you multiple times |
| 00:34:01 | filwit | i've asked about that... var = Type.x # 'x' is global |
| 00:34:17 | Araq | 2. there are rules about the expressiveness |
| 00:34:35 | filwit | you'd have to make this: proc x(t:TypeDesc[Type]) = global_x |
| 00:34:48 | Araq | so? |
| 00:34:57 | Araq | that's "Not supporting OO" now? |
| 00:34:59 | filwit | you are now managing "global_x" |
| 00:35:21 | filwit | and just making a special wrapper, which each person who wants to code like that, needs to make |
| 00:35:49 | filwit | also, i didn't mean to say Nimrod has "no" rules to it's expressiveness |
| 00:35:51 | filwit | sorry |
| 00:36:04 | filwit | like I've said before, Nimrod, IMO, gets many many things right |
| 00:36:12 | filwit | especially compared to other languages |
| 00:36:36 | Araq | # funcs are found in declaration order |
| 00:36:38 | Araq | # so you can have multiple overload with the same type |
| 00:36:40 | Araq | # the first one will be tried first, but if it doesn't work |
| 00:36:42 | Araq | # then the compler move on to the next and tries that, until |
| 00:36:43 | Araq | # it matches one, or fails completely and throws a compiler error |
| 00:36:45 | Araq | that's awful |
| 00:36:54 | filwit | :) |
| 00:37:11 | filwit | how so exactly? |
| 00:37:22 | Araq | so forward declarations are bad and yet you use the order in overloading resolution? o.O |
| 00:37:36 | filwit | it's not the same problem at all |
| 00:37:56 | filwit | forward declaration is only bad because the compiler can't see something that the programmer obviously can |
| 00:38:06 | filwit | it's annoying to have to hold it's hand through it |
| 00:38:34 | filwit | my function resolution is about putting preferences on functions that have the same parameters |
| 00:39:56 | filwit | funcs can be overloaded with the same parameter, but you prefer them by declaring them above the others. |
| 00:40:29 | Araq | clay does something similar iirc |
| 00:40:39 | Araq | they want to remove the feature :P |
| 00:40:40 | filwit | i did not know that |
| 00:41:17 | filwit | yes, i understand it's might be confusing, but I also do the same thing with module resolution |
| 00:41:34 | Araq | in nimrod you can' |
| 00:41:39 | Araq | can't |
| 00:42:02 | filwit | can't what? |
| 00:42:41 | Araq | play with the order of module imports to change overloading resolution |
| 00:43:15 | filwit | well... the only reason it applies to mine, is because i don't have "imports" |
| 00:43:29 | filwit | you just use "types" which can be in any file |
| 00:44:04 | Araq | that's a maintainance nightmare ;-) |
| 00:44:26 | filwit | how so? |
| 00:44:40 | filwit | can you present a problem where it will get really out of hand? |
| 00:45:18 | Araq | you have no module system |
| 00:45:18 | filwit | i have thought about it, and i think there are easy solutions to everything |
| 00:45:35 | Araq | what you have here is an ever growing mess |
| 00:45:47 | Araq | where everything freely uses everything else |
| 00:45:57 | filwit | hmm, no more than C# or C++ where namespaces don't match files |
| 00:46:02 | Araq | and all you can do is whole program compilation |
| 00:46:22 | filwit | ahh, yes but i didn't tell you about 'isolation' |
| 00:46:33 | Araq | and yes |
| 00:46:34 | filwit | but still, normally that's not needed |
| 00:46:43 | Araq | it's a problem in C# and C++ too IMO |
| 00:46:52 | filwit | your Standard Lib shouldn't have conflicting names to begin with |
| 00:47:18 | filwit | actually, see i used to agree with you there (about namespaces vs modules) |
| 00:47:29 | filwit | but my brother convinced me |
| 00:48:07 | filwit | you can't tie code to specific files, because it becomes really hard to refactor your code |
| 00:48:22 | Araq | wait a sec ... |
| 00:48:36 | Araq | you design the language to require an IDE |
| 00:48:52 | filwit | no |
| 00:48:54 | Araq | and yet some things make refactoring hard? |
| 00:48:57 | filwit | but it would be ideal |
| 00:49:14 | filwit | good point |
| 00:49:42 | filwit | still, i don't see how that's a point in module's favor, since if you have an IDE, finding the type wont be hard either |
| 00:50:37 | filwit | the benefit of not having to import something, is that you don't have to remember the double category |
| 00:50:50 | filwit | you can just right-click "go to definition" |
| 00:50:53 | Araq | well I tried hard to make the language IDE agnostic |
| 00:51:11 | filwit | yes, like i said, my design doesn't require an idea |
| 00:51:21 | filwit | but you do need to know what files are being compiled |
| 00:51:21 | Araq | yes it does IMO |
| 00:51:55 | filwit | the devs have to be aware of what types are available, true, and that would be best illustrated through an IDE |
| 00:52:09 | filwit | but you could acheive the same thing with terminal commands |
| 00:52:12 | filwit | or a project file |
| 00:52:33 | filwit | plus, IDE's these days are kinda a must-have for big projects |
| 00:53:00 | filwit | so relying on one that is designed to fit isn't a big deal, so long as it's open-source/cross-platform |
| 00:53:46 | filwit | anyways... no other complaints? |
| 00:53:57 | filwit | is there anything you like about the design at all? |
| 00:54:43 | filwit | I use curly-braces syntax because it's why i prefer best, but mostly I have not much of a preference there |
| 00:55:02 | filwit | i don't really like how Nimrod requires spaces, cause it's hard to work with in GEdit |
| 00:55:21 | Araq | it's not |
| 00:55:25 | filwit | but that's not a problem with other text-editors/IDEs |
| 00:55:34 | Araq | I used gedit for it |
| 00:55:41 | Araq | before aporia was ready |
| 00:55:45 | filwit | yes, but you use double-spaces |
| 00:55:52 | filwit | so two spaces isn't hard to hit |
| 00:55:59 | filwit | just takes getting used too |
| 00:56:05 | filwit | but i like 4-spaces |
| 00:56:10 | Araq | o.o |
| 00:56:13 | filwit | easier to read, IMO |
| 00:56:19 | Araq | I press tab to indent |
| 00:56:32 | filwit | yes, but then deleting the tab? |
| 00:56:44 | Araq | shift+tab |
| 00:56:51 | Araq | to dedent |
| 00:57:08 | filwit | i meant a single tab |
| 00:57:16 | filwit | i was actually making that in Aporia |
| 00:57:29 | filwit | where it would delete the "tab size" number of blank spaces |
| 00:57:38 | filwit | if you just hit delete |
| 00:57:59 | filwit | so it felt like a regular tab system |
| 00:58:18 | Araq | ah that's what you mean |
| 00:59:35 | Araq | I don't mind your design too much |
| 00:59:46 | Araq | but I also find it boring ;-) |
| 00:59:54 | filwit | great! |
| 01:00:02 | filwit | i read that as "consistent" |
| 01:00:09 | filwit | meaning, "good for noobs" |
| 01:00:18 | filwit | meaning, "good for game-scripts" |
| 01:00:26 | filwit | which is the other design... |
| 01:00:36 | * | fowl quit (Ping timeout: 248 seconds) |
| 01:01:03 | filwit | it's designed to be interpreted, so it would be very useful for a game-engine doing real-time adjustments to code |
| 01:01:16 | filwit | anyways, again, thanks for the input |
| 01:01:26 | Araq | noobs shouldn't program ;-) |
| 01:01:40 | filwit | it's not just about noobs |
| 01:01:50 | filwit | it's about other understand peoples code faster |
| 01:02:29 | filwit | if there's less, consistent rules the language has, and things are organized right (OOP imo), then you can read others code and learn it faster |
| 01:02:42 | filwit | that's one thing that I liked about Nimrod |
| 01:02:50 | filwit | is that it had very simple rules, off the bat |
| 01:03:01 | filwit | you basically only see function calls |
| 01:03:17 | filwit | and you use them, mostly the same way, even if they're a template/macro |
| 01:03:38 | filwit | vs D/C++ where you have all this extra template syntax |
| 01:05:03 | filwit | my main gripe with Nimrod is that it's not OOP, and you have to go out of your way to make it work like that |
| 01:05:13 | filwit | and i really don't like "floating functions" these days |
| 01:05:45 | filwit | but anyways, we've talked about all that before |
| 01:05:58 | Araq | indeed |
| 01:09:16 | Araq | why are floating types better? |
| 01:09:21 | Araq | argh, no |
| 01:09:29 | Araq | I don't want to hear it again :P |
| 01:09:34 | filwit | hahaha |
| 01:10:21 | Araq | how do you declare a virtual func in your language? |
| 01:10:35 | filwit | i have mixed ideas on that |
| 01:11:07 | filwit | either the compiler determins it needs them to be virtual (like D), or you use: 'proc' |
| 01:11:13 | filwit | determines* |
| 01:11:35 | filwit | my idea is to use a lot of static analysis when i can |
| 01:11:46 | filwit | for instance, there would only be one 'type' |
| 01:11:52 | filwit | (no struct/class) |
| 01:12:34 | filwit | and the compiler says... "this type isn't derived, and isn't exported, so it can be [like a struct]" |
| 01:13:08 | filwit | an easy way to enforce that a type is a struct though, is like: type Vector : final |
| 01:14:09 | filwit | and then you just have documentation for semi-advanced programmers that explain why it's good practice to "lock-up" types (so other programmers cant change them, causing unoptimizations to happen) |
| 01:14:35 | filwit | also, it would ideally be instance specific (like Java) |
| 01:15:16 | filwit | where, even if the type had a hierarchy to it, if the compiler could determine that wasn't being used, it wouldn't need to include the memory padding, vtables, etc |
| 01:15:40 | * | fowl joined #nimrod |
| 01:16:34 | * | Anaphaxeton quit (Remote host closed the connection) |
| 01:18:33 | filwit | ps. my language isn't boring in the sense that it would have a completely unique memory model (var/ref/ptr system i told you about) and it doesn't use "classical" constructor syntax |
| 01:19:48 | Araq | why do you care about devirtualization in an interpreted language? |
| 01:20:02 | filwit | it's not interpreted |
| 01:20:13 | Araq | you said it would be |
| 01:20:16 | filwit | it would be as optimized a LLVM could get it to be |
| 01:20:19 | filwit | it would be both |
| 01:20:41 | filwit | the compiler is designed to say open, and accept modifications commands to the semantics |
| 01:20:48 | filwit | so you can make changes on the fly |
| 01:20:52 | filwit | and then just run it |
| 01:21:08 | filwit | but you can build it too, all the way to native (or to IL for JIT if you want) |
| 01:21:39 | filwit | effeciency is my primary concern at the end of the day |
| 01:21:48 | filwit | efficiency* |
| 01:23:32 | filwit | right now, I have a interpreter (no parser yet), which can run int math |
| 01:23:36 | filwit | that's all |
| 01:25:00 | fowl | filwit: did you try proc foo(s, t) = echo(s, t) in nimrod |
| 01:25:25 | filwit | fowl: yes Araq told me that was added in! |
| 01:25:27 | filwit | very cool |
| 01:25:51 | filwit | when i was first around, that wasn't made yet, and I was excited Araq was thinking about adding it in |
| 01:26:20 | Araq | filwit: you should also check out the new first class iterators |
| 01:26:55 | filwit | link? |
| 01:27:16 | filwit | i'll find it |
| 01:27:17 | filwit | one sec |
| 01:27:22 | fowl | Araq: how long until i can do var fib = iterator{.closure} = ... |
| 01:27:48 | Araq | fowl: do you already need it? :-) |
| 01:28:59 | fowl | no but being able to do that and return iterators could be useful, i was thinking about using it in a dsl for game state handling |
| 01:29:59 | Araq | you can return them already |
| 01:30:08 | Araq | it's just that anon iterators don't exist |
| 01:30:21 | Araq | and yeah I had game state handling in mind for them too |
| 01:31:20 | filwit | so what is this first-class iterators? |
| 01:31:26 | filwit | i can't find it in the docs |
| 01:31:35 | filwit | i always new iterators in Nimrod where cool |
| 01:31:44 | filwit | but did something change with them? |
| 01:31:51 | fowl | filwit: http://build.nimrod-code.org/docs/manual.html#closure-iterator_362287364 |
| 01:32:22 | Araq | you can do the usual IEnumerable stuff with them now |
| 01:32:39 | Araq | and you can use them for async IO |
| 01:32:46 | fowl | cool |
| 01:32:54 | filwit | ahh, interesting |
| 01:32:57 | Araq | once the stdlib is patched to support it |
| 01:34:36 | fowl | i did an sdl skeleton with it https://gist.github.com/fowlmouth/4970500 |
| 01:34:46 | fowl | iterators* |
| 01:38:31 | Araq | filwit: you need a syntax that says if the 'this' object is passed by var/ref/ptr |
| 01:39:23 | filwit | func foo(x:ref int) |
| 01:39:30 | filwit | defaults to var |
| 01:39:36 | dom96 | hrm, the sockets gods are not cooperating with me tonight |
| 01:39:41 | filwit | which doesn't equate to "value" |
| 01:39:54 | filwit | it just means it can't be modified or set to null |
| 01:40:20 | filwit | well.. vars can be modified, just no params (by default) |
| 01:40:35 | filwit | obviously... |
| 01:41:13 | fowl | what wrong with null ref/ptr? |
| 01:41:42 | filwit | i have three types.. var, ref, & ptr |
| 01:41:46 | filwit | var can't be null |
| 01:42:17 | fowl | what if its a var ptr |
| 01:42:23 | filwit | (technically you can force it to be, in unsafe code or with ptrs) |
| 01:42:40 | filwit | a 'var ptr' doesn't make any sense in my language |
| 01:42:49 | filwit | you declare things like this: |
| 01:42:55 | filwit | def x = 10 # constant |
| 01:43:01 | filwit | var x = 10 # owner |
| 01:43:20 | filwit | ref x : int # non-owner |
| 01:43:31 | filwit | ptr x = 10 # unsafe pointer |
| 01:44:25 | fowl | whats the use of declaring things as a pointer to a raw memory address |
| 01:44:55 | filwit | they aren't managed |
| 01:45:11 | filwit | there's no bookkeeping going on at all |
| 01:45:16 | filwit | ptr can point to valid memory |
| 01:45:29 | fowl | is that to a private stack or something |
| 01:45:33 | fowl | heap |
| 01:45:51 | filwit | my memory modal, as I've explained to Araq, is unique |
| 01:46:05 | filwit | it doesn't use a GC, but is "safe" |
| 01:46:06 | fowl | i only see that being useful if you have a full vm for it |
| 01:46:16 | filwit | no VM or GC |
| 01:46:26 | filwit | you have a heap and a stack |
| 01:47:04 | filwit | and vars are allocated at definition. refs are always weak |
| 01:47:17 | filwit | vars get cleaned up at the end of their scope |
| 01:47:34 | filwit | or when theyre containing type gets deleted |
| 01:47:42 | filwit | refs are set to null at that point |
| 01:47:54 | filwit | (the refs that where pointing to them) |
| 01:48:30 | filwit | so it's a type of "GC"... just not a usually kind |
| 01:48:38 | filwit | cause there are different restrictions |
| 01:49:04 | filwit | https://gist.github.com/PhilipWitte/4962210 |
| 01:49:28 | filwit | (there is more too it than that, but that's the general idea) |
| 01:50:01 | Araq | well good night everyone |
| 01:50:08 | filwit | night! |
| 01:50:24 | fowl | i find the difference in `ref x : type` and `var x = type` unsettling >_> |
| 01:50:49 | filwit | :) you get used to it pretty quick |
| 01:50:58 | filwit | and honestly, i really like it afterwards |
| 01:51:13 | filwit | you can clearly see what the intent of a variable is |
| 01:51:17 | fowl | the syntax reminds me of c++tranny |
| 01:51:28 | filwit | never heard of it... |
| 01:51:30 | fowl | https://github.com/fowlmouth/cpptranny |
| 01:52:01 | filwit | gross.. my syntax does not look like that |
| 01:52:14 | filwit | :P |
| 01:52:33 | filwit | here's more examples of my design: https://gist.github.com/PhilipWitte/5017538 |
| 01:52:53 | fowl | the type decls, func decls, var decls do, for the most part |
| 01:53:05 | filwit | wait... i think i'm reading that wrong |
| 01:53:06 | fowl | if you were trying to wrap c++ 1:1 thats what your language would look like :p |
| 01:53:23 | filwit | i was reading their normal C++ examples |
| 01:53:37 | filwit | yes, that's interesting |
| 01:54:03 | filwit | still... there is more to my language than just the memory model, but yeah, thanks for the heads up on that |
| 01:54:16 | filwit | i always knew i wasn't the first to think of the memory model |
| 01:54:29 | filwit | i just never knew of anything else that made use of it |
| 01:54:36 | filwit | maybe C++tranny does |
| 01:54:48 | fowl | no, c++tranny is an alternate syntax for c++, nothing more |
| 01:56:10 | fowl | its the same information you need in C++ code, with readability |
| 01:56:20 | filwit | i see |
| 01:56:33 | filwit | yeah, i don't like how complicated it looks |
| 01:56:58 | filwit | basically just C++ with, but with a Javascript twist |
| 01:57:05 | filwit | or... something like that |
| 01:57:26 | fowl | id say it looks more like actionscript than anything else |
| 01:57:32 | filwit | true |
| 01:59:54 | dom96 | good night |
| 02:00:04 | filwit | night, dom96! |
| 02:00:09 | fowl | night |
| 02:00:16 | filwit | i'm taking off too |
| 02:00:20 | filwit | bye, fowl |
| 02:00:24 | fowl | cya |
| 02:00:36 | * | filwit quit (Quit: Leaving) |
| 07:28:32 | * | gour joined #nimrod |
| 08:02:57 | * | FreeArtMan joined #nimrod |
| 09:08:33 | * | gour quit (Disconnected by services) |
| 09:08:33 | * | gour_ joined #nimrod |
| 09:10:57 | * | Anaphaxeton joined #nimrod |
| 09:25:40 | * | fowl quit (Ping timeout: 248 seconds) |
| 11:07:09 | * | gour_ is now known as gour |
| 11:08:12 | gour | Araq: what do you thin kabout EFL? btw, i see you rm-ed 'install' for Claro, so it's not possible to build examples |
| 11:26:21 | * | fowl joined #nimrod |
| 11:30:42 | Araq | gour: "install" has never been implemented |
| 11:31:01 | Araq | so I removed the line that says it can be done |
| 11:32:09 | fowl | Araq: can json's existkey be renamed or inlined to `haskey` |
| 11:32:25 | fowl | existskey* |
| 11:32:54 | fowl | haskey is used for ttable[] |
| 11:33:07 | Araq | fowl: do it, deprecate "existsKey" and make a pull request |
| 11:33:34 | fowl | cool ty |
| 11:34:29 | dom96 | Make sure to write "**Deprecated since version 0.9.2**: reason" in the docs for 'existsKey'. |
| 11:34:43 | gour | Araq: ok |
| 11:35:03 | gour | what do you think about https://sourceforge.net/create/ as place for Nimrod? |
| 11:35:30 | NimBot | nimrod-code/Aporia 02796b4 Dominik Picheta [+0 ±4 -0]: Compile & Run using paths with a space now works properly.... 2 more lines |
| 11:35:38 | dom96 | My first thought is "bleh". |
| 11:36:12 | gour | e.g. "We start with a wiki, but you can install and use any tools that you want in your project web space." |
| 11:36:38 | gour | Araq: so, install has to be done by hand in order to build examples? |
| 11:40:32 | gour | here is reddit post - http://www.reddit.com/r/programming/comments/191vib/the_next_sourceforge/ |
| 11:41:56 | Araq | gour: yes |
| 11:42:15 | Araq | it amounts to "sudo cp libclaro.so /urs/lib" |
| 11:42:23 | Araq | or something like that |
| 11:42:30 | Araq | but we'll change it anyway |
| 11:42:39 | Araq | and embed it in the claro.nim |
| 11:43:00 | fowl | <- hates sourceforge |
| 11:43:11 | fowl | i find it hard to navigate |
| 11:43:12 | Araq | so sourceforge tries to compete with github finally |
| 11:43:24 | dom96 | Most people do hate it. |
| 11:43:36 | Araq | unfortunately it's still hard to navigate and browsing some repo is awefully slow |
| 11:43:36 | gour | "old one" :-) |
| 11:43:55 | gour | github is also not special, just sucks less, maybe |
| 11:44:30 | gour | they rm-ed download :-( |
| 11:44:36 | dom96 | what advantage would moving to sourceforge bring us? |
| 11:44:40 | Araq | "The killer feature of SourceForge is that for every user they create an Unix account and you can login via ssh." ... hm |
| 11:47:34 | dom96 | and do what exactly? |
| 11:47:51 | fowl | dom96: want to port sfml to nimrod with me? (= |
| 11:48:36 | dom96 | not sure I have the time. |
| 11:49:04 | Araq | gour: I have no opinion on EFL |
| 11:49:15 | fowl | oh:< |
| 11:49:16 | Araq | but since it's linux specific it's not very interesting |
| 11:49:27 | dom96 | fowl: I can help a little bit once in a while maybe. |
| 11:49:38 | dom96 | fowl: why do you want to port sfml to nimrod? |
| 11:50:28 | fowl | i like the api and its really easy to use and encourages imperative design |
| 11:51:01 | dom96 | ok, but why port it to Nimrod? why not just use the wrapper? |
| 11:52:06 | fowl | there is overhead in converting from c++ to c |
| 11:52:36 | fowl | and requiring ppl to have not just sfml but csfml installed is annoying |
| 11:59:23 | fowl | here's what i have so far https://gist.github.com/fowlmouth/5019522 |
| 11:59:25 | * | q66 joined #nimrod |
| 12:04:08 | * | Anaphaxet0n joined #nimrod |
| 12:04:23 | * | Anaphaxeton quit (Ping timeout: 255 seconds) |
| 12:04:41 | Araq | fowl: looks nice but you don't to copy the "ClassImpl" bullshit of C++ |
| 12:07:16 | fowl | Araq: i just wanted to keep the implementation code separated for each platform |
| 12:07:39 | Araq | oh alright |
| 12:07:45 | fowl | i dont ever want to have to look at window_win.nim (whenever someone interested does it, because fck the win api) |
| 12:08:21 | Araq | I never bother, I'd use a 'when' in the object ;-) |
| 12:13:08 | Araq | it's often only a "when defined(windows): winHandle: THandle" anyway |
| 12:15:21 | fowl | i dont want platform specific stuff in the main file if possible |
| 12:15:51 | fowl | plus TWindow will likely hold more data like an event queue |
| 12:16:51 | Araq | your way is fine too |
| 13:42:36 | gour | Araq: i believe EFL is supposed to run on mobile devices as well, although i'm not very interested for it...otoh, looking at some claro examples, it looks as one could call claro as something line wxlight |
| 13:52:39 | fowl | i want an ubuntu phone |
| 13:52:58 | dom96 | i want google glass |
| 13:53:12 | Araq | hm no iOS crap and no Java/Andriod crap? |
| 13:53:28 | Araq | indeed ... could be an idea |
| 13:53:35 | fowl | im not ready for glass yet |
| 13:53:47 | Araq | but I thought ubuntu phone only runs a firefox? |
| 13:53:49 | fowl | i'll get one when its required by the government |
| 13:54:08 | dom96 | Araq: You're thinking of MozillaOS or whatever it's called |
| 13:54:19 | Araq | dom96: yeah ... |
| 13:54:41 | fowl | ubuntu phone uses QML (some web-like stuff?) or c api |
| 13:54:44 | fowl | afaik |
| 14:00:47 | dom96 | I bet ubuntu phones will be quite expensive, judging from the OS' system requirements. |
| 14:09:24 | gour | "Reply to forum posts by email" is nice feature on new SF |
| 14:45:48 | dom96 | I can't get timeouts to work with httpclient and ssl for some reason :\ |
| 14:57:06 | Araq | so ... gour ... do the claro examples work for ya? |
| 15:03:01 | fowl | check out this beautiful gui http://sfgui.sfml-dev.de/p/ |
| 15:04:05 | dom96 | Reminds me of Counter Strike's GUI |
| 15:04:16 | gour | Araq: nope...i had problems with includes and then got some linker error... |
| 15:04:22 | Araq | it's ugly |
| 15:04:28 | dom96 | "Load properties from CSS-like themes during runtime." |
| 15:04:49 | fowl | ^ |
| 15:05:03 | fowl | i had some prototype loading of gui elements from json but it sucks |
| 15:05:13 | fowl | im gonna rewrite it |
| 15:05:22 | fowl | one day, LOL |
| 15:05:39 | dom96 | A Nimrod DSL for creating quick GUIs would be nice |
| 15:07:52 | gour | ported Claro to Nimrod looks as best long-term option for GUI...the lib is capable can be extended and not bloated and it would be native |
| 15:11:06 | Araq | yeah |
| 15:11:37 | Araq | do it ;-) |
| 15:13:01 | gour | first i've to build some examples and become a bit familiar with it |
| 15:13:26 | gour | i also wonder about the mechanism how to extend it with newer widgets |
| 15:13:38 | gour | here i do not consider custom ones |
| 15:18:03 | fowl | if you port it you can use dynamic dispatch |
| 15:28:09 | gour | my porting is far away...in the meantime it would be nice to settle on that lib (it seems i should better listen Araq's advices to save time) and try to bind it to Nimrod 1st |
| 15:28:46 | gour | hopefully, other nimrod users can come to the same conclusion so we can join forces :-) |
| 15:29:45 | fowl | c2nim should do most of the work for you |
| 15:29:53 | * | gour nods |
| 15:30:15 | fowl | you'll need #def CLFEXP |
| 15:30:41 | * | reactormonk quit (Ping timeout: 248 seconds) |
| 15:32:18 | gour | fowl: i have to re-learn more about that C0s |
| 15:32:33 | gour | C's macros having problems with binding required lib |
| 15:32:42 | gour | it was long ago when i fiddled with it |
| 15:33:18 | gour | for now, i converted few of my personal repos from fossil to git to brush a bit my rusty git skills |
| 15:39:55 | Araq | gour: we already have a claro.nim wrapper |
| 15:40:10 | Araq | no need for c2nim |
| 15:40:51 | Araq | but the wrapper should add {.compile: "fileA.c":} etc. so it's not dependent on a DLL/lib*so |
| 15:41:10 | Araq | (I use the term "DLL" for both most of the time btw) |
| 15:41:39 | Araq | (as IMO unix couldn't name a single thing right :P ) |
| 15:42:05 | gour | ohh, that's nice |
| 15:43:05 | gour | that would be very clean setup |
| 15:43:35 | Araq | gour: you should really learn to listen to me :P |
| 15:43:55 | gour | indeed |
| 15:44:25 | gour | Araq: i wonder who are some of your better disciples to learn the arte from 'em |
| 15:44:30 | gour | *art |
| 16:14:11 | dom96 | yay, it works! |
| 16:14:52 | Araq | dom96: what was the bug? |
| 16:15:16 | dom96 | Araq: OpenSSL has an internal buffer. |
| 16:15:49 | dom96 | I was using select to check whether the socket can be read from, but OpenSSL already buffered everything. |
| 16:33:21 | fowl | i havent had to deal with openssl yet, glad because it sounds like its all headaches |
| 16:34:37 | dom96 | yeah, it is. Hopefully with my nice implementation you won't have to worry about it though. |
| 16:37:32 | * | Anaphaxet0n quit (Ping timeout: 255 seconds) |
| 16:38:06 | * | Anaphaxeton joined #nimrod |
| 16:42:27 | fowl | :) |
| 16:52:47 | Anaphaxeton | hi hi |
| 16:53:05 | dom96 | hey Anaphaxeton |
| 17:07:30 | * | xcombelle joined #nimrod |
| 17:08:19 | dom96 | hello xcombelle |
| 17:08:33 | xcombelle | hi dom96 |
| 17:10:33 | dom96 | New to Nimrod? |
| 17:10:39 | xcombelle | yes |
| 17:11:17 | dom96 | awesome. Let us know if you have any questions. |
| 17:13:35 | xcombelle | I'm coming from a python background |
| 17:14:38 | dom96 | back in the day I came from a python background too. |
| 17:25:20 | Araq | welcome xcombelle |
| 17:28:17 | dom96 | hrm, i'm starting to think that implementing proper timeouts for httpclient is too complex, and people should just use a thread or something. |
| 17:28:19 | dom96 | Opinions? |
| 17:29:07 | Araq | timeouts are essential for httpclient |
| 17:29:16 | Araq | you can't really use it otherwise |
| 17:29:34 | Araq | so no to threads for it |
| 17:32:12 | Araq | why is it too hard to implement? |
| 17:32:46 | dom96 | It's not hard, it's very bloaty though. |
| 17:32:58 | Araq | why? |
| 17:33:01 | dom96 | I have to keep track of how long each recv/recvLine/connect call takes |
| 17:33:13 | Araq | nah |
| 17:33:46 | Araq | you should pass timeout to recv/recvLine/connect |
| 17:34:07 | Araq | and document this behaviour instead ;-) |
| 17:34:37 | dom96 | Perhaps that would be good enough. |
| 17:34:42 | Araq | think about it ... there is progress after all |
| 17:34:48 | dom96 | It would be nice to have a guarantee that it won't take longer than timeout |
| 17:34:50 | Araq | so you shouldn't timeout |
| 17:35:08 | Araq | nah |
| 17:35:24 | Araq | the timeout exists so you'll get an error after some time |
| 17:35:36 | Araq | it's not some realtime thing |
| 17:35:50 | Araq | one should indeed use a thread for that then |
| 17:37:13 | dom96 | alright |
| 17:37:22 | dom96 | In that case it's simple :P |
| 18:03:49 | fowl | i wish there were more ODE tutorials around |
| 18:06:59 | fowl | also that i took physics and knew terminology |
| 18:07:01 | fowl | that would help |
| 18:09:18 | Araq | you should write a "nimrod for python programmers" tutorial |
| 18:09:24 | Araq | that would help too :-) |
| 18:19:28 | fowl | i've been planning on writing something about templates and macros |
| 18:21:06 | Araq | alright |
| 18:26:21 | fowl | Araq: cool i just tried ptr(A)|ref(A) is there an overarching ptr type that matches those and the hidden ref types (string, seq)? |
| 18:29:25 | Araq | er ... what? |
| 18:35:35 | fowl | anything that could be nil? |
| 18:46:30 | * | sdw joined #nimrod |
| 18:48:07 | Araq | fowl: when compiles(x.isNil) ? |
| 18:48:13 | Araq | hi sdw |
| 18:48:20 | sdw | hey :) |
| 18:48:48 | Araq | your nick looks familiar, ever been here before? |
| 18:48:53 | sdw | yup |
| 18:49:11 | sdw | maybe a year or two ago |
| 18:49:19 | sdw | you've got quite a following now |
| 18:50:08 | Araq | do I? :-) |
| 18:50:48 | sdw | are these just the usual freenode observers? |
| 18:51:15 | fowl | Araq: oh nice |
| 18:51:32 | dom96 | sdw: some are absent, but mostly this is us. :) |
| 18:52:11 | sdw | alright. does nimrod have a cozy visual studio development envrionment yet? |
| 18:52:38 | dom96 | A plugin for Visual Studio: no. An awesome IDE written in Nimrod: yes :P |
| 18:52:49 | Araq | I don't think so ... the debugger works nicely with VS though |
| 18:52:55 | Araq | at least that's what I've been told |
| 18:53:44 | Araq | er I mean VS's debugger works nicely with code generated by Nimrod |
| 18:54:00 | sdw | meh, ill just install the damn thing and see for myself |
| 19:13:52 | sdw | ha! i always see game development as an area where these "weird" languages are used https://github.com/Araq/Nimrod/wiki/Community-Projects |
| 19:15:50 | Araq | sdw: yeah well it's always been designed for game development |
| 19:16:17 | Araq | nah ... I'm not serious |
| 19:16:41 | Araq | something happened to the idea of "general purpose language" though |
| 19:16:45 | sdw | i am also looking to make a game with it |
| 19:17:16 | sdw | but mostly just playing around |
| 19:19:06 | Araq | we have a realtime GC :-) |
| 19:19:42 | sdw | aporia isn't building |
| 19:19:53 | Araq | I know |
| 19:19:58 | sdw | oh |
| 19:20:07 | sdw | version 0.9.0 of compiler |
| 19:20:20 | Araq | nobody uses 0.9.0 anyway |
| 19:20:31 | Araq | people use the github version |
| 19:20:31 | fowl | can we use this to query alignment for sdl_event ? http://gcc.gnu.org/onlinedocs/gcc/Alignment.html |
| 19:21:20 | Araq | fowl: you're better off asking for the field's offset instead |
| 19:22:25 | Araq | sdw: problem is: aporia doesn't build with the github version either :-/ |
| 19:22:56 | sdw | but the latest github is still recommended? |
| 19:23:07 | sdw | oh the nimrod compiler* |
| 19:23:09 | sdw | of* |
| 19:23:19 | Araq | in general yeah |
| 19:23:22 | dom96 | Araq: It does for me. |
| 19:23:24 | fowl | do you think offsetof() would help libffi? |
| 19:23:50 | Araq | fowl: yes but there is no way to access it |
| 19:24:11 | Araq | except generating a small C program on the fly ... |
| 19:24:39 | Araq | dom96: alright my version of aporia is too old then I guess |
| 19:24:50 | fowl | thats doable, it could be ran once a release and cache the info |
| 19:25:29 | Araq | that's more work than fixing the offset calculations in the compiler though |
| 19:26:11 | fowl | i think having kind* {.size: 1.}: TEventType should be enough |
| 19:26:24 | Araq | been there done that |
| 19:26:26 | fowl | 1 or sizeof(char) |
| 19:26:39 | Araq | SDL's event struct is a PITA |
| 19:26:55 | Araq | the nested union in the struct etc. |
| 19:27:01 | Araq | I never got it right |
| 19:27:19 | Araq | and the compiler already uses 1 byte for 'kind' anyway |
| 19:27:42 | fowl | yeah |
| 19:27:44 | * | reactormonk joined #nimrod |
| 19:28:35 | fowl | it would be neat to be able to switch easily between static and dynamic linking |
| 19:32:55 | fowl | isnt there some tool to query this stuff from a dynlib |
| 19:33:19 | Araq | what do you want to query? offsets? no way |
| 19:34:46 | fowl | ah |
| 19:38:22 | fowl | what makes it aligned anyways i dont see any attribute or macros used in the header |
| 19:39:11 | Araq | it's the combination of structs and unions |
| 19:39:39 | Araq | and things are aligned without any pragmas anyway in C |
| 19:40:04 | * | shevy quit (Ping timeout: 248 seconds) |
| 19:40:57 | sdw | that crown icon is pretty sweet |
| 19:41:26 | Araq | thanks |
| 19:41:33 | Araq | we got a new website design too |
| 19:41:54 | Araq | but it's not deployed yet |
| 19:52:59 | * | shevy joined #nimrod |
| 19:54:47 | sdw | PS C:\nimrod\Aporia> .\aporia.exe |
| 19:54:47 | sdw | could not import: PS C:\nimrod\Aporia> |
| 19:55:53 | Araq | watch out with the > |
| 19:56:07 | Araq | it redirects stuff into the .exe |
| 19:56:16 | fowl | thats powershell prompt |
| 19:56:24 | fowl | PS dir> |
| 19:56:50 | fowl | (probably) |
| 19:56:54 | sdw | it is |
| 20:01:36 | sdw | notepad it is! |
| 20:08:04 | Araq | sdw: normally it says what couldn't be imported |
| 20:08:17 | sdw | normally :) |
| 20:13:02 | sdw | i recall at one point you were experimenting with a configuration setting that would change nimrod from python indent style to c-style braces |
| 20:13:07 | sdw | is that right? |
| 20:13:29 | Araq | yeah quite true |
| 20:13:45 | Araq | nothing came out of it :P |
| 20:14:01 | sdw | we dont want no stinking braces anyways |
| 20:14:04 | Araq | except the compiler quite easily supports different frontend syntaxes |
| 20:18:02 | sdw | tabulators not allowed!? |
| 20:18:09 | sdw | who turned those on anyways :P |
| 20:18:26 | sdw | what's the rationale there? easier implementation? |
| 20:18:32 | Araq | yeah |
| 20:18:51 | Araq | I can easily write a 60K compiler with 4-5 passes over the code |
| 20:19:05 | Araq | with lots of innovative features |
| 20:19:13 | Araq | but can't figure out how to parse a tab |
| 20:20:10 | reactormonk | somehow I have the feeling creating issues for zahary doesn't help as much :-( |
| 20:20:11 | fowl | thats why you should have went to school and learned to love java |
| 20:21:06 | Araq | guido himself said if he could do it again |
| 20:21:11 | Araq | he would forbid tabs |
| 20:21:24 | Araq | or at least forbid mixing tabs and spaces in the same file |
| 20:22:14 | Araq | reactormonk: zahary is quite busy these days |
| 20:22:38 | fowl | thats why you should have went to school and learned to love java |
| 20:22:41 | reactormonk | other hobbies? |
| 20:22:42 | fowl | er mb |
| 20:23:24 | Araq | I only know he got a new job |
| 20:23:31 | reactormonk | wtf /b/ - you switch forward two slides and see the exact same post O.o |
| 20:24:33 | fowl | is /b/ on slides now? o_o |
| 20:25:22 | Araq | what's /b/ ? |
| 20:26:11 | * | nolan2 joined #nimrod |
| 20:27:20 | sdw | Araq: principle? |
| 20:27:24 | sdw | I never heard the reason |
| 20:27:41 | Araq | mixing spaces and tabs is a recipe for desaster in python |
| 20:27:53 | Araq | it only works if your tabs are 8 spaces |
| 20:28:14 | Araq | and his reasons are that enough people struggled with it |
| 20:28:30 | Araq | so allowing fewer options helps |
| 20:28:39 | nolan2 | Is there a more sophisticated REPL for the console than "nimrod i"? (I.e. something that doesn't crash on coding errors. :) |
| 20:29:23 | Araq | I don't recall getting any bug report for that from you :P |
| 20:29:46 | nolan2 | Also, I think I've found a practical use for Nimrod for one of my projects. Is there any reason why I couldn't build a library in Nimrod, compile it for Android and access it via JNA? |
| 20:29:58 | fowl | nolan2: there's a gtk repl thats a bit better check out tools/nimrepl |
| 20:30:18 | Araq | nimrepl is better than "nimrod i"? no way ... |
| 20:30:32 | Araq | "nimrod i" keeps the session (if it doesn't crash) |
| 20:30:33 | fowl | why not? it compiles for you |
| 20:30:35 | nolan2 | Yeah, I've seen Nimrepl, was hoping for something on the console. I'll play with that more though. |
| 20:38:58 | Araq | nolan2: please give a simple example where crashing it |
| 20:40:19 | nolan2 | somemethodthatdoesnotexist "foo" |
| 20:40:34 | nolan2 | Granted, not valid syntax, but latest trunk just crashes for me. |
| 20:40:56 | Araq | that's a a new regression |
| 20:41:03 | Araq | it is valid syntax btw |
| 20:41:12 | nolan2 | It seems to handle other stuff better, so my generalization was a bit hasty. I apologize for that. |
| 20:41:23 | Araq | np |
| 20:41:40 | Araq | it is easy to fix |
| 20:41:47 | nolan2 | Yeah, I thought so. It's been a couple months since I've played with Nimrod so I need to work through the tutorial again. |
| 20:50:36 | * | xcombelle quit (Remote host closed the connection) |
| 20:51:19 | * | filwit joined #nimrod |
| 20:51:29 | filwit | hi peoples |
| 20:51:43 | filwit | dom96, you around? |
| 20:52:28 | filwit | was thinking about designing the Aporia logo, and wanted to talk about it with you |
| 20:53:09 | Araq | hi filwit, dom96 will arrive soon here |
| 20:55:07 | filwit | okay, thanks |
| 20:55:53 | filwit | Araq, ever think about a Nimrod mascot? |
| 20:56:12 | filwit | most languages don't really have a logo, just a mascot |
| 20:56:12 | Araq | the crown is not enough? |
| 20:56:29 | filwit | the crown is fine |
| 20:56:31 | Araq | I despise the "gother" if that's what you mean |
| 20:56:43 | filwit | gother? |
| 20:56:55 | filwit | Ohhh... |
| 20:56:59 | filwit | the Go mascot |
| 20:57:08 | filwit | yeah... he's kinda retarded looking |
| 20:57:20 | filwit | it was drawn by the wife of the core developer |
| 20:57:28 | Araq | fits the language though |
| 20:57:38 | filwit | lol, Go isn't that bad |
| 20:57:47 | filwit | but it's not great either... |
| 20:58:11 | filwit | i really don't know much about Go these days really |
| 20:58:20 | filwit | have you looked at Dart, btw? |
| 20:58:25 | filwit | (i'm sure you have) |
| 20:58:49 | filwit | it's a much better attempt at a language by Google, IMO |
| 20:59:09 | Araq | Dart has an unsound type system by intention |
| 20:59:21 | Araq | it's horrible |
| 20:59:38 | filwit | yeah, it's biggest flaw |
| 20:59:42 | fowl | dom96: can you do a closure iterator for downloading files :) |
| 20:59:47 | filwit | but it's much better than Javascript |
| 21:00:02 | Araq | that's not hard |
| 21:00:08 | filwit | very true |
| 21:00:14 | Araq | and I'm not sure it's true for Dart |
| 21:00:17 | filwit | Javascript is, by far, my least favorite language |
| 21:00:24 | filwit | (maybe PHP) |
| 21:00:36 | filwit | it's too bad i have to write in JS every day... |
| 21:00:59 | Araq | you can use Nimrod's JS backend instead |
| 21:01:00 | fowl | <- only writes in executable html these days |
| 21:01:18 | filwit | Araq... i may try that one day |
| 21:01:28 | filwit | fowl.. what? |
| 21:01:40 | filwit | you mean HTML desktop apps? |
| 21:01:53 | fowl | no, a joke, in the worst taste |
| 21:02:15 | filwit | oh (i still don't get it :/) |
| 21:02:32 | fowl | bad joke:/ |
| 21:02:38 | filwit | fowl: Linux or Windows? |
| 21:02:49 | filwit | and what distro if Linux? |
| 21:03:08 | filwit | (personal interest) |
| 21:03:12 | fowl | linux mint atm im going to switch soon not sure to what though |
| 21:03:25 | filwit | Mint Debian? |
| 21:03:29 | fowl | no |
| 21:03:54 | filwit | I use Arch, and recommend it (if you can get it to install) |
| 21:04:18 | filwit | you can't go wrong with rolling-release |
| 21:04:29 | fowl | yea i know about, i have mixed feelings about their bleeding-edge-ness |
| 21:04:35 | fowl | about arch* |
| 21:04:48 | filwit | I've never had problems |
| 21:05:04 | filwit | there was issues when they went from initscript to systemd |
| 21:05:12 | filwit | but the wiki explained everything well |
| 21:05:34 | filwit | what I like, is that I get the latest Gimp/Inkscape/Blender/etc as soon as it comes out |
| 21:05:35 | fowl | yea they make system breaking changes way too often |
| 21:05:49 | fowl | i do too :) |
| 21:05:59 | filwit | yeah but you need to get PPAs |
| 21:06:17 | filwit | and they really don't break the system that often |
| 21:06:19 | nolan2 | The tutorial recommends using "when false:" to comment out large bodies of code. Does this mean that everything I comment out has to be indented to be within the when block? |
| 21:06:35 | Araq | nolan2: yes. |
| 21:06:57 | Araq | you should get an editor that supports that |
| 21:06:58 | nolan2 | So how is that better than commenting? |
| 21:07:07 | filwit | nolan2: just do: when false: for debugging, then toggle it on with: when true: |
| 21:07:24 | filwit | nolan2: then just shit-tab it when you're done debugging |
| 21:07:34 | fowl | nolan2: the code is semantically checked |
| 21:07:38 | filwit | nolan2: shift-tab** |
| 21:07:53 | fowl | or at least syntactically checked |
| 21:08:15 | Araq | nolan2: disabled code is not the same as a *comment* |
| 21:08:25 | filwit | does Aporia support comment/uncomment code blocks? |
| 21:08:33 | Araq | I think it does now |
| 21:08:40 | filwit | nice |
| 21:08:55 | nolan2 | Ah, OK. Hmm. |
| 21:09:04 | Araq | filwit: yep. |
| 21:09:05 | filwit | i am going to pull down the latest Nimrod/Aporia soon |
| 21:09:17 | Araq | it generates a discard """ ... """ though |
| 21:09:21 | Araq | :-/ |
| 21:09:46 | filwit | that's no good |
| 21:09:51 | filwit | should just prefix '#' |
| 21:10:59 | Araq | yeah or use a 'when false' |
| 21:11:55 | filwit | idealy, the un/comment-block operation should just prefix a '#', IMO |
| 21:12:02 | filwit | cause it will show up as comments that way |
| 21:12:13 | Araq | it should be configurable |
| 21:12:21 | filwit | true |
| 21:15:21 | filwit | why does Nimrod take up 100mb... |
| 21:15:38 | filwit | neh, ~200mb |
| 21:16:40 | filwit | and i'm downloading from my repo, i haven't even pulled upstream changes for ages |
| 21:16:58 | filwit | is there artwork or something in the repo? |
| 21:17:18 | Araq | no there is a long history of build.zip files though |
| 21:17:37 | reactormonk | Araq, hmm, a way to find why serve exits? Can I somehow set a breakpoint for an exit call? |
| 21:17:40 | filwit | ahh, i see |
| 21:17:57 | Araq | I heard pruning the repo would cut off all forks:-/ |
| 21:18:30 | filwit | it would be a good idea though, i think |
| 21:18:40 | filwit | just inform those who've forked it |
| 21:19:58 | Araq | reactormonk: just grep for 'quit' in the compiler's sources |
| 21:20:28 | Araq | chances are high it's the one in service.nim:92 that causes problems |
| 21:21:28 | filwit | Araq: what is the likelihood that forward-declaration will be removed? |
| 21:21:43 | Araq | filwit: >90% |
| 21:22:18 | filwit | awesome. Lot of work? |
| 21:22:39 | Araq | yes and it breaks all sorts of invariants |
| 21:23:04 | Araq | but since you can't live with the slightest inconveniences anymore |
| 21:23:07 | filwit | worth it. I bet a lot of people turn away once they hear that about the language |
| 21:23:24 | Araq | *shrug* |
| 21:23:44 | Araq | it may suprise you but: I've never optimized the language design for popularity |
| 21:23:58 | fowl | more difficult than implementing {.forward.}? |
| 21:24:15 | Araq | it's not even sound: |
| 21:24:24 | Araq | proc p(x: type(q)) |
| 21:24:31 | Araq | proc q(x: type(p)) |
| 21:25:13 | filwit | Araq: oh i'm extremely picky, i admit. That's why i started my own thing... i have very particular ideas about what's right, and I want to control all the details. |
| 21:25:39 | Araq | it's not that you're picky |
| 21:25:45 | filwit | Araq: still, i think i've presented valid reasoning, and even if not, i still attempt to provide some kind of reasoning. |
| 21:25:59 | filwit | Araq: not saying that you don't |
| 21:26:24 | Araq | it's that I often wonder if you're actually interested in the end result |
| 21:26:32 | Araq | er ... |
| 21:26:39 | Araq | that's a more general "you" here |
| 21:26:50 | filwit | what do you mean? |
| 21:26:55 | filwit | by "end result"? |
| 21:27:10 | Araq | like consindering what it means to get small&fast binaries without dependencies |
| 21:27:11 | filwit | i'm looking for a C# replacement, always have been |
| 21:28:14 | Araq | or that you can use a single language for scripting and system programming |
| 21:28:51 | filwit | of course you can... i always get told you can't, and i think people are completely wrong about that. |
| 21:29:10 | filwit | just because no one had designed a language with that kind of layering yet, doesn't mean it isn't possible |
| 21:29:20 | filwit | look at Unity3D, it uses C# for scripting |
| 21:29:43 | filwit | but D is almost as easy as C#, and has the potential of being just as fast as C++ |
| 21:29:55 | filwit | Nimrod is the same (only completely different in design) |
| 21:31:23 | filwit | that's what frustrates me so much about your design choices... you have great syntax like "var" and everything looks like functions.. there's a GC, etc.. all for convenience |
| 21:32:47 | filwit | but there are a lot of other things that make it hard to learn and use |
| 21:32:54 | filwit | (IMO obviously) |
| 21:33:10 | Araq | hard to *use*? that's news to me |
| 21:33:21 | Araq | hard to learn? perhaps. |
| 21:33:59 | filwit | yes, this is why i'm always bugging you about consistency. Learning is a mental challenge.. so is "use". You have to remember more things.. |
| 21:34:11 | filwit | like: new(type) & newSeq(type) |
| 21:34:24 | filwit | two things which basically do the same thing (conceptually) |
| 21:34:30 | filwit | two things to remember |
| 21:34:44 | fowl | you only need newSeq() in rare cases |
| 21:34:57 | shevy | just design like php - throw everything into a pot and call that a "finished language" |
| 21:35:04 | filwit | yes, only because there's a 3rd way to do it!! |
| 21:35:08 | filwit | that's exactly my point |
| 21:35:15 | Araq | you also do: s = "" and not new(s) |
| 21:35:24 | Araq | and yet you never complain about that |
| 21:35:42 | filwit | yes, because there is a balance |
| 21:35:58 | filwit | you want those things that are very very common to have sugar |
| 21:36:00 | fowl | filwit: no, because if you can initialize a variable when you declare it you're better off, however it shouldnt be forced |
| 21:36:21 | fowl | you can use newseq if you know what size seq you need and save an allocation |
| 21:36:51 | filwit | fowl: that doesn't mean the syntax wouldn't be much easy (both to learn and use) like this: var s = seq(int).new() |
| 21:37:06 | filwit | fowl: and every other type works the same |
| 21:37:20 | filwit | fowl: meaning to make an int, you can do: var i = int.new() |
| 21:37:27 | Araq | except that you don't "new" value types at all |
| 21:37:43 | filwit | good point |
| 21:37:54 | filwit | but for each reference type, you use that syntax |
| 21:38:07 | Araq | seq is not a reference type |
| 21:38:40 | Araq | it has some specialties/misfeatures like "nil" |
| 21:38:50 | filwit | so make it: var s = seq(int).set([1, 2, 3]) |
| 21:38:50 | Araq | but it's not a reference type |
| 21:39:05 | Araq | you can that today |
| 21:39:11 | Araq | var s = @[1, 2, 3] |
| 21:39:14 | filwit | the point is to keep the way to do things to a minimum |
| 21:40:06 | Araq | btw there are people that actually *use* Nimrod |
| 21:40:17 | fowl | i like to do |
| 21:40:24 | filwit | there are people that use Visual Basic, what is your point? |
| 21:40:31 | Araq | and nobody said "the cognitive load is too high" |
| 21:40:47 | filwit | i did |
| 21:41:09 | Araq | but you're pretending to be the dumbest script kiddie ever |
| 21:41:25 | Araq | to arrive at a minimal design |
| 21:41:32 | fowl | proc loadAssets(file: string, errors: var seq[string]) = if isNil(errors): newSeq(errors, 0) #errors = @[] would work here too.. |
| 21:41:36 | Araq | kudos to you for being able to do that btw |
| 21:41:39 | fowl | var errors: seq[string] |
| 21:41:46 | fowl | loadAssets(file, errors) |
| 21:42:01 | fowl | if errors.len(): echo "has errors: " .. |
| 21:42:08 | Araq | but it makes your arguments artificial |
| 21:42:28 | filwit | Araq: no, you just don't see why it's important to eliminate the number of ways to do things. Like I said, there's a balance |
| 21:43:22 | filwit | Araq: I do try (when thinking about language design) to put myself in a "learners" position |
| 21:43:43 | Araq | yes and you're good at that |
| 21:44:13 | Araq | but these minor things you come up with are not a constant source of confusion |
| 21:44:33 | Araq | instead they are still easily learned |
| 21:44:45 | filwit | papercuts add up |
| 21:45:14 | filwit | and you're fighting against language that make things very easy, like C# |
| 21:45:31 | filwit | or.. you're not fighting, like you say, you don't care about popularity |
| 21:45:36 | filwit | which i don't really believe |
| 21:46:09 | filwit | also, I never said Nimrod doesn't have some awesome features |
| 21:46:29 | filwit | and when i first started using Nimrod, I really liked the UFCS, etc |
| 21:46:53 | filwit | it's only more recently that i realized that leads to really hard to follow code |
| 21:47:05 | fowl | filwit: it seems to me like you're focusing on the most minor syntactic details |
| 21:47:27 | filwit | fowl: i'm a graphics artist... people really don't realize how important the details are |
| 21:47:42 | fowl | "hard to follow code in my opinion"* |
| 21:47:47 | filwit | fowl: you can take a basic shape, and really sell it with some drop-shadow and a gradient |
| 21:48:13 | filwit | fow: everything I'm saying is obviously "in my opinion" i don't really see the point in explaining that |
| 21:48:21 | filwit | fowl: with every assertion i mean |
| 21:49:23 | filwit | fowl: obviously, the things I say aren't universal truths... just because I say them. |
| 21:50:10 | fowl | i think that in general people find it easier to read, its easy to see the flow your data is taking when methods are chained together |
| 21:50:40 | reactormonk | Araq, nope, it's not that one |
| 21:50:54 | fowl | otherwise oop would be dead in the water |
| 21:50:55 | filwit | fowl: I can chain my methods together in my design without UFCS |
| 21:51:05 | filwit | fowl: also, look at Dart |
| 21:51:20 | * | nolan2 quit (Quit: Leaving.) |
| 21:51:40 | filwit | fowl: while i don't agree with the syntax entirely, they do this: Object.dosomething()..dosomethingElse() // notice the '..' |
| 21:51:59 | fowl | what is the .. for |
| 21:52:08 | fowl | is Object and object instance or a namespace |
| 21:52:09 | filwit | fowl: 'dosomething()' in the example doesn't return |
| 21:52:24 | gour | am i right that none of the github/bitbucket/SF's trackers has support for handling stuff via email? |
| 21:52:52 | filwit | fowl: so '..' means 'Object.' |
| 21:53:30 | filwit | fowl: it's sugar for chaining method calls... though I think there's a better way (in my design) but I won't go over that |
| 21:53:32 | fowl | ok so its analogous to smalltalk cascading |
| 21:53:48 | filwit | basically, don't know much about smalltalk |
| 21:54:39 | dom96 | gour: github does. |
| 21:54:40 | Araq | reactormonk: is it msgs.SuggestQuit? |
| 21:54:59 | gour | dom96: it's possible to created/edit/close tickets via email= |
| 21:55:00 | gour | ? |
| 21:55:22 | dom96 | reactormonk: Perhaps you could add an 'assert false' in the stdlib's quite proc? |
| 21:55:37 | dom96 | filwit: I am here now, design time? |
| 21:55:57 | filwit | dom96: sure! just wanted to get your ideas for the logo |
| 21:56:32 | dom96 | fowl: I think I will transition asyncio to use closure iterators, it should then be natural to add support for downloading files. |
| 21:56:59 | filwit | dom96: do you have any ideas on logo design? or color preferences? |
| 21:57:26 | fowl | dom96: cooooool:> |
| 21:58:02 | filwit | dom96: also, what kinda "fealings" do you want? "cool" "hip" "cute" "masculine/feminine", etc ? |
| 21:58:07 | dom96 | filwit: I don't really have a clear idea :\ |
| 21:58:24 | dom96 | filwit: I'd say: cool, masculine. |
| 21:58:27 | Araq | aporia should get a hat |
| 21:58:36 | filwit | dom96: a hat? |
| 21:58:42 | filwit | Araq: a hat? |
| 21:58:50 | Araq | a wizard's hat |
| 21:59:04 | Araq | cause it does all the magic :-) |
| 21:59:15 | filwit | well Aporia means "deep thought" or a "butterfly" |
| 21:59:20 | filwit | or something like that |
| 21:59:25 | dom96 | lol, so every nimrod tool will be something to wear on your head? :P |
| 21:59:30 | filwit | don't really have to keep it in those boundries |
| 21:59:35 | Araq | dom96: that's the idea |
| 21:59:40 | dom96 | I wouldn't mind a butterfly |
| 21:59:46 | Araq | oh come on |
| 21:59:49 | filwit | LOL |
| 21:59:51 | Araq | a butterfly is lame |
| 21:59:54 | fowl | filwit: f2(f1(a)) is not chaining as a.f1.f2(), you see how the flow requires you to look inside the expression and move outwards (to the left no less, i reckon that most of the programmers reading/writing with ascii characters dont read right to left) |
| 21:59:55 | filwit | i kinda like Araq's idea |
| 22:00:12 | Araq | and already taken by perl6 anyway |
| 22:00:20 | fowl | i dont understand what your point was with dart's Object.foo()..foo2() |
| 22:00:22 | dom96 | A wizard hat though... |
| 22:00:28 | dom96 | Sorry, I don't like that. |
| 22:00:47 | dom96 | I'm visualising some silly cartoon hat. |
| 22:01:17 | dom96 | filwit: You can draw a concept if you want. But i'm not sure i will like it. |
| 22:01:20 | Araq | think of Gandalf's hat :P |
| 22:01:33 | filwit | fowl: first, 'f1' IMO, should always require the '()' brackets (to indicate it's not a property), and i completely agree with you... i just don't agree with global floating functions in the first place. |
| 22:01:37 | fowl | dom96: make it a unicorn with a machete for a horn |
| 22:01:42 | dom96 | that does butch it up a bit. |
| 22:01:53 | dom96 | now, a unicorn would be cool :P |
| 22:02:01 | filwit | fowl: everything should be "purely" OOP, with a "type" being the top-level encapsulating object (no modules) |
| 22:02:30 | dom96 | Not sure about the machete. |
| 22:02:38 | Araq | except that's not what a "type" is at all :P |
| 22:02:45 | filwit | fowl: therefor, everything works like UFCS does.. without the alternative way: f2(f1(a)) |
| 22:02:54 | fowl | filwit: have you tried ruby? |
| 22:03:30 | filwit | fowl: glanced at it, but if you don't mind, I will talk to you about language design a little later |
| 22:03:44 | fowl | filwit: nvm, i cant continue this conversation because its not going anywhere |
| 22:03:48 | fowl | afk |
| 22:04:10 | dom96 | filwit: hah, you could actually draw Deep Thought, the big robot from Hitchiker's guide to the galaxy :P |
| 22:04:35 | filwit | dom96: lol |
| 22:04:45 | filwit | that would be interesting |
| 22:05:23 | filwit | still.. i when i said I liked Araq's idea, I was thinking more like a hat with a butterfly on it... |
| 22:05:41 | filwit | but you probably wont like that... yes? |
| 22:05:45 | Araq | no butterflies |
| 22:05:52 | dom96 | no hats :P |
| 22:05:53 | Araq | we're no hippies |
| 22:06:03 | filwit | butterflies are hippy... |
| 22:06:23 | filwit | well.. sortof |
| 22:06:32 | filwit | arent** |
| 22:06:50 | filwit | okay, so.. no butterflies and no hats... |
| 22:06:58 | filwit | "cool" and "masculine" |
| 22:06:58 | reactormonk | lib/system.nim(885, 62) Error: undeclared identifier: 'assert' |
| 22:07:01 | reactormonk | O.o |
| 22:07:04 | Araq | butterflies are very bad for the weather |
| 22:07:12 | filwit | what? |
| 22:07:22 | dom96 | hrm, i'm not sure "Aporia" actually means "Deep thought" |
| 22:07:23 | filwit | weather? |
| 22:07:36 | dom96 | "An irresolvable internal contradiction in a text, argument, or theory." |
| 22:07:45 | dom96 | "The expression of doubt." |
| 22:07:47 | Araq | ever heard of the "butterfly effect"? |
| 22:08:08 | Araq | butterflies cause rain and snow |
| 22:08:30 | dom96 | Yeah, so do I, when I fart. |
| 22:08:51 | Araq | that's why you'll pay a tax for it soon |
| 22:09:32 | filwit | lol, wut r u guys talking about? |
| 22:09:58 | fowl | make the logo an earth with a fennec fox wrapped around it |
| 22:10:08 | fowl | and change the name to firefax |
| 22:10:31 | filwit | lawl |
| 22:10:31 | * | Zerathul joined #nimrod |
| 22:11:12 | dom96 | Lets use a Yu-gi-oh character! http://yugioh.wikia.com/wiki/Aporia |
| 22:11:44 | filwit | no |
| 22:11:49 | filwit | :-P |
| 22:12:08 | dom96 | Don't you want to practice your anime drawing skills? |
| 22:12:21 | filwit | it's your logo, dom96, so i will do whatever you want |
| 22:12:29 | filwit | LOL |
| 22:12:37 | filwit | i know you're just joking (at least i hope) |
| 22:12:48 | dom96 | lol |
| 22:13:54 | dom96 | There really isn't much else about what Aporia means on the internet |
| 22:14:01 | dom96 | I really did pick one of the dying words. |
| 22:15:38 | dom96 | Look someone made some header text for us: http://1.bp.blogspot.com/_8FZJEaIVhug/TJm0qfjEy-I/AAAAAAAAALc/dCPHrjsqfNA/s1600/Aporia-Logo1.jpg |
| 22:15:56 | filwit | yes, your choice was horrible for design.. lol |
| 22:15:59 | filwit | but it sounds cool |
| 22:16:11 | filwit | and it gives us a lot of creative freedom really |
| 22:16:11 | dom96 | yep |
| 22:16:23 | filwit | we can do something more abstract too |
| 22:16:36 | filwit | i have an interesting idea actually |
| 22:16:41 | dom96 | Well I can see memes with this word... lol |
| 22:16:49 | dom96 | http://media.tumblr.com/tumblr_ljihzzJAwK1qbolbn.jpg |
| 22:17:20 | dom96 | This looks nice: http://f0.bcbits.com/z/11/02/1102470375-1.jpg |
| 22:17:31 | dom96 | filwit: what's your idea? |
| 22:18:24 | * | Zerathul quit (Quit: ChatZilla 0.9.90 [Firefox 18.0.2/20130201065344]) |
| 22:18:34 | filwit | i will have to show you |
| 22:18:40 | filwit | one second though |
| 22:18:55 | filwit | give me a minute, then i will jump into designing and show you something |
| 22:19:37 | dom96 | hrm, I'm thinking that perhaps this would look nice as a logo: http://www.jpmoth.org/~dmoth/Butterflies%20of%20China/03_Pieridae/Aporia%20delavayi/Aporia%20delavayi_070702386.jpg |
| 22:20:07 | dom96 | It's not very colorful, if you kept it that way maybe it would be quite a "cool" and "dark" butterfly? |
| 22:20:31 | * | FreeArtMan quit (Quit: rm -rf /) |
| 22:21:12 | * | gour quit (Quit: WeeChat 0.4.0) |
| 22:58:31 | * | nolan2 joined #nimrod |
| 23:10:04 | reactormonk | new design up... when? |
| 23:10:47 | Araq | with the next release, reactormonk |
| 23:15:54 | NimBot | Araq/Nimrod 02ba4f7 Dominik Picheta [+0 ±3 -0]: Fixed timeouts for sockets, implemented timeouts in httpclient and fixed... 2 more lines |
| 23:18:09 | nolan2 | So what is the canonical wayto implement string conversion for a Nimrod type? Implement a `$` proc, or is there another method that calls `$`? |
| 23:18:39 | Araq | implement a $ proc |
| 23:19:03 | nolan2 | Cool, thanks. |
| 23:32:01 | reactormonk | Araq, quit proc is magic btw... |
| 23:37:35 | reactormonk | so can't do that |
| 23:38:22 | reactormonk | wait.. |
| 23:38:24 | dom96 | create a 'quit' proc, rename the current 'quit' proc, assert false in the new proc :P |
| 23:38:48 | reactormonk | dom96, just did that... assert not defined. |
| 23:39:09 | reactormonk | why can't raise raise a string? :-/ |
| 23:40:26 | dom96 | use newException |
| 23:41:17 | Araq | reactormonk: assert is defined somewhere in system.nim |
| 23:41:37 | Araq | move the 'quit' around so that it comes after the assert definition |
| 23:42:58 | reactormonk | Araq, assert depends on raise depends on quit more or less |
| 23:43:14 | Araq | see? |
| 23:43:26 | Araq | you're about to produce an endless recursion |
| 23:43:43 | Araq | and the "no forwarding" rules helped to make you aware of it :P |
| 23:44:08 | Araq | but no no no ... it's inconvenient to have to think about dependencies, I know, I know |
| 23:46:05 | reactormonk | how can I print the stacktrace? |
| 23:46:52 | Araq | echo e.getStackTrace |