IRC channel logs


back to list of logs

***daviid is now known as Guest98177
***Guest98177 is now known as daviid
<cmaloney>i'm reading through elm docs and now i want typed guile with adts
<cmaloney>this is not normal
<daviid>cmaloney: better read the land of lisp then ... :)
<daviid>CL can be fast, upto .3 C executin time ... our next step cmaloney, thanks to andy of course, is to have an AOT, then we may introduce declaration (by the way, I hope that when that comes, we will adopt the CL way, not the kawa way, but ... synctatically speaking, which may sound like a detail but ino is not ...
<akkad>fast CL is ugly :P
<daviid>not necessarily
<daviid>it all depends on your skill, no one said, no one ever said programming is a piece of cake ... it takes a life, 30, 40y to reaaaaaallllllllly become good, so be patient and learn, learn, and learn again ...
<happy_gnu[m]>So daviid i shouldn't be frustrated after 6 months?
<happy_gnu[m]>Is kinda hard to go from simple stuff to interesting :/
<daviid>happy_gnu[m]: no, keep quiet, and stay among us, there are quite good hackers here, and all are very nice people too, always ready to help ...
<cmaloney>what if you are on year 35 and still feel like an amateur? :'(
<happy_gnu[m]>And reading SICP is awesome but hard :(
<daviid>cmaloney: that, imo, is good
<daviid>because, it means youe are still ready to learn
<daviid>the enemy is when you start to believe 'you know', that's the dead end
<cmaloney>i dunno... you said CL was good. now your opinion is suspect. ;-)
<cmaloney>i'm teasing
<daviid>sorry, I don't get it. I said CL can be fast, but I sitched to guile a while ago (15y) ... and still am here
<daviid>guile is the future, it will be fast, then the benefit of scheme over CL will show ... we have goops too, which is why I picked up Guile, along with eith part of GNU and other reasons, but don't wna to tal about that right now
<daviid>happy_gnu[m]: keep going, reading, not just SICP, any lisp based stuff, read code, ask here, try to have a 'pet project' of your own ... and you will be fine
<happy_gnu[m]>daviid: thanks :) yeah I am also reading the land of lisp
<daviid>happy_gnu[m]: in a few years you'll become a good hacker, but that won't happen ina WE
<cmaloney>daviid: in my head we have different functional factions throwing gang signs (lambdas with the left hand = lisp, lambda with the right = guile)
<happy_gnu[m]>And it helped me to understand o little bit of a similar game on emacs
<cmaloney>it's a ridiculous thought but one that struck me as fummy
<cmaloney>funny even
<happy_gnu[m]>But I feel like there is too much to learn, Unix philosophy, shell, all types of shell :/, JavaScript, HTML, php, lisp, Haskell, Java, clojure
<happy_gnu[m]>It is overwhelming
<happy_gnu[m]>I try not to think about that and focus on lisp though
<adhoc>happy_gnu[m]: it sure can be, there are decades of culture and development in those things
<daviid>happy_gnu[m]: emacs can be a good start as well, any lisp based coding is a good source, then with time, of course, you'll recognise good from bad coding ... which a nice skill t have too of course ...
<adhoc>getting in early on the development cycle of alanguage helps a lot as you grow with it
<happy_gnu[m]>And then games and design inkscape, gimp, blender
<happy_gnu[m]>I feel bad I started so old
<happy_gnu[m]>I feel like I wasted a lot of time
<daviid>happy_gnu[m]: don't think that way! there is no 'good' age to start, in any domain by the way, just start ... and feel happy, so many people would like but don't start ... precisley because they beleive age is a 'problem', I don't agree
<daviid>what matter is desire, not age
<happy_gnu[m]>Yeah at least I am trying
<daviid>if you have the desire to progress then you1re good
<happy_gnu[m]>I closed my law office to become a programmer
<happy_gnu[m]>Discovering GNU/Linux was beautiful
<daviid>happy_gnu[m]: exactly, and I swear, if you are patient and stick with 'us', and guile (or lisp based s/w), then you will progress and succeed in writing something ...
<adhoc>weh had a nold timer join our radio club, age 74, mainly to find folkks to talk to about programming arduino and started coding in c,c++ and now python nad javascript
<happy_gnu[m]>Thanks daviid
<daviid>happy_gnu[m]: welcome!
<adhoc>had done basic decades ago, now spends about half his time working on projects
<adhoc>never too ld to lern to code
<happy_gnu[m]>Oh how cool adhoc
<adhoc>yeah has been interesting to field questions
<OrangeShark>happy_gnu[m]: I sort of feel like that sometimes too, I wish I started earlier.
<daviid>adhoc: yes, this is a well known medecine fact: the age is never an obstacle, the obstacle is the lack of desire ... there are people that learned at 80y old a new (speaking) language, quick as light speed, becaue they had to (and accepted 'they had to', converting the 'have to' in desire ...
<adhoc>time and energy to spend one it is the key thing
<djcb`>did anyone succeed in using `meson` for guile-related tasks (.go compilation, snarfing etc.)?
***cmaloney is now known as time
***time is now known as cmaloney
<amz3`>héllo #guile
<amz3`>what's up?
<amz3`>each time I play an RPG game, I dream of making one, I can't focus on the game itself, except wondering how everything is done
<amz3`>now I know for a fact, that if I started such a game I would not finish it
<amz3`>so I'd rather stop dreaming...
<amz3`>I've been fiddling around rust, I am wondering what Guile does provide that makes it better than rust platform for programming, any idea?
<happy_gnu[m]>amz3`: there are a lot of positive things in Guile
<happy_gnu[m]>amz3`: guile is part of the Lisp family
<happy_gnu[m]>This can help you a little
***Amynka is now known as EvilQueen
<amz3`>tx happy_gnu[m]
<happy_gnu[m]>amz3`: I don't have much technical knowledge to help you more but
<happy_gnu[m]>I can tell you learning guile is awesome
<happy_gnu[m]>amz3`: maybe you can read Structure and Interpretation of Computer Programs (SICP) and watch the lectures
***EvilQueen is now known as YouDontSay
<cmaloney>I can say that learning a little bit of Guile / Scheme has made learning other functional languages easier for me
<cmaloney>and now I understand some of the "weird syntax" for functional concepts that are being bolted on to other languages like Python
<amz3`>happy_gnu[m]: I know Guile, I am asking for other point of view on rust
<amz3`>I see rust makes a very good point about error handling
<amz3`>In guile, you are basically on your own
<amz3`>IMO, exception support is not good enough
<happy_gnu[m]>amz3`: then maybe is about what you prefer and what you feel more conformable with.
<amz3`>afaik you can't raise/throw an exception that is a GOOPS object
<amz3`>hence you can have a hierarchy of exceptions and handle them particularly
<amz3`>this ^ is a comparison to python way of handling errors
<amz3`>compared to rust, rust requires you to handle errors everywhere, see the .unwrap() method call and '?' add the end of expressions all are placeholders for actual good rust error handling
<amz3`>I am not sure what's the best approach to error handling exception/error codes (like C) or rust's thing
<amz3`>one thing I am sure, is that rust is more explicit about the places where you need to handle errors which is not the philosophy of dynamic languages where things are less explicit
<amz3`>by default
***YouDontSay is now known as Amynka
<amz3`>daviid: can you raise/throw an exception that is a goops object?
<amz3`>daviid: how do you handle errors in your program?
<amz3`>basicallly what's the schemey way of handling errors
<OrangeShark>amz3`: yeah, there is definitely different ways to handle errors in programming. There is error codes, exceptions, result/optional style values
<cmaloney>This is the same thing that I noticed with Elm and the Algebraic Data Types
<cmaloney>where it puts in error handling for unhandled case statements
<amz3`>OrangeShark: scheme do all those things :/
<OrangeShark>yup, you can do all of those
<amz3`>cmaloney: how does elm handle errors?
<cmaloney>It uses strict typing and complains a lot at compile time
<amz3`>that what rust does too, it leads to slower 'write then run' life cycle but when it runs you have more chance to have it right
<ijp>amz3: you can throw any object as an exception
<cmaloney>This is what prompted me to wonder (in channel) re: Typed Racket support for Guile
<OrangeShark>cmaloney: there is a typed version of guile
<OrangeShark>called Theme-D
<cmaloney>Wow, Google really doesn't know about it. :)
<amz3`>ijp: oh, nice! I should give it a chance
<cmaloney>Getting everything for the Street Fighter character "Guile" and his theme. ;)
<amz3`>cmaloney: look in the mailing list
<ijp>well, it does go with everything
<amz3`>ahah, ddg://guile+wiredtiger leads to a "Images > Sorry, no results here." but still gives the correct results below
<amz3`>happy_gnu[m]: what are you interested in? web? desktop apps? games? algorithms? data structures?
<amz3`>happy_gnu[m]: I am asking because you asked previously help to hack on something, but you did not tell what you are interested in
<amz3`>ijp: I think you implementation of fingertrees is unique, I can't find a similar datastructure in python or rust or javascript
<amz3`>that's strange because it works quiet well for representing text in text editors
<ijp>it is certainly not unique, it's just not as common outside functional languages
<amz3`>It will be nice to have some datastructure zoo coming with it implementing various other datastructures on top of it
<amz3`>I will add that to my todo list
<amz3`>cmaloney: did you have a look at guile-wiredtiger?
<happy_gnu[m]>amz3`: i am connected with Riot I can't pm
<happy_gnu[m]>Riot don't let me
<amz3`>happy_gnu[m]: what are you interested in?
<amz3`>happy_gnu[m]: maybe you like artificial intelligence?
<happy_gnu[m]>Well for now I am just starting to learn programming
<OrangeShark>amz3`: You need to add some images for guile wiredtiger so they can show up!
<amz3`>oh you are getting started programming, I did not know I was under the impression that guile yet another programming language you knew
<amz3`>OrangeShark: that's a good idea
<OrangeShark>like a logo
<happy_gnu[m]>I just know a little python and JavaScript but nothing much
<happy_gnu[m]>I read on github Open Source University and started doing a course called how to design data
<amz3`>happy_gnu[m]: what project did you already start in all those languages?
<happy_gnu[m]>But I felt like I wasn't learning
<amz3`>happy_gnu[m]: I don't know those
<happy_gnu[m]>So I read about the course and discovered that it was scheme
<amz3`>happy_gnu[m]: well reading or listenning doesn't feel like you know programming because you don't actualy write code but it helps to read & listen
<happy_gnu[m]>So I decided to Learn and started reading SICP and the little schemer
<amz3`>SICP is full of exercices
<amz3`>I know only 'reasoned schemer' book, but I guess it's a good teaching material
<OrangeShark>happy_gnu[m]: how to design data is the course using racket, isn't it?
<happy_gnu[m]>I've done simple projects a few websites and a lot of exercises
<happy_gnu[m]>Yes it is OrangeShark
<happy_gnu[m]>But they don't really teach scheme I felt like was doing the things but I wasn't understanding why
<happy_gnu[m]>That is why I also dropped Free Code Camp
<happy_gnu[m]>But SICP is awesome I understand why I do each thing
<happy_gnu[m]>And I feel like there is nothing I can't do or understand
<happy_gnu[m]>Of course I've got a lot to learn but the possibilities are infinite
<happy_gnu[m]>In python or JavaScript I always felt I was too stupid to write the that made "for" or "while"
<OrangeShark>happy_gnu[m]: wasn't sure which to use?
<happy_gnu[m]>No I meant
<happy_gnu[m]>I can write a "new-for" loop in scheme like the new-if of SICP
<happy_gnu[m]>But in JavaScript I can't write a new-if or a new-foc
<OrangeShark>yeah, basically how lisp allows you to easily extend the language. That is definitely one of the cool features of lisp
<amz3`>yes you can't really do that without macros
<amz3`>that said, javascripters successfully extended the language via things like babel
<OrangeShark>there is also sweet.js for macros
<amz3`>if only GNU Guile had a marketing departerment ;)
<amz3`>it would win the language war
<OrangeShark>so amz3` what have you been up to?
<happy_gnu[m]>Is so awesome
<happy_gnu[m]>I teached my brother in 10 minutes
<happy_gnu[m]>More that I learned with python in 1 month :/
<amz3`>OrangeShark: well... I was not doing guile stuff lately, I think I will do python/javascript freelance so I am kind of preparing a porfolio of some sort
<amz3`>I promised mwette to try libgit2 bindings generated with his helper
<amz3`>that's all!
<amz3`>OrangeShark: and you?
<OrangeShark>that binding generator looks promising :)
<OrangeShark>I have mostly been busy work, also reading some software books. I am hoping to get back to working on guile related projects now.
<amz3`>OrangeShark: what kind of book?
<OrangeShark>currently code complete, it a software engineering book on software construction
<amz3`>at work, we had a presentation about what do with legacy code, it was quiet interesting
<amz3`>I did not knew that in english it was called 'legacy code'
<amz3`>in french, we say "historical code" or "old code"
<OrangeShark>well legacy code might have different meaning to people
<OrangeShark>some people define it as "code with no tests"
<OrangeShark>there is a good book on legacy code called "Working Effectively with Legacy Code"
<amz3`>that's the book the presentation was based on
<amz3`>legacy code is rusty code for me, this includes code wihtout test
<amz3`>he also talked about tests pyramid
<amz3`>where basically, you have a lot of unit tests, the higher level the test is the less of them there is
<amz3`>so it makes a pyramid
<OrangeShark>yup, that is generally how it is
<amz3`>like for instance, he argued that there should never be a lot of selenium tests
<OrangeShark>higher level tests also tend to run longer
<OrangeShark>unit tests should run fast, because you want to keep running them as you develop your code
<cmaloney>amz3: No, what is that?