IRC channel logs

2015-06-25.log

back to list of logs

<davexunit>I see that there's an mkstemp! procedure to make a temporary file from a template string, but is there a procedure for making a temporary directory?
<davexunit>a-ha, I can just wrap the mkdtemp syscall
<paron_remote>hello *
<crocket>Do you guys know a URL of performance comparison between guile and racket?
<crocket>Ah, it seems racket is generally faster than guile.
<paron_remote>wingo wrote up http://wingolog.org/archives/2013/01/07/an-opinionated-guide-to-scheme-implementations at one point if you're interested in a less benchmark'y, more "use this for that" type breakdown
<crocket>yes
<crocket>I read it
<crocket>Performance is not important in most caes.
<crocket>cases
<crocket>Guile should be as fast as python 3.
<nalaginrut>morning guilers~
<crocket> https://en.wikipedia.org/wiki/Guile_(Street_Fighter)
<nalaginrut>yeah, my favorite character when I was a pupil
<crocket>What do you guys use guile for?
<crocket>Where does guile serve well?
<nalaginrut>crocket: almost everything for me ;-)
<nalaginrut>it depends on you
<crocket>nalaginrut, Can you show me your guile programs?
<nalaginrut>crocket: http://web-artanis.com/
<crocket>nalaginrut, Where do you obtain guile modules?
<nalaginrut>crocket: you may use guildhall
<crocket>nalaginrut, Do you know any guildhall repository that holds a lot of packages?
<nalaginrut>let me see
<nalaginrut>crocket: http://shift-reset.com/doro/ I think
<crocket>A few dozens
<crocket>And, it doesn't have your web framework.
<nalaginrut>well, there're not many packages so far, contributions needed
<nalaginrut>crocket: Artanis may not use guildhall as package manager in the future, it has its own, since many plugins will be based on its interface for web service/app
<nalaginrut>so it's fine if it's not in guildhall
<crocket>Artanis doesn't have a package manager, yet
<nalaginrut>it will ;-
<nalaginrut>)
<crocket>Is it actively developed?
<nalaginrut>but only for itself, maybe not a generic one
<nalaginrut>crocket: yes, it's under heavy development
<nalaginrut>I have many changes haven't committed
<crocket>Are there other guile package repositories than guix and doro?
<nalaginrut>for now, I'm working on MVC, then the server core, the third step is the package manager
<crocket>Nowadays, FRP is considered superior to MVC.
<crocket>You should look into functional reactive programming(FRP).
<crocket>Also, if you plan to implement package manager, you want to learn from guix.
<nalaginrut>crocket: I'll take look at it ;-)
<nalaginrut>crocket: GNU dmd is another manager
<nalaginrut>but I never tried it
<crocket>What is dmd?
<nalaginrut> https://www.gnu.org/software/dmd/
<nalaginrut>crocket: does FRP handle DB well?
<crocket>nalaginrut, I don't know, but it's well suited for desktop and web GUI.
<nalaginrut>alright, maybe should be added as another module
<crocket>nalaginrut, Read https://gist.github.com/staltz/868e7e9bc2a7b8c1f754 for the introduction to FRP.
<nalaginrut>thanks ;-)
<zacts>FRP = functional reactive programming?
<zacts>oh yeah
<zacts>I see it above
<zacts>cool
<zacts>I found this tutorial for that a while back, that was cool
<zacts>let's see if I can find it
<zacts>hm... here's one that looks interesting https://gist.github.com/staltz/868e7e9bc2a7b8c1f754
<zacts>^ but the one I was thinking of was a bit different
<zacts>ah sorry
<zacts>crocket: just linked that one
<zacts>:-)
<zacts>carry on
<zacts>although, I do know of an academic PDF about various programming paradigms / techniques (although personally I don't like the term paradigm for programming anymore)
<zacts>the PDF also has a nice section on FRP iirc
<crocket>How do we handle DBs functionally?
<crocket>Datomic is a functional database, but it is not free.
<zacts> https://www.info.ucl.ac.be/~pvr/VanRoyChapter.pdf
<zacts>^ here is the PDF
<zacts>fwiw
<zacts>crocket: hm...
<zacts>I think I remember seeing something about DB + functional
<zacts>actually, heh
<zacts>let's see if I can remember
<zacts>also http://www.cs.cmu.edu/~rwh/theses/okasaki.pdf
<zacts>^ I've heard this is a cool book, but I need to read it eventually
<zacts>- Title: Purely Functional Data Structures by Chris Okaski
<zacts>crocket: perhaps you could borrow ideas from the Haskell community on DB + functional programming
<zacts>although
<zacts>crocket: are talking about implementing a DB from scratch in a functional way?
<crocket>okasaki
<zacts>crocket: thanks
<zacts>typo
<crocket>zacts, That would be ideal.
<crocket>functional DB bindings may be difficult to implement.
<zacts>although, are you concerned more about interfacing with an existing SQL database (like sqlite3?)
<mark_weaver>that Okasaki book is really excellent.
<mark_weaver>(I have a copy in dead-tree form)
<zacts>mark_weaver: I hope to try to obtain a physical paper version of it when I can afford it, but I just got the Little Prover on pre-order
<mark_weaver>nice!
<zacts>crocket: perhaps ask the Clojure / Haskell / Erlang communities for their solutions to the Functional Programming + DB problem
<zacts>?
<zacts>:-)
<crocket>ok
<zacts>that's my suggestion
<mark_weaver>I should get The Little Prover also :)
<zacts>crocket: I think they've likely had some interesting solutions for this, especially on the Haskell side of things
<zacts>crocket: http://referaat.cs.utwente.nl/conference/15/paper/7281/building-a-functional-relational-database.pdf
<zacts>^ as linked on #haskell
<wleslie>oooh
<crocket>zacts, Yes, I saw it
<zacts>neat
<ArneBab_>nalaginrut: FRP is what davexunit uses in Sly
<crocket>Wow
<crocket> http://elm-lang.org/guide/reactivity
<crocket> http://elm-lang.org/guide/reactivity is a good explanation of FRP.
<crocket>Is there any game written with Sly?
<crocket>I want to see.
<nalaginrut>ArneBab_: sly in html5 now?!
<ArneBab_>nalaginrut: no, the method FRP.
<nalaginrut>for Artanis, the need is to handle DB well, and generate views automatically, I want to use it in a IOT project
<nalaginrut>alas~so I have to face high concurrency server core soon... ;-D
<ArneBab_>Sly example https://media.dthompson.us/u/davexunit/m/guile-2d-frp-demo-b13d/
<crocket>Does IOT mean internet of things?
<nalaginrut>seems FRP is more related to web front end
<nalaginrut>crocket: yes
<ArneBab_> http://dthompson.us/guile-2d-is-now-named-sly.html
<crocket>nalaginrut, Some people say that if you make postgresql append-only and use timestamps, you would get immutable databases easily.
<nalaginrut>crocket: oh!
<crocket>Datomic is an immutable database.
<crocket>Datomic does similar things...
<nalaginrut>for now, I just expect the relational mapping is stateless, but DB immutable is cool
<crocket>What is a stateless relational mapping?
<nalaginrut>crocket: it's hard to explain at present, maybe wait it in the future
<nalaginrut>;-)
<crocket>Sly README is a good learning material for FRP.
<nalaginrut>I'm afrade immutable DB is not so fast, no?
<crocket>nalaginrut, depends
<crocket>If you only append and read, it should be fast.
<nalaginrut>crocket: oh, here's a paper if you interested in, <<out of the tarpit>>, maybe you've already know
<crocket>If you need ACID guarantees, it is going to get slow....
<crocket>If you append only, you won't need ACID guarantees much.
<nalaginrut>well, DB read/write could be separated
<nalaginrut>but the performance depends on scenario...
<ArneBab_>nalaginrut: FRP sounds like someone took continuations and built library functions around one usecase of them to make it easier to handle.
<crocket>ArneBab_, Your sly example video's resolution is too low.
<ArneBab_>it’s not mine
<nalaginrut>ArneBab_: nice! it's better if the continuations could be sent to another node
<nalaginrut>that's what I really like
<ArneBab_>nalaginrut: I guess you’d have to serialize them somehow for that
<ArneBab_>for example sending around the starting data for the function which provides the continuation
<nalaginrut>yes, I've ever taken a look at serializable-continuation, I haven't found an elegant way to implement it
<nalaginrut>and I believe there's limitations to stop me to implement generic serializable-continuations, I mean something maybe impossible to serialize
<crocket>What is the relationship between FRP and continuation?
<nalaginrut>dunno
<nalaginrut>crocket: Functional Reactive Programming, Continued
<nalaginrut>well, but it's AFRP
<nalaginrut>IMO, things related to continuations has to be asynchronous...
<crocket>Do people use Make to build guile packages?
<nalaginrut>crocket: I do
<crocket>Make is not really well suited for guile.
<nalaginrut>well, it's fine for me, but something like "gake" could be better
<ArneBab_>I do
<nalaginrut>just like rake for ruby
<nalaginrut>dunno, but personally, I think Make is enough
<ArneBab_>nalaginrut: it doesn’t look like FRP stays as simple as it promises…
<crocket>For clojure, it could be named 'cake'.
<nalaginrut>ArneBab_: oh...everything once be related to continuations becomes complicated...
<crocket>If you compare Make with clojure's leiningen, Make looks primitive.
<crocket>leiningen profiles are simple and specifies dependencies.
<nalaginrut>crocket: well, the interesting point is that, sometime people complain it's too primitive, sometimes they think it's too complicated ;-P
<crocket>primitive and complicated
<ArneBab_>After playing with cmake, SCons, waf and a few others, I prefer plain make with autotools where needed.
<crocket>The thing is that they are not for guile.
<crocket>You chose wrong tools
<nalaginrut>personally, it's fine for me if it works properly, so I can put my hack power to other more complicated things
<ArneBab_>I did not use Guile back then :)
<ArneBab_>then it’s make - or directly your distros package manager
<ArneBab_>crocket: if you need something advanced, use guix. It ties neatly into make.
<ArneBab_>every package manager works nicely with projects using make
<crocket>I still think guile needs its own centralized package repository.
<ArneBab_>crocket: guildhall
<crocket>It serves as a reference.
<ArneBab_>crocket: did you already install guildhall?
<crocket>not yet
<crocket>It seems guildhall needs improvements
<ArneBab_>then install it, before talking more about what guile needs
<nalaginrut>crocket: try it, and works like gems or pip
<ArneBab_>check what it has, before thinking what it might not have
<ArneBab_>nalaginrut: continuations are just the supercharged version of “we can stop anywhere and go on from there”
<crocket>I'll get back on guile
<ArneBab_>nalaginrut: but I guess for serializability, you’d need to provide a way to obtain all values.
<nalaginrut>ArneBab_: yes, but it's easy to understand its principle, and could be very complicated to use it, there're so many ways to play it
<nalaginrut>well, that's why I love it
<ArneBab_>nalaginrut: something like a function which simply emits values from a list
<ArneBab_>(I also consider continuations as complicated - with power… ☺)
<nalaginrut>sometimes I love it, sometimes I fear
<ArneBab_>nalaginrut: then you’d have functions which provide continuations, and serializing them would simply mean running them till they end and putting all values into a list which is then sent to another node as starting value for a simple procedure which returns values from the list.
<ArneBab_>love and fear — fits it well ☺
<nalaginrut>ArneBab_: you mean just dump it as bytecode? I
<nalaginrut>ArneBab_: you mean just dump it as bytecode? I've tried such black magic and works, but wingo said it's evil ;-(
<ArneBab_>I mean using a very limited form which can only return data at every step
<nalaginrut>well, maybe this way is not proper for serious project ,but toy
<nalaginrut>I have to find better way
<ArneBab_>but dumping bytecode sounds exciting - stuff which should never make its way into production h)
<ArneBab_>:)
<nalaginrut>there could be many problems in this way ;-D
<nalaginrut>when you load it, something will be flushed
<nalaginrut>I mean overwritten
<nalaginrut>it's not safe
<ArneBab_>yes :)
<nalaginrut>oh, I made a mistake, AFRP stands for Arrowized FRP, and it's synchronous. But I do see Asnychronous FRP somewhere...
<nalaginrut>nowadays these abbreviations are terrible
<crocket>I thought about relational mapping.
<crocket>How would you make it stateful?
<crocket>It's not easy to introduce states in relational mappings.
<crocket>nalaginrut, ^^
<crocket>As long as you use pure data structures to describe relational mappings, there will not be surprises.
<crocket>just like clojure data structures.
<nalaginrut>crocket: well, you know Scheme is not pure FP, right?
<crocket>nalaginrut, Neither is clojure.
<nalaginrut>crocket: find a good way/design to avoid impure things in RM is what I'm working on, so I think it's not contradict against what you said
<crocket>What is RM?
<nalaginrut>relational mapping
<crocket>yes
<crocket>data structural relational mapping.
<crocket>What an awkward name
<nalaginrut>this name is confusing, since data structure could be Object
<nalaginrut>and back to ORM
<crocket>Just map your database to pure data structures.
<nalaginrut>I want to avoid OOP
<crocket>Pure data structure that do not have associated functions
<crocket>Clojure has pure data structures.
<nalaginrut>just call it FPRM is enough
<crocket>And, so does guile
<crocket>Does it?
<nalaginrut>I call it FPRM in Artanis
<crocket>ok
<crocket>Just segregate data manipulating functions from data structures mapped to database tables.
<nalaginrut>something like that, but handle relations could be complicated
<nalaginrut>I'm still working
<crocket>I think you should implement relational mapping as a third party library outside Artanis.
<crocket>It is a general purpose functionality.
<crocket>And, you market your relational mapping library with Artanis.
<nalaginrut>for very complicated DB operation, I prepared SQL-mapping to let users handle SQL directly with something convenient to preprocess the SQL string
<nalaginrut>for example, to avoid SQL-injection
<crocket>Mosquitos inject SQL into your program.
<crocket>Malaria SQL.
<mdln>hehe
<nalaginrut>IMO, use SQL directly is the best way to handle DB, relational mapping is just for someone lazy
<crocket>I think it is fine
<crocket>nalaginrut, I think you should optimize for simplicity instead of ease.
<crocket>To achieve simplicity, pull things apart. For example, pull data apart from functions.
<crocket>If you mix data with functions, you get objects.
<nalaginrut>crocket: I have use case for Artanis now, so I have to meet the need and save development time ASAP
<nalaginrut>yes, I confess all these things make it sound complex
***michel_mno_afk is now known as michel_mno
<crocket>Does relational mapping make things simple?
<crocket>This is what you should ask.
<nalaginrut>crocket: you can say it's Objects, closures + msg passing to fetch proper methods are actually half-baked OOP
<nalaginrut>I don't want to eliminate all OOP clues as possible, I just want to drop the heavy OO system
<crocket>I can't imagine what you describe.
<crocket>At least, you better separate functions from data so that you can manipulate data anywhere.
<nalaginrut>crocket: I think it's separated, at least I want to, the table mapping contains methods anyway
<nalaginrut>if it's still not so elegant, I could prepare an new abstract level... (well, it'll grow to be a monster)
<crocket>abstraction falls apart if you mix things.
<nalaginrut>well, hope I can do better
<ArneBab_>SRFI-119 is FINAL! http://srfi.schemers.org/srfi-119/srfi-119.html
*ArneBab_ is happy
<nalaginrut>ArneBab_: congrats!
<ArneBab_>thank you!
<ArneBab_>the example in the abstract now includes a function call in parens to show that the intention is not getting rid of parens completely.
<ArneBab_>* n : factorial (- n 1)
<nalaginrut>people always said "there're too many parens", now they have to find another reason to hate it
<ArneBab_>
<ArneBab_>they could have already used SRFI-110 to avoid the parens, SRFI-119 is just a simpler syntax to achieve that. Less workarounds.
<civodul>Hello Guilers!
<nalaginrut>heya
<amz3>héllo :)
<wleslie>hi!
<dsmith-work>Morning Greetings, Guilers
<wleslie>morning dsmith-work! happy Friday!
<wleslie>well, I'm sending a Friday your way. I guess it will be a few hours for you, low bandwidth conditions.
<dsmith-work>wleslie: Yes, quite a few hours. It's Thursday morning here.
<dsmith-work>But a preemtive Friday is always welcome
<dsmith-work>s/preemtive/preemptive/
<mark_weaver>ArneBab_: congrats on finalizing SRFI-119 !
<ArneBab_>mark_weaver: thank you!
<ArneBab_>now onward to finishing py2guile… :)
<mark_weaver>:)
<ArneBab_>I finished the (hopefully) final proofreading, just need to type it
<ArneBab_>mark_weaver: would you like to check it after I finished fixing the stuff I found?
<ArneBab_>(or rather: read it and note what seems odd ☺)
<wleslie>py2guile? is it a tutorial?
<mark_weaver>ArneBab_: I'll try to find the time, but I'm very heavily overloaded right now.
<ArneBab_>mark_weaver: thank you!
<ArneBab_>wleslie: it documents my findings when going from Python to Guile
<wleslie>cool
<ArneBab_>sadly the site is down right now - along with all my other sites (they got cracked and are offline until I cleaned them and found and fixed the vulnerability)
<civodul>ArneBab_: http://draketo.de/proj/wisp/srfi-reference.scm is 403
<wleslie>I remember when you wrapped some mig bindings in a cpython extension and Markus and Neil were suggesting to do the same with guile
<ArneBab_>civodul: see above…
<ArneBab_>wleslie: I had forgotten that :)
<ArneBab_>wleslie: Back then the parens still scared me away from Scheme :)
<wleslie>crazy times, 64 bit was just starting to appear on the desktop
<civodul>what would be neat is some sort of a MiG as a Scheme macro
<ArneBab_>civodul: the reference implementation is included as tarball in the SRFI.
<civodul>ok
<ArneBab_>(Michael Sperber asked for that and I was happy to provide it)
<davexunit>what's MiG?
<ArneBab_>Mach Interface Generator
<davexunit>oh
<davexunit>for a microkernel
<ArneBab_>creates the messages to interface with a Hurd system
<wleslie>it described the hird of interfaces representing depth
<ArneBab_>
<civodul>wleslie: why the past tense? it still does :-)
<civodul>(it's also used on evil OSX)
<wleslie>of course it does (:
<wleslie>I haven't run pure GNU in quite a few years though, so it feels like both the past and the future for me, but not the present
<ArneBab_>I ran a GNU Hurd system in qemu a few months ago, and the translators worked.
<ArneBab_>it became a bit more convenient
*paron_remote does some web hacking in guile today
<paron_remote>also hello *!
<davexunit>(for-each greet! %all-users)
<civodul>#<unspecified>
<davexunit>this REPL is a bit slow
<civodul>in reality the unspecified value does not get printed at the REPL
<davexunit>so this REPL is broken, too!
<davexunit>;)
<paron_remote>davexunit: I wonder if this should go upstream in guile http://dthompson.us/rendering-html-with-sxml-and-gnu-guile.html
<davexunit>paron_remote: maybe, with some fixes.
<davexunit>all that escape code stuff isn't actually needed.
<davexunit>my mistake.
<davexunit>just use utf-8!
<paron_remote>:)
<paron_remote>davexunit: well except <>" and friends maybe? or does sxml handle that already
<paron_remote>huhm, didn't realize multiple value return cascaded back through functions
<paron_remote>that's pretty neat.
<amz3>sxml with skribe reader becomes useable, you can wrinte (p [Héllo (bold [guiler])! How are you doing]) instead of you-know-what ;)
***michel_mno is now known as michel_mno_afk
<amz3>basically with the bracket [] syntax spaces around elemnets are included, where as in scheme regular syntax you have to specify them like (p "Héllo " (bold "guiler") "! How are you doing")
<amz3>then if skribe is used for writting xml or html, one can get away with (@ (attribute vlaue)) syntax using keywords
<amz3>well, enough talking ;)
<daviid>davexunit: fyi, your blog page "Rendering HTML..." does not 'respect' my bworswer width, which irritates me :)
<daviid>gnome doc also force the user to enlarge browser windows, very annoying imo
<daviid>nalaginrut: artanis documentation also forced me to change my browser window size, for info
<nalaginrut>davexunit: you mean "info artanis" ?
<nalaginrut>it's generated by org-mode, so I'm not sure if I have chance to tweak something
<daviid>nalaginrut: no, i went to the website and browsed the doc from here
<daviid>maybe, but texinfo to html does the right job [as an example], so our doc is fine, g-wrap, guile-gnome[clutter] as well...
<nalaginrut>daviid: did you read the html5 version or regular html version?
<daviid>imo it is very important, i almost immediately stop0 reading anything that ctakes too much 'space' and does not adapt itself to my widow size ... my 2c
<nalaginrut>the texinfo is generated by org-mode, then handled by texinfo
<daviid>nalaginrut: don't know, just opened what was there using epiphany, a couple of months ao
<daviid>anyway just try what ever you have...
<daviid>juszt wanted to make a small comment rather off topic but... done. my 2c
<nalaginrut>daviid: it's fine for me here
<nalaginrut>daviid: you're not using 16:10, right?
<daviid>nalaginrut: not even the home page of artanis does the right job
<nalaginrut>daviid: it appears fine in epiphany for me, maybe you're using a old CRT?
<daviid>using epiphany, -geometry 689x874+914+58, i only see half of it
<daviid>epiphany 3.16.1-1
<daviid>i have to enlarge the widow to: -geometry 1031x859+572+58 to see the page
<daviid>properly
<nalaginrut>I only have epiphany 3.4.2, there's no -geometry here, I may try it tomorrow in a newer debian
<daviid>nalaginrut: i did xwininfo for you to understand ...
<daviid>i just use epiphany
<paron_remote>hm
<paron_remote>I miss that all exceptions have error messages that go with them in python
<nalaginrut>but I have to say, when I was discussing with my designer about web layout, I ask how to make a responsive page to adapt different screen, my designer told me forget about it, nowadays we just support wide screen. ;-P
<paron_remote>it seems the two options I have out of the box are throw or error, and the latter does provide an error message but not a specific identifier, so I'm inclined to use throw
<nalaginrut>I'm so sorry ;-P
<paron_remote>but I feel like I'd like to have both of those features
<nalaginrut>but yes, it's possible to adapt various screen automatically, in CSS
<nalaginrut>I just don't have time for it...
<daviid>nalaginrut: i can post a screencopy of the main page and it is the colored html5 doc which is 'wrong'.
<nalaginrut>daviid: in principle, one may add support to adapt various screens with @media tag, it's time consuming work for web frontend developers to tweak it
<amz3>I don't like fixed width layout too
<amz3>you can use flexbox
<amz3>it's simple
<daviid>nalaginrut: try this one, play with the width of your bworser, the font size ... http://www.altosw.be/kise/ ... that's what users want, imo
<nalaginrut>amz3: yes, me too, I just don't have time for that, I expect adaptive page too
<nalaginrut>daviid: does kise generate texinfo ?
<nalaginrut>I need to export texinfo too
<daviid>i mention this because the side effect is terrible: if the front webpage is not even 'good' how will be the s/w ?
<daviid>nalaginrut: no, it is the Kisê's project web pages. Kisê's doc is written in texinfo
<daviid>anyway, get to get back to work
<daviid>nalaginrut: you should fix it, imo, both yopur artanis web pages and the html5 doc
<nalaginrut>I think it's not wise to rewrite whole doc into another format, the problem is actually easy, just add one more @media section to http://www.gnu.org/software/artanis/css/manual.css
<nalaginrut>daviid: I'll put it in my TODO, but it's not soon, is it fine for your screen to read the PDF version?
<daviid>did not say you should rewrite the all doc in another format :) dammned!
<daviid>do as you wish nalaginrut i stop reading webpages that are not 'good' and desist even to try their associated s/w
<davexunit>paron_remote: yes, those essential syntactic characters must be escaped, yeah.
<nalaginrut>daviid: please don't push me now, I have to make the software itself better and stable, then polishing it
<davexunit>paron_remote: but none of the other stuff.
<paron_remote>davexunit: gotcha, thanks
<davexunit>daviid: are you complaining about the fixed width layout? I just used the pelican default theme.
<davexunit>I'm going to switch to my own static site generator in 3 years or so...
<paron_remote>davexunit: hm, wait is that true?
<paron_remote>scheme@(guile-user)> (with-output-to-string (lambda () (sxml->xml (templatize "Hello <dorks>!" `((p "oh my"))))))
<paron_remote>$14 = "<html><head><title>Hello &lt;dorks&gt;!</title></head><body><p>oh my</p></body></html>"
<paron_remote>looks like sxml->xml escapes those automatically
<nalaginrut>if I put too much time/hack power on CSS, then you have no chance to use Artanis too, since it'll be alpha for long long time
<davexunit>paron_remote: yes, sxml->xml does that, but it doesn't do other things.
<daviid>davexunit: yes, it is terrible
<davexunit>because (equal? 'html 'xml) => #f
<davexunit>daviid: it's not that bad.
<davexunit>sorry that it doesn't appeal to your particular taste in aesthetics, I guess.
<nalaginrut>daviid: anyway, I promise to fix it, someday
<daviid>davexunit: not taste, it's not that, it is that i can not read it [unless enlarging my bworser window to almost the double of its original size], which imp0acts on what i am doing next to the browser ... anyway, just commenting
<nalaginrut>I guess it's because daviid is not using wide screen display
<davexunit>I have never used a browser on which I cannot read my own web site.
<davexunit>anyway, yeah it's not that pretty. I'm not a designer.
<nalaginrut>I'm not designer too, and my designer suggest me not put much time on layout at present
<daviid>davexunit: you want me to send a screencopy? you'll understand
<davexunit>nah that's okay
<daviid>:)
<nalaginrut>daviid: artanis.info is adaptive IMO, could you use it temperately?
<nalaginrut>I'm sorry it's my duty ;-)
<daviid>nalaginrut: realx, i made these comments to help you and dave understand that for a user [which i pretended beeing in this case] having to scroll horizontally to read all sentences is just not praticle and probably, as for me, lead to the user abandonning the site and the s/w again my 2c. i really have other things to do :)
<amz3>I agree with daviid that having a working website is important, but I have me, myself and I... :)
<amz3>a feedback
<amz3>nalaginrut: is it posible to use artanis without a database
<amz3>it would be nice to have, since putting together the packages for getting the database to work is difficult
<amz3>my immediate need is a web framework, but i build my own database (please down't laught)
<amz3>that is all :)
<amz3>the work you've done on sql query is impressive :)
<amz3>I just could not make it work because of the database dependency
<amz3>also the global configuration file, is some trouble too
<nalaginrut>daviid: yes, I understand, I'm kind of perfectionist in certain area, I spent much time to tweak the color and fonts of html5 doc, I confess it's not so beautiful since I'm not a designer, but I want to say I'm not a careless guy. I just realized that the software itself is the key part to focus on, I hope it can get rid of alpha soon. And this work need much much time/hackpower. I want it perfect when it's born, but I realized that I have to take
<nalaginrut>it easy after several through-night hacking. Anyway, you have my word, it'll be fixed in the future. ;-)
<nalaginrut>amz3: yes, you can work without DB, do it like this (run #:use-db? #f)
<amz3>it did not work last time I tried
<amz3>hm
<amz3>I'll check and come to you
<amz3>nalaginrut: where is the code of the website I can fix it now
<davexunit>nalaginrut: I find that artanis uses too much mutable state.
<amz3>I looked at the code, one can use something else that position: relative. it's tradeoff because menu will go up, but...
<nalaginrut>amz3: https://github.com/NalaGinrut/artanis/blob/gh-pages/css/manual.css
<amz3>ok
<amz3>I made a small script to turn skribillo's skribe syntax to sxml syntax http://pamrel.lu/fa261/
<nalaginrut>and for the main site: https://github.com/NalaGinrut/artanis/blob/gh-pages/css/common.css
<amz3>it doesn't support keywords I mean element attributes
<amz3>nalaginrut: I'll find the correct files :)
<nalaginrut>davexunit: mutation is not evil, depends on scenario ;-)
<nalaginrut>davexunit: and please consider that the server core is green thread, so there'll be less lock operations
<nalaginrut>different concurrent model makes different situation
<amz3>oops! You only need guile-reader, since I bundle the code of ludo I added the copyright http://pamrel.lu/4bb58/
<nalaginrut>amz3: thanks ;-P !
<davexunit>just get rid of those nasty escape codes I added
<amz3>in a few hours you will have a green pink website :D
<amz3>ok
<nalaginrut>well, it's appreciated if someone can make main site of Artanis to use a guile based static page generator
<nalaginrut>it's using Chicken Scheme's instead at present
<nalaginrut>which sounds very not convincing...
<amz3>dave has one
<nalaginrut>that's nice
<nalaginrut>I have to go to bed
<nalaginrut>night guilers~
<amz3>night
<nalaginrut>amz3: BTW, it works for me without DB, just (run) could work too
<amz3>you still need the modules
<amz3>IIRC
<nalaginrut>amz3: the modules can't be dropped IMO, the current modules are integrated tightly for Artanis, since all the things are kind of *low-level languages* to be generated by the latest abstract level
<nalaginrut>you can write webapp/service with current APIs, but you just need to run CLI to generate them automatically
<nalaginrut>I want to save users time as possible, since I'm one of the users too
<nalaginrut>have to sleep, bye
<amz3>go to sleep then :)
<paron_remote>hm
<paron_remote>so in GOOPS, it's generally okay to do (foo #:getter get-foo) rather than (foo #:getter classname-foo) because via generic methods foo is ~namespaced via the defmethod?
<paron_remote>is that so?
<paron_remote>I guess that makes sense
<paron_remote>though I wonder what convention is?
<daviid>paron_remote: (foo #:getter get-foo) is perfectly ok yes. there is no convention 'per se', and both #:getter #:setter get-foo set-foo as well as #:accessor foo [or !foo, as I prefer, for practicle reasons [binding slot values to vars in let forms ...]] are fine and you can even 'maintain' both approaches
<zacts>lo guilers
<dsmith-work>Yeah, I really hate it when I have to scroll a browser window horizontally too. Argh!
<davexunit>what tiny screens are you people using?
<paron_remote>daviid: thanks!
<ArneBab_>davexunit: my smallest screen is just about 30cm wide
<daviid>paron_remote: wc!
<paron_remote>sorry to ask again, I don't know why I can't ever find this on my own
<paron_remote>what's the name of the function that gives you a numeric range as a list?
<paron_remote>this time I'll save it to my notes.org file ;p
<davexunit>paron_remote: iota
<paron_remote>davexunit: ah right :)
<ijp>it is the *obvious* name for this procedure
<ijp>for 5 points, tell me where it came from
<dsmith-work>ijp: I don't care one iota where it came from
<dsmith-work>I can remember iota, it's shell "seq" that I alwasy forget.
<paron_remote>I'm not informed enough for it to be obvious I guess :)
<paron_remote>hm interesting
<paron_remote>(iota 4 2.5 -2) from the manual doesn't work here
<paron_remote>oh
<paron_remote>srfi-1 of course
<ijp>paron_remote: the earmuffs were intended to indicate sarcasm
<ijp>IIRC, the name is taken from APL
<paron_remote>ijp: oh okay, I thought they were for emphasis, so it was extra obvious and I was just being dumb :)
<paron_remote>which is always a possibility
<zacts>isn't seek mainly a clojure abstraction
<zacts>oops
<zacts>seq
<zacts>I tired clojure a bit once
<zacts>the seq, I didn't fully like it