2015-12-26T00:13:38Z physixer quit (Ping timeout: 256 seconds)
2015-12-26T00:14:06Z cemerick quit (Ping timeout: 240 seconds)
2015-12-26T00:20:06Z physixer joined #scheme
2015-12-26T00:29:13Z nilg quit (Remote host closed the connection)
2015-12-26T00:53:36Z Beluki quit (Quit: Beluki)
2015-12-26T00:55:04Z jcowan joined #scheme
2015-12-26T00:55:14Z pjb: physixer: it's possible, but only the first matching branch is evaluated.
2015-12-26T00:56:01Z pjb: (cond ((= a b) 42) ((= a b) '(my teacher is a boss)) (else 0)) ;-)
2015-12-26T01:07:41Z fantazo quit (Ping timeout: 246 seconds)
2015-12-26T01:10:39Z pjb: https://www.youtube.com/watch?v=Y-7j_URPbpI
2015-12-26T01:10:44Z pjb: Oops, sorry.
2015-12-26T01:24:00Z jcowan: ww errors give interesting insights into people's other interests
2015-12-26T01:33:38Z oleo_ joined #scheme
2015-12-26T01:34:19Z physixer: (define-struct vector [x y z]) is really orthogonal to manual (define (make-vector x y z) (list x y z))
2015-12-26T01:34:37Z physixer: in the first case you can't loop through the components, in the second you can, right?
2015-12-26T01:36:07Z physixer: I'm using DrRacket BSL mode
2015-12-26T01:36:47Z oleo quit (Ping timeout: 264 seconds)
2015-12-26T01:58:50Z Fare joined #scheme
2015-12-26T02:13:05Z aap_ joined #scheme
2015-12-26T02:16:06Z aap quit (Ping timeout: 240 seconds)
2015-12-26T02:16:40Z pierpa: physixer: correct
2015-12-26T02:21:58Z Fare quit (Ping timeout: 250 seconds)
2015-12-26T02:23:43Z Fare joined #scheme
2015-12-26T02:35:42Z karswell` joined #scheme
2015-12-26T02:36:35Z karswell quit (Remote host closed the connection)
2015-12-26T02:50:36Z lambda-11235 joined #scheme
2015-12-26T03:15:03Z Necrosporus: Does emacs lisp worth learning for anything that is not related to emacs? Is there a stand-alone elisp compiler?
2015-12-26T03:15:33Z Necrosporus: in other words, does it contain any cool features, which are lacking in scheme?
2015-12-26T03:16:33Z pjb: physixer: if the implementation doesn't have native structures, then usually vectors are used to store the slots, rather than lists.
2015-12-26T03:19:23Z physixer: '(1 2 3) is not working with DrRacket BSL, BSL with abbreviations, Intermediate. And I'm getting sick of HtDP anyway. Too much spoon-feeding in some parts, being overly clever in others.
2015-12-26T03:19:57Z pjb: Necrosporus: Well, the cool features of emacs lisp are actually the editing data structures and functions. Things like buffers, windows, keymaps, etc.  Notably, with buffers, there are buffer local variables: any global variable can be made such that when it is set it becomes lcoal to the current buffer (like if it was a slot to the buffer object).  As a lisp, it's an old lisp-2 (with recently only the addition of lexical scoping an
2015-12-26T03:19:58Z pjb: true closures).
2015-12-26T03:20:21Z pjb: physixer: some students seem to need all those details.
2015-12-26T03:20:41Z pjb: physixer: To learn a language, I like reading just the reference or standard definition.
2015-12-26T03:20:44Z physixer: pjb: what do you mean by 'slots'? I haven't heard it in context of scheme. Is it from SICP?
2015-12-26T03:21:13Z pjb: I'm used to CL terminology.  A slot would be an entry in a structure, an object, a vector or array.
2015-12-26T03:21:27Z physixer: ok
2015-12-26T03:21:41Z pjb: slot, field, attribute, etc, it's all the same.a
2015-12-26T03:21:44Z physixer: so struct-member
2015-12-26T03:21:45Z pjb: member in C++…
2015-12-26T03:21:49Z physixer: yup
2015-12-26T03:22:36Z physixer: SICP is a little verbose for my taste too, but I'm guessing the "metacircular" discussion might be interesting.
2015-12-26T03:23:20Z physixer: I'm primarily attracted to scheme for minimalism, and meta. (metaprogramming, meta-abstractions, meta, meta, meta)
2015-12-26T03:23:46Z pjb: A lot of scheme material on http://schemers.org/
2015-12-26T03:24:21Z Necrosporus: I think SICP is fine. Though The Little Schemer is too verbose
2015-12-26T03:24:59Z physixer: Necrosporus: Oh I was hoping the opposite. That little schemer would head straignt into meta land and blow your mind.
2015-12-26T03:25:15Z pierpa quit (Ping timeout: 240 seconds)
2015-12-26T03:25:20Z Necrosporus: physixer, TLS repeats concept too much
2015-12-26T03:25:24Z Fare quit (Quit: Leaving)
2015-12-26T03:25:52Z Necrosporus: Like analysis of similar programs one after another
2015-12-26T03:26:09Z physixer: Necrosporus: wait TLS is only 216 pages. Still verbose?
2015-12-26T03:26:16Z Necrosporus: Also I can write same code in better way than in the book and without looking in complete solution
2015-12-26T03:26:26Z Necrosporus: physixer, a whole 216 pages!
2015-12-26T03:26:35Z pjb: It was shorter when it was named The Little Lisper, came as 30 or 40 photocopied pages then :-)
2015-12-26T03:26:38Z Necrosporus: it could be made at least 10 times shorter
2015-12-26T03:26:49Z physixer: oops.
2015-12-26T03:26:58Z Necrosporus: Maybe I should have taken TLL instead
2015-12-26T03:27:23Z physixer: I guess I'm looking for a 50 page summary of SICP+HtDP, and a 50 page summary of TLS. Without missing any details though.
2015-12-26T03:27:44Z Necrosporus: What's HtDP?
2015-12-26T03:27:50Z pjb: It's old. You would need to adapt your scheme to run TLL programs on. (eg. defining functions such as atom, etc).
2015-12-26T03:28:02Z physixer: Necrosporus: http://www.ccs.neu.edu/home/matthias/HtDP2e/Draft/index.html
2015-12-26T03:28:09Z pjb: How to Design Programs -- An Introduction to Computing and Programming  http://www.htdp.org/2003-09-26/Book/
2015-12-26T03:28:40Z Necrosporus: does I need to read it too, or it duplicates SICP?
2015-12-26T03:29:32Z pjb: Necrosporus: well, basically HtDP teaches you Scheme.  SICP teaches you programming.
2015-12-26T03:29:45Z physixer: Necrosporus: my guess is there is a lot of duplication. Plus HtDP is at more beginner level. The cartoon graphics, and hand-holding in some parts is killing me.
2015-12-26T03:32:32Z Necrosporus: I like the approach of TLS, but it's directed to make people understand recursion, it does not help much to ones who understands it already
2015-12-26T03:32:49Z cemerick joined #scheme
2015-12-26T03:32:57Z Necrosporus: Only things I learned from TLS is meaning of car, cdr, cons so far
2015-12-26T03:33:15Z Necrosporus: The rest is discussion something I already understand mostly
2015-12-26T03:33:17Z physixer: Necrosporus: and how far are you into it?
2015-12-26T03:33:28Z Necrosporus: 99/211
2015-12-26T03:33:38Z physixer: that's depressing.
2015-12-26T03:34:17Z physixer: car cdr cons were implemented by the fourth or fifth lecture of the SICP 1980s playlist on youtube
2015-12-26T03:34:35Z Necrosporus: I think I'd rather read a book
2015-12-26T03:35:10Z Necrosporus: And I do fast-forward, so TLS is not so depressing. It's quite clean where I can make fast forward
2015-12-26T03:36:02Z Necrosporus: I think that ideal book for me was something what starts with exercises with short descriptions
2015-12-26T03:36:49Z Necrosporus: And if you can't make an exercise, then you have to read the rest of chapter
2015-12-26T03:36:58Z pjb: Necrosporus: try to read r5rs first.  http://www.schemers.org/Documents/Standards/R5RS/HTML/
2015-12-26T03:36:58Z physixer: I had to skip HtDP sections here and there too. But then the perfectionist in me starts nagging 'maybe I missed an important thing in the skipped section'.
2015-12-26T03:37:03Z pjb: It's only 50 pages.
2015-12-26T03:37:54Z Necrosporus: I do not like the format. I'd like a single page HTML with better graphics for formulas (or tex rendering)
2015-12-26T03:37:59Z pjb: Then once you've read r5rs, you may want to browse the SRFIs. http://srfi.schemers.org/
2015-12-26T03:38:06Z Necrosporus: Nope
2015-12-26T03:38:27Z Necrosporus: I do not intend to use Scheme for writing stuff after I learn it
2015-12-26T03:38:47Z Necrosporus: I do it only for ideas, not for language itself
2015-12-26T03:39:05Z Necrosporus: Tcl can do everything scheme does, I think
2015-12-26T03:39:31Z Necrosporus: and unlike scheme there is no thousands of incompatible implementations
2015-12-26T03:39:39Z physixer: Maybe I should jump straight into Krishnamurthi's Programming Languages. Any ideas about that book? what level it is?
2015-12-26T03:39:57Z ArneBab_ joined #scheme
2015-12-26T03:40:01Z Necrosporus: physixer, download it and read first parts and something from middle?
2015-12-26T03:42:49Z Necrosporus: pjb, though I could actually implement scheme in Tcl and write in my own scheme
2015-12-26T03:42:55Z ArneBab quit (Ping timeout: 240 seconds)
2015-12-26T03:43:09Z Necrosporus: Is it better than writing in Tcl directly?
2015-12-26T03:43:32Z Necrosporus: Tcl is somewhat similar to lisps with a little different approach
2015-12-26T03:44:28Z physixer: Necrosporus: that's similar to what I thought. When I came across lambda calculus and SICP lectures, I though I should implement it in C myself. I'm still considering that, given that R5RS is only 50 pages. I'm think more about R7RS which is also minimal compared to R6RS.
2015-12-26T03:44:31Z Necrosporus: in lisps keyword is used to distinguish special forms from function calls. Terms must be quoted to avoid expansions
2015-12-26T03:45:05Z Necrosporus: pjb, why do you recommend r5rs instead of r7rs?
2015-12-26T03:45:15Z Necrosporus: or r4rs
2015-12-26T03:46:38Z Necrosporus: In Tcl everything is command, there is no distinction between procedure and language primitive except implementation
2015-12-26T03:47:10Z Necrosporus: Variables should be preceded by $ to be expanded, they are not expanded by default
2015-12-26T03:47:49Z Necrosporus: There is first class lambda functions though, but they are not as useful as in lisp
2015-12-26T03:48:29Z Necrosporus: So basically, scheme is mostly functions with few macros
2015-12-26T03:49:25Z Necrosporus: Tcl is mostly procedures (which are like scheme special forms / macros) with few lambda-functions which are not part of language itself
2015-12-26T03:49:51Z Necrosporus: if there were no apply and lambda in Tcl they could have been implemented with procedures
2015-12-26T03:51:51Z Necrosporus: Also in lisp macros and variables are same namespace, so you can't have both variable named if and function/specialform named if, in Tcl it's no problem to call a variable "if", it will work just fine
2015-12-26T03:53:57Z Regulator_ joined #scheme
2015-12-26T03:55:56Z Regulator9 quit (Ping timeout: 272 seconds)
2015-12-26T04:11:10Z karswell` quit (Remote host closed the connection)
2015-12-26T04:12:35Z physixer: so lemme get this straight, HtDP's BSL (beginner student language) doesn't allow functions to be passed as parameters?
2015-12-26T04:12:56Z physixer: (define (maploop func L)
2015-12-26T04:12:58Z physixer:   (if (empty? L)
2015-12-26T04:12:58Z physixer:       empty
2015-12-26T04:12:58Z physixer:       (cons (func (car L)) (maploop func (cdr L)))))
2015-12-26T04:13:19Z physixer: this gives error in DrRacket: function call: expected a function after the open parenthesis, but found a variable
2015-12-26T04:14:27Z physixer: with 'func' of (func (car L)) highlighted
2015-12-26T04:22:51Z physixer quit (Quit: leaving)
2015-12-26T04:47:03Z corruptbehavior joined #scheme
2015-12-26T05:06:15Z badkins joined #scheme
2015-12-26T05:10:06Z Guest1698 quit (Ping timeout: 240 seconds)
2015-12-26T05:11:08Z badkins quit (Ping timeout: 256 seconds)
2015-12-26T05:12:18Z Necrosporus: How would you do a lisp compiler or interpreter on itself?
2015-12-26T05:12:28Z Necrosporus: I mean, how would it run?
2015-12-26T05:16:10Z wolfcore joined #scheme
2015-12-26T05:16:33Z wolfcore is now known as Guest97128
2015-12-26T05:20:12Z jcowan: Necrosporus: Typically you use another Lisp to host it until it can support itself.  Chicken, a Scheme-to-C compiler, was originally hosted on Gambit, another Scheme-to-C compiler.
2015-12-26T05:20:54Z jcowan: The original Scheme interpreter and the first Scheme compiler, Rabbit, were hosted on MacLisp, one of the predecessors of Common Lisp
2015-12-26T05:21:39Z Necrosporus: jcowan, I mean how do you do it at all? Parse each byte?
2015-12-26T05:21:50Z Necrosporus: Not that how to host it
2015-12-26T05:22:05Z Necrosporus: but how to compile lisp, write x86 instructions?
2015-12-26T05:22:24Z Necrosporus: Then if you want to support x86_64 you'd need to rewrite half of compiler
2015-12-26T05:22:44Z jcowan: There are for that reason relatively few native code Lisp compilers
2015-12-26T05:22:51Z jcowan: s/Lisp/Scheme
2015-12-26T05:24:21Z Necrosporus: jcowan, but even if you host it on another compiler, do you parse each byte?
2015-12-26T05:24:24Z jcowan: There are byte code compilers with or without JIT compilers, compilers to C, byte code interpreters, tree-walking interpreters, etc.
2015-12-26T05:24:31Z jcowan: Eventually yes
2015-12-26T05:24:44Z jcowan: Though to start with you can often use the host implementation's reader to start with.
2015-12-26T05:24:45Z Necrosporus: And then produce some byte-code
2015-12-26T05:24:54Z jcowan: It varies
2015-12-26T05:25:14Z jcowan: Chicken does not produce byte code, for example; the interpreter is a classic (slow) tree walker, the compiler generates C.
2015-12-26T05:25:43Z jcowan: Chibi generates byte code, Racket generates byte code but has a JIT
2015-12-26T05:26:05Z jcowan: It's common for interpreters to be written partly in C but mostly in Scheme
2015-12-26T05:26:33Z jcowan: kawa generates JVM byte codes
2015-12-26T05:26:39Z jcowan: and much of it is written in Java
2015-12-26T05:26:46Z Necrosporus: How do you generate C file? I imagine, write a static list of C defines, then generate the rest as simple sequence of letter, so resulting code would be basically #include <compiler.h> F b w 3 W v ...
2015-12-26T05:27:23Z jcowan: Not typically.  Typically you output fairly readable C, at least locally, though it may be hard to decipher it more globally because it is not typical C.
2015-12-26T05:28:20Z jcowan: There is a library by Alex Shinn, fmt, that helps generate C code.  Similar libraries exist for the JVM and CLR byte codes.
2015-12-26T05:29:24Z Necrosporus: But if you output C, then you cannot use JIT and you cannot outperform C
2015-12-26T05:29:37Z Necrosporus: What if I want to outperform C on same algorithm?
2015-12-26T05:29:44Z jcowan shrugs.
2015-12-26T05:29:52Z Necrosporus: Is it possible?
2015-12-26T05:30:02Z Necrosporus: Some say that Stalin can do that
2015-12-26T05:30:24Z jcowan: Stalin probably outperforms typical hand-written C, provided your code is debugged, because the development cycle is horribly long
2015-12-26T05:30:35Z jcowan: Stalin takes 24h to compile itself on modern hardware
2015-12-26T05:31:01Z jcowan: Also its community is dysfunctional to the point of being nonexistent.
2015-12-26T05:31:23Z Necrosporus: jcowan, why not to write with other scheme interpreter, and then compile with stalin?
2015-12-26T05:31:51Z jcowan: That wouldn't help much.  It would still be an interpreter, and the problem with interpreters is that they do a lot of redundant processing at run time.
2015-12-26T05:32:19Z jcowan: Looking up variables over and over, etc.
2015-12-26T05:32:41Z Necrosporus: I mean, you write it and test on small data-set, when you see that it works fine, you compile it with stalin and use a larger dataset?
2015-12-26T05:32:52Z Necrosporus: then it would work instantly even with interpreter
2015-12-26T05:33:38Z jcowan: The whole point of compilers is to precompute a great deal so that it does not have to be computed at run time.
2015-12-26T05:33:56Z jcowan: A Stalin-compiled interpreter is still computing everything at run time.
2015-12-26T05:35:49Z Necrosporus: What output format do you think is more reasonable? C, LLVM, CLR, JVM, Parrot, some other bytecode, or even assembly?
2015-12-26T05:36:57Z Necrosporus: you could output assembly and build it with fasm, for example, this way you get all the power of native code and you do not need to have headache with opcodes
2015-12-26T05:37:12Z jcowan: In my opinion there is no one best choice.  Also you left off JavaSCript.
2015-12-26T05:38:05Z jcowan: I don't know of any Schemes whose back ends are LLVM or Parrot, though they may exist.
2015-12-26T05:38:22Z Necrosporus: jcowan, I know, but for my case, when I want to get working compiler as easily as possible, if I do not plan to use it for anything, just to learn theory or compilation?
2015-12-26T05:38:55Z Necrosporus: So it does not have to be fast or efficient, it only have to work
2015-12-26T05:39:18Z Necrosporus: jcowan, also if there's still no scheme for llvm, I could make first one
2015-12-26T05:39:41Z Necrosporus: if I actually do that, which is not very likely. I'm just evaluating it
2015-12-26T05:41:02Z jcowan: I see a paper here about an LLVM back end for Bigloo, which is a highly retargetable compiler (C, JVM, CLR)
2015-12-26T05:43:13Z jcowan: Have you seen the 90 minute Scheme to C video by Marc Feeley?  There are slides too
2015-12-26T05:43:36Z Necrosporus: jcowan, what was the point of developing Chicken if there was already Gambit?
2015-12-26T05:43:48Z Necrosporus: nope
2015-12-26T05:44:02Z jcowan: I recommend it for your situation
2015-12-26T05:44:56Z jcowan: I don't know, you'd have to ask Felix.  Like a lot of things including Linux, it was started for fun and to experiment with a certain implementation technique that had been described in the literature but never used in practice before.
2015-12-26T05:45:35Z jcowan: Scheme is small enough that there are almost 80 implementations in the Fairly Complete List, and I have almost 50 installed on my Linux box.
2015-12-26T05:45:55Z jcowan: I use most of them only for standardization testing, though.
2015-12-26T05:48:06Z jcowan: The more general answer, though, is that different implementations provide different tradeoffs.  If you need speed enough to sacrifice almost everything else, use Stalin.  If you want a compact embeddable interpreter like Lua, use Chibi.  If you want a good fast native compiler on x86 or x86_64, Larceny is a good choice.  Chiicken has more active development than Gambit, but Gambit is a little more optimized, especially (IIRC) for
2015-12-26T05:48:06Z jcowan: floating point.
2015-12-26T05:48:38Z jcowan: If you want lots of library support and a graphical IDE, Racket is your friend.
2015-12-26T05:51:07Z Guest97128 quit (Ping timeout: 260 seconds)
2015-12-26T05:54:17Z Necrosporus: jcowan, isn't guile supposed to be embeddable like Lua?
2015-12-26T05:54:46Z jcowan: Yes, but it's much larger.  It would be less misleading to say that it is embeddable like Python.
2015-12-26T05:55:14Z jcowan: (I am speaking of Guile 2.x here.  I don't know much about Guile 1.x)
2015-12-26T05:56:28Z jcowan: Lua has an optional JIT, however, and Chibi does not have one yet.
2015-12-26T05:56:36Z Necrosporus: jcowan, have you used Tcl?
2015-12-26T05:56:43Z jcowan: Long ago and far away
2015-12-26T05:56:55Z wolfcore joined #scheme
2015-12-26T05:57:19Z wolfcore is now known as Guest73848
2015-12-26T05:57:52Z Necrosporus: jcowan, do you think that it could/should be viewed as a dialect of lisp?
2015-12-26T05:58:06Z Necrosporus: Lisp does not have to use (), right?
2015-12-26T05:58:15Z jcowan: *All* programming languages are dialects of Lisp!
2015-12-26T05:58:33Z Necrosporus: even fortran?
2015-12-26T05:58:47Z jcowan: But seriously, I don't think it's particularly Lispy.  It has some Lisp-like features, yes, but most languages do.
2015-12-26T05:58:50Z jcowan: Even Fortran.
2015-12-26T05:59:06Z jcowan: Lisp is a lens that can burn holes in reality
2015-12-26T05:59:27Z Regulator9 joined #scheme
2015-12-26T06:02:05Z Necrosporus: Are there lisp interpreters with multiline repl with syntax highlighting?
2015-12-26T06:02:19Z Necrosporus: including colored parens
2015-12-26T06:02:36Z Regulator_ quit (Ping timeout: 272 seconds)
2015-12-26T06:02:42Z jcowan: Emacs is your friend
2015-12-26T06:03:05Z cemerick quit (Ping timeout: 246 seconds)
2015-12-26T06:04:39Z jcowan: Anyway, it's after 0100 here, so I'm bailing out; my eyelids won't stay up.
2015-12-26T06:04:42Z jcowan quit (Quit: Leaving)
2015-12-26T06:08:42Z pjb: Necrosporus: because 1- I know r5rs, 2- r5rs (only 50 pages) is much smaller than r7rs.
2015-12-26T06:11:06Z Necrosporus: I know that emacs can do that, but I'd like something simpler, with default bindings adapted for modern keyboards (and practices), not ancient space cadet keyboards
2015-12-26T06:11:24Z Necrosporus: And more like repl
2015-12-26T06:16:09Z pjb: Necrosporus: you should read Lisp in Small Pieces   http://pagesperso-systeme.lip6.fr/Christian.Queinnec/WWW/LiSP.html  http://pagesperso-systeme.lip6.fr/Christian.Queinnec/Books/LiSP-2ndEdition-2006Dec11.tgz
2015-12-26T06:16:09Z rudybot: http://teensy.info/V109FE2ERI
2015-12-26T06:17:00Z Necrosporus: pjb, why?
2015-12-26T06:17:17Z pjb: Necrosporus: but writing a lisp compiler is rather easy: you basically just need to compile the special operators.  The rest of the language is just macros, and library functions.
2015-12-26T06:18:27Z pjb: Because LiSP teaches you who to write a lisp implementation, starting from an interpreter, and followed by 8 versions of a compiler. (A lisp-1, so scheme really).
2015-12-26T06:28:17Z Tbone139 joined #scheme
2015-12-26T06:39:08Z Guest73848 quit (Ping timeout: 246 seconds)
2015-12-26T06:45:21Z wolfcore joined #scheme
2015-12-26T06:45:45Z wolfcore is now known as Guest14236
2015-12-26T07:13:51Z Necrosporus: pjb, isn't it boring to learn how someone else done it?
2015-12-26T07:14:16Z Necrosporus: I think that it's much more fun to try do it yourself deliberately avoiding reading literature
2015-12-26T07:14:33Z Necrosporus: And only after you are done, read how serious people do it
2015-12-26T07:27:23Z wildlander quit (Quit: Saliendo)
2015-12-26T07:34:20Z corruptbehavior quit (Quit: Leaving)
2015-12-26T07:45:47Z AkashicLegend joined #scheme
2015-12-26T07:54:35Z vikraman quit (Quit: Bye!)
2015-12-26T07:55:10Z vikraman joined #scheme
2015-12-26T07:59:30Z alezost joined #scheme
2015-12-26T08:08:28Z aap_ is now known as aap
2015-12-26T08:29:45Z fantazo joined #scheme
2015-12-26T08:37:10Z lambda-11235 quit (Quit: Bye)
2015-12-26T08:39:46Z neoncontrails joined #scheme
2015-12-26T08:51:34Z Necrosporus quit (Ping timeout: 256 seconds)
2015-12-26T08:55:52Z Necrosporus joined #scheme
2015-12-26T09:10:27Z oleo_ quit (Remote host closed the connection)
2015-12-26T09:15:22Z oleo joined #scheme
2015-12-26T09:15:22Z oleo quit (Changing host)
2015-12-26T09:15:22Z oleo joined #scheme
2015-12-26T09:15:56Z Regulator_ joined #scheme
2015-12-26T09:18:56Z Regulator9 quit (Ping timeout: 272 seconds)
2015-12-26T09:34:08Z Regulator_ quit (Ping timeout: 272 seconds)
2015-12-26T09:36:16Z Regulator9 joined #scheme
2015-12-26T09:52:36Z fantazo quit (Quit: Verlassend)
2015-12-26T10:18:17Z alezost quit (Quit: I live in GuixSD <http://www.gnu.org/s/guix> and Emacs <http://www.gnu.org/s/emacs>)
2015-12-26T10:41:26Z Regulator_ joined #scheme
2015-12-26T10:41:54Z Regulator9 quit (Ping timeout: 272 seconds)
2015-12-26T10:46:34Z gravicappa joined #scheme
2015-12-26T10:48:26Z xwl joined #scheme
2015-12-26T10:58:07Z vydd joined #scheme
2015-12-26T11:13:51Z h0wl3vvd joined #scheme
2015-12-26T11:13:52Z h0wl3vvd: hello
2015-12-26T11:14:07Z h0wl3vvd: can somebody explain me hows scheme works ?
2015-12-26T11:16:33Z Necrosporus: h0wl3vvd, scheme works fine
2015-12-26T11:17:19Z h0wl3vvd: Necrosporus: im not asking for that
2015-12-26T11:18:37Z Necrosporus: h0wl3vvd, do you have any specific questions?
2015-12-26T11:18:46Z Necrosporus: You could read SICP for example
2015-12-26T11:18:51Z h0wl3vvd: Necrosporus: i mean VM
2015-12-26T11:19:12Z Necrosporus: It depends of implementation and there are a lot of them
2015-12-26T11:19:17Z h0wl3vvd: scheme can be interpreted or byte code can be compiled by JIT
2015-12-26T11:19:26Z h0wl3vvd: in example lets take guile or racket
2015-12-26T11:19:31Z h0wl3vvd: and i dont get it
2015-12-26T11:20:01Z Necrosporus: I'm not a right person to explain you that, but I'd look in their sites or channels
2015-12-26T11:20:09Z h0wl3vvd: Necrosporus: -.-
2015-12-26T11:20:14Z h0wl3vvd: so dont waste my time nerd
2015-12-26T11:25:20Z XTL: nice
2015-12-26T11:31:55Z neoncontrails quit (Ping timeout: 240 seconds)
2015-12-26T11:52:12Z hiroakip joined #scheme
2015-12-26T12:16:03Z ArneBab_ quit (Read error: Connection reset by peer)
2015-12-26T12:16:09Z ArneBab joined #scheme
2015-12-26T12:17:16Z Mokuso joined #scheme
2015-12-26T12:22:55Z AkashicLegend quit (Quit: maharaja)
2015-12-26T12:27:52Z Beluki joined #scheme
2015-12-26T12:28:51Z davexunit joined #scheme
2015-12-26T12:39:15Z Mokuso quit (Quit: EOF)
2015-12-26T12:51:30Z ggole joined #scheme
2015-12-26T12:59:59Z atomx joined #scheme
2015-12-26T13:11:50Z Regulator9 joined #scheme
2015-12-26T13:13:54Z Regulator_ quit (Ping timeout: 272 seconds)
2015-12-26T13:35:31Z atomx: h0wl3vvd: did you discover things about jit ?
2015-12-26T13:36:02Z atomx: h0wl3vvd: I told you.
2015-12-26T13:36:15Z atomx: first start with simple implementation for FPLs
2015-12-26T13:36:36Z h0wl3vvd: atomx: im dont
2015-12-26T13:36:41Z atomx: h0wl3vvd: after you know that you go and read jit papers and the code
2015-12-26T13:36:50Z h0wl3vvd: DAMN
2015-12-26T13:36:55Z atomx: h0wl3vvd: start by studing SKI logic
2015-12-26T13:36:55Z hiroakip quit (Ping timeout: 240 seconds)
2015-12-26T13:36:57Z h0wl3vvd: ill dont read any fucking jit code
2015-12-26T13:37:08Z atomx: ?
2015-12-26T13:37:09Z h0wl3vvd: what u fucking talking dude
2015-12-26T13:37:11Z h0wl3vvd: fuck off
2015-12-26T13:37:18Z h0wl3vvd: you stupid motherfucker
2015-12-26T13:37:20Z h0wl3vvd: damn...
2015-12-26T13:37:25Z C-Keen: h0wl3vvd: please.
2015-12-26T13:37:29Z h0wl3vvd: C-
2015-12-26T13:37:32Z h0wl3vvd: C-Keen:
2015-12-26T13:37:34Z atomx: not read jit code.
2015-12-26T13:37:36Z h0wl3vvd: but what he talking about
2015-12-26T13:37:39Z h0wl3vvd: omg...
2015-12-26T13:37:44Z h0wl3vvd left #scheme
2015-12-26T13:37:46Z C-Keen: h0wl3vvd: what are you talking about?
2015-12-26T13:37:47Z atomx: after you know SKI go and read the racket code that generates JIT
2015-12-26T13:38:09Z atomx: I answered nicely to h0
2015-12-26T13:38:21Z atomx: can you ban him ?
2015-12-26T13:38:24Z C-Keen: I didn't even understand his question
2015-12-26T13:38:27Z C-Keen: and no I cannot.
2015-12-26T13:38:37Z atomx: H0... asked about how JIT code works
2015-12-26T13:38:50Z atomx: I answered him
2015-12-26T13:39:04Z atomx: and he tells me ``you stupid motherfucker``
2015-12-26T13:39:10Z C-Keen: He wanted to know "how scheme works"
2015-12-26T13:39:14Z C-Keen: whatever that means
2015-12-26T13:39:16Z atomx: He asked the question on #racket.
2015-12-26T13:39:22Z C-Keen: I see
2015-12-26T13:39:42Z atomx: I answered him and he left the channel. I answered him here as well and he swears again
2015-12-26T13:39:56Z atomx: On #racket he wanted to know how JIT works
2015-12-26T13:40:31Z atomx: I told him first to start studing the implementation of FPLs, in particulat SKI logic
2015-12-26T13:40:42Z atomx: and he swears here and on #racket as well
2015-12-26T13:40:46Z C-Keen: He's got 99 problems but the JIT aint none
2015-12-26T13:42:00Z atomx: he asks complicated questions , much more than he understands
2015-12-26T13:42:57Z C-Keen: that may be a sign of trolling ;)
2015-12-26T13:43:56Z atomx: he appeared sometimes on #racket. not the 1st time
2015-12-26T13:44:29Z C-Keen: sorry I gtg, ttyl!
2015-12-26T13:55:01Z pierpa joined #scheme
2015-12-26T13:55:51Z ELLIOTTCABLE is now known as ec^
2015-12-26T14:08:14Z atomx quit (Remote host closed the connection)
2015-12-26T14:08:57Z sz0 quit (Quit: Bye.)
2015-12-26T14:09:24Z sz0 joined #scheme
2015-12-26T14:27:08Z Riastradh joined #scheme
2015-12-26T14:43:37Z xwl left #scheme
2015-12-26T14:49:39Z xwl joined #scheme
2015-12-26T14:59:48Z phax joined #scheme
2015-12-26T15:00:18Z jcowan joined #scheme
2015-12-26T15:07:52Z mumptai joined #scheme
2015-12-26T15:23:15Z Wojciech_K joined #scheme
2015-12-26T15:26:03Z phax quit (Quit: phax)
2015-12-26T15:27:05Z jcowan quit (Read error: Connection reset by peer)
2015-12-26T15:37:51Z jcowan joined #scheme
2015-12-26T15:45:51Z daviid` joined #scheme
2015-12-26T15:48:24Z gravicappa quit (Remote host closed the connection)
2015-12-26T15:55:17Z badkins joined #scheme
2015-12-26T16:04:08Z xwl quit (Remote host closed the connection)
2015-12-26T16:04:23Z xwl joined #scheme
2015-12-26T16:13:43Z phax joined #scheme
2015-12-26T16:14:40Z phax quit (Client Quit)
2015-12-26T16:29:14Z mumptai quit (Remote host closed the connection)
2015-12-26T16:32:03Z cemerick joined #scheme
2015-12-26T16:32:05Z mumptai joined #scheme
2015-12-26T16:41:05Z cemerick quit (Ping timeout: 260 seconds)
2015-12-26T16:43:23Z jyc quit (Ping timeout: 264 seconds)
2015-12-26T16:43:39Z GGMethos quit (Ping timeout: 255 seconds)
2015-12-26T16:45:10Z badkins quit (Remote host closed the connection)
2015-12-26T16:53:34Z jyc joined #scheme
2015-12-26T16:55:55Z badkins joined #scheme
2015-12-26T16:58:30Z Riastradh quit (Ping timeout: 245 seconds)
2015-12-26T16:58:39Z phax joined #scheme
2015-12-26T16:58:47Z phax quit (Remote host closed the connection)
2015-12-26T17:01:54Z badkins quit (Remote host closed the connection)
2015-12-26T17:09:05Z zbigniew quit (Ping timeout: 260 seconds)
2015-12-26T17:12:40Z GGMethos joined #scheme
2015-12-26T17:13:06Z badkins joined #scheme
2015-12-26T17:16:03Z zbigniew joined #scheme
2015-12-26T17:17:57Z lambda-11235 joined #scheme
2015-12-26T17:29:07Z alezost joined #scheme
2015-12-26T17:40:24Z emma quit (Ping timeout: 264 seconds)
2015-12-26T17:48:23Z sz0 quit (Quit: Bye.)
2015-12-26T17:49:02Z cdidd quit (Ping timeout: 276 seconds)
2015-12-26T17:49:27Z phax joined #scheme
2015-12-26T17:53:51Z vydd quit (Ping timeout: 255 seconds)
2015-12-26T18:03:43Z cdidd joined #scheme
2015-12-26T18:10:30Z ggole quit
2015-12-26T18:13:18Z badkins quit (Remote host closed the connection)
2015-12-26T18:16:37Z phax quit (Quit: phax)
2015-12-26T18:25:58Z wildlander joined #scheme
2015-12-26T18:27:50Z Regulator_ joined #scheme
2015-12-26T18:29:56Z Regulator9 quit (Ping timeout: 272 seconds)
2015-12-26T18:32:29Z badkins joined #scheme
2015-12-26T18:50:11Z vydd joined #scheme
2015-12-26T18:54:58Z badkins quit (Remote host closed the connection)
2015-12-26T18:57:17Z vydd quit (Ping timeout: 276 seconds)
2015-12-26T19:02:54Z mutbuerger joined #scheme
2015-12-26T19:03:30Z Regulator_ quit (Ping timeout: 272 seconds)
2015-12-26T19:04:00Z Regulator9 joined #scheme
2015-12-26T19:14:07Z gravicappa joined #scheme
2015-12-26T19:15:11Z xwl quit (Ping timeout: 264 seconds)
2015-12-26T19:20:35Z Steverman quit (Ping timeout: 264 seconds)
2015-12-26T19:34:15Z Wojciech_K quit (Read error: Connection reset by peer)
2015-12-26T19:39:34Z mmc joined #scheme
2015-12-26T19:40:24Z pjb: Necrosporus: of course, you have a good (pedagogical) point.  But there are sometimes complex concepts and techniques that you can still learn from books written by people having spent the time to discover them.  But you're right that this would motivate students to read more, if they had to solve the problems first.
2015-12-26T19:41:54Z pjb: Necrosporus: myself, I spent time trying to implement a BASIC in LSE at 14 yo, and hit a wall parsing expressions with those parentheses, since I hadn't grabbed the recursion concept (and knew nothing about grammars and parsers).  Of course, that motivated me to be very interested with compiler courses I took later :-)
2015-12-26T19:42:39Z pjb: (unfortunately, there was no internet available then).
2015-12-26T19:51:22Z emma joined #scheme
2015-12-26T19:51:22Z emma quit (Changing host)
2015-12-26T19:51:22Z emma joined #scheme
2015-12-26T19:53:14Z PinealGlandOptic quit (Ping timeout: 250 seconds)
2015-12-26T20:09:54Z nilg joined #scheme
2015-12-26T20:14:36Z Khisanth quit (Ping timeout: 264 seconds)
2015-12-26T20:31:56Z sz0 joined #scheme
2015-12-26T20:33:58Z fantazo joined #scheme
2015-12-26T20:42:18Z Khisanth joined #scheme
2015-12-26T20:47:35Z bogdanm quit (Ping timeout: 260 seconds)
2015-12-26T20:48:06Z profess quit (Ping timeout: 240 seconds)
2015-12-26T20:49:15Z gravicappa quit (Ping timeout: 240 seconds)
2015-12-26T20:50:04Z bogdanm joined #scheme
2015-12-26T20:50:28Z profess joined #scheme
2015-12-26T21:04:04Z badkins joined #scheme
2015-12-26T21:10:31Z badkins quit (Remote host closed the connection)
2015-12-26T21:17:17Z Riastradh joined #scheme
2015-12-26T21:22:53Z phax joined #scheme
2015-12-26T21:23:03Z phax quit (Client Quit)
2015-12-26T21:30:15Z \var quit (Ping timeout: 240 seconds)
2015-12-26T21:30:29Z oleo quit (Remote host closed the connection)
2015-12-26T21:31:22Z \var joined #scheme
2015-12-26T21:33:47Z oleo joined #scheme
2015-12-26T21:35:59Z sz0 quit (Quit: Bye.)
2015-12-26T21:41:52Z badkins joined #scheme
2015-12-26T21:42:47Z Necrosporus_ joined #scheme
2015-12-26T21:45:12Z badkins quit (Remote host closed the connection)
2015-12-26T21:46:12Z Necrosporus quit (Ping timeout: 256 seconds)
2015-12-26T21:48:10Z badkins joined #scheme
2015-12-26T21:50:07Z Necrosporus_ is now known as Necrosporus
2015-12-26T21:56:42Z Regulator_ joined #scheme
2015-12-26T21:57:02Z Regulator9 quit (Ping timeout: 272 seconds)
2015-12-26T22:07:52Z badkins quit (Remote host closed the connection)
2015-12-26T22:37:55Z vydd joined #scheme
2015-12-26T22:42:11Z badkins joined #scheme
2015-12-26T22:43:18Z vydd left #scheme
2015-12-26T22:53:22Z Regulator9 joined #scheme
2015-12-26T22:55:56Z Regulator_ quit (Ping timeout: 272 seconds)
2015-12-26T22:59:31Z Steverman joined #scheme
2015-12-26T23:27:11Z daviid` quit (Ping timeout: 260 seconds)
2015-12-26T23:39:14Z jao joined #scheme
2015-12-26T23:57:19Z badkins quit