<shangul>
Okay this means matrix and LISP have a close relation!
dddddd has quit [Remote host closed the connection]
drastik_ has joined #lisp
drastik has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
willdye has left #lisp [#lisp]
kmurphy4 has quit [Quit: kmurphy4]
fikka has quit [Ping timeout: 264 seconds]
fisxoj has joined #lisp
gigetoo has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
fikka has joined #lisp
kmurphy4 has joined #lisp
drastik_ has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 245 seconds]
shangul has quit [Remote host closed the connection]
drastik_ has joined #lisp
fikka has joined #lisp
mange has joined #lisp
shangul has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
shangul has quit [Remote host closed the connection]
beach has quit [Ping timeout: 256 seconds]
zachk has quit [Quit: Leaving]
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
Pixel_Outlaw has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Intensity has quit [Ping timeout: 260 seconds]
elfmacs has joined #lisp
quazimodo has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
milanj_ has quit [Quit: This computer has gone to sleep]
fikka has quit [Ping timeout: 264 seconds]
manicennui has joined #lisp
manicennui is now known as arubin
arubin has quit [Client Quit]
arubin has joined #lisp
Intensity has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
quazimodo has joined #lisp
eli_oat has joined #lisp
fikka has joined #lisp
daniel-s has quit [Quit: Konversation terminated!]
daniel-s has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
ealfonso has quit [Read error: Connection reset by peer]
EvW1 has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
Kundry_W_ has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
akkad has joined #lisp
fikka has joined #lisp
ioa has quit [Read error: Connection reset by peer]
thekolb has quit [Read error: Connection reset by peer]
ioa has joined #lisp
mrottenkolber has joined #lisp
mrottenkolber is now known as Guest3664
fikka has quit [Ping timeout: 256 seconds]
robotoad has quit [Quit: robotoad]
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Guest23311 has quit [Remote host closed the connection]
Guest23311 has joined #lisp
akkad has left #lisp ["Using Circe, the loveliest of all IRC clients"]
fikka has joined #lisp
karlosz has quit [Ping timeout: 245 seconds]
fikka has quit [Ping timeout: 256 seconds]
red-dot has joined #lisp
karlosz has joined #lisp
robotoad has joined #lisp
fikka has joined #lisp
Cymew has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fikka has quit [Ping timeout: 240 seconds]
Cymew has quit [Ping timeout: 240 seconds]
Oladon has joined #lisp
dented42 has joined #lisp
fikka has joined #lisp
AetherWind has joined #lisp
Jesin has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
mange has quit [Remote host closed the connection]
kozy has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
kmurphy4 has quit [Quit: kmurphy4]
fisxoj has quit [Quit: fisxoj]
pierpa has quit [Quit: Page closed]
dented42 has joined #lisp
dented42 has quit [Read error: Connection reset by peer]
dented42_ has joined #lisp
fikka has joined #lisp
eli_oat has quit [Quit: Leaving.]
subroot has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
dented42_ has quit [Ping timeout: 264 seconds]
ealfonso has joined #lisp
<ealfonso>
I heard that hunchentoot sessions are not really secure... "Hunchentoot makes some reasonable effort to prevent eavesdroppers from hijacking sessions (see below), but this should not be considered really secure. Don't store sensitive data in sessions and rely solely on the session mechanism as a safeguard against malicious users who want to get at this data!" is there an easy way to make them secure?
fikka has joined #lisp
shka_ has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
Kundry_Wag has joined #lisp
red-dot has joined #lisp
<pillton>
Aren't all session mechanisms insecure in some way or another?
fikka has joined #lisp
Kundry_Wag has quit [Ping timeout: 264 seconds]
vtomole has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
dented42 has joined #lisp
skapata has quit [Remote host closed the connection]
subroot has quit [Read error: Connection reset by peer]
fikka has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
Pixel_Outlaw has quit [Quit: Leaving]
iAmDecim has joined #lisp
slyrus1 has joined #lisp
schoppenhauer has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
schoppenhauer has joined #lisp
mange has joined #lisp
dented42_ has joined #lisp
dented42 has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 268 seconds]
doesthiswork has quit [Quit: Leaving.]
beach has joined #lisp
sebastien_ has quit [Ping timeout: 245 seconds]
<beach>
Good morning everyone!
<vtomole>
Morning!
Bike has quit [Quit: Lost terminal]
fikka has joined #lisp
slyrus1 has quit [Quit: slyrus1]
<ealfonso>
this has probably been discussed before. but... will lisp ever become mainstream?
fikka has quit [Ping timeout: 260 seconds]
<beach>
ealfonso: Not the way the world (industry and academia) is structured today.
<beach>
ealfonso: The good thing is that it doesn't matter to us whether it is or not.
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<pillton>
Probably not, mainly because communities write language run-times that don't compose.
iAmDecim has quit [Read error: Connection reset by peer]
iAmDecim has joined #lisp
iAmDecim has quit [Read error: Connection reset by peer]
iAmDecim has joined #lisp
red-dot has joined #lisp
Oladon has quit [Quit: Leaving.]
itruslove has joined #lisp
eminhi has quit [Quit: leaving]
iAmDecim has quit [Read error: Connection reset by peer]
iAmDecim has joined #lisp
giraffe has joined #lisp
giraffe is now known as Guest28040
on_ion has quit [Quit: WeeChat 1.9.1]
<ealfonso>
when I start a repl in slime, how I switch to a package and load some sexps in that package? I've tried (swank:set-package "...") (swank-repl::in-package "..."), but it doesn't seem to work the first time
<mathZ>
How about (in-package :Foo) ?
Kundry_Wag has joined #lisp
<ealfonso>
mathZ I get "var is unbound" for a defvar'd var in package A after (in-package "A")
<ealfonso>
the 2nd time it seems to work
<ealfonso>
also, how is it possible that I'm getting a "function is undefined" for a function I declared as an (:import-from package function) ?
Kundry_Wag has quit [Ping timeout: 260 seconds]
fraya has joined #lisp
<beach>
It probably wasn't defined in `package'.
<beach>
ealfonso: You don't import and export functions in Common Lisp, just symbols.
<beach>
ealfonso: How about you show some code.
<ealfonso>
beach 1. you're right, I forgot the (in-package ...) at the top of the file
fikka has joined #lisp
<ealfonso>
beach I know, it just happens that the symbol is of a function
bjorkintosh has quit [Quit: Leaving]
<beach>
ealfonso: I always put (cl:in-package ...) on top of files, because you never know what the current package is when you load or compile them.
flamebeard has joined #lisp
<theemacsshibe[m]>
are there any matrix(.org) bindings for common lisp?
<ealfonso>
yes, I forgot to do that
<ealfonso>
this is the sexp I'm using to load my project on a new repl. the "start" and "make-config" functions are defined in one of my packages: (progn (load "my-project.asd") (ql:quickload "my-project") (in-package "my-project") (start (make-config :port 4242)))
<theemacsshibe[m]>
now it's not the thing with numbers in it
fikka has quit [Ping timeout: 248 seconds]
<theemacsshibe[m]>
it's the thing that lets normies like me use IRC with slightly more features
<beach>
ealfonso: You should probably not LOAD the ASDF file, but instead make sure ASDF finds it on your system.
<ealfonso>
the first time, I get COMMON-LISP-USER:make-config is not defined
<ealfonso>
the second time it works... I'm wondering if there's a way for it to work the first time
<ealfonso>
beach I feel that even if I did that, the first time the my-package:my-symbol symbols would still be interpreted as being in COMMON-LISP-USER at first in the slime repl
<ealfonso>
but I will definitely try that
<beach>
ealfonso: When that entire form is read, you are still in the cl-user package.
<beach>
ealfonso: so any symbol without a package prefix is going to be interned in the cl-user package, including make-config.
<beach>
<beach>
ealfonso: Since there is no such function, you get the error.
<ealfonso>
beach yeah. but if I prefix those symbols with my project, I think I get a read error since the package hasn't been loaded
<beach>
ealfonso: Plus, you can't really give it a package prefix, because that package does not exist when the form is read either.
<beach>
Correct.
vtomole has quit [Ping timeout: 260 seconds]
<ealfonso>
so I guess have to live with manually running the form twice. or running two different forms
<beach>
Well, there are kludges around it.
<beach>
Instead of (make-config ...) you can do (funcall (find-symbol "MAKE-CONFIG" "MY-PROJECT") ...)
<beach>
Same with START I guess.
crimsontr has joined #lisp
crimsontr has quit [Client Quit]
daniel-s has quit [Remote host closed the connection]
<ealfonso>
theemacsshibe[m] (sorry I have no idea what that is)
<ealfonso>
beach thanks... yeah
arubin has quit [Quit: Connection closed for inactivity]
EvW has joined #lisp
fikka has joined #lisp
kamog has quit [Quit: ERC (IRC client for Emacs 26.1)]
Folkol_ has joined #lisp
<ealfonso>
beach thanks, that did do what I wanted
<beach>
Sure, no problem.
<ealfonso>
beach it was annoying to have to wait at the repl for one sexp to finish loading only to enter another one
<beach>
I understand.
fikka has quit [Ping timeout: 276 seconds]
light2yellow has quit [Quit: light2yellow]
Cymew has joined #lisp
kuribas has joined #lisp
<kuribas>
Hi, I installed sbcl in linux. Where can I find the full documentation?
<beach>
kuribas: If you are new to Common Lisp, you probably want to start with the Common Lisp HyperSpec.
mathZ has quit [Remote host closed the connection]
<kuribas>
lol "I basically do not have a very high opinion of many of the decisions that were made in Common Lisp."
<beach>
Sounds like an RMS quotation.
<kuribas>
yeah
<beach>
You can safely ignore his opinion about Common Lisp.
Kundry_Wag has quit [Ping timeout: 260 seconds]
<phoe>
yep, except he didn't make elisp much better or useful
<beach>
I admire RMS, but he is not always right.
<phoe>
perhaps done the contrary at times
<kuribas>
phoe: exactly
<shrdlu68>
Keywords are his biggest grievance.
<phoe>
shrdlu68: he fixed that by making every single symbol a keyword
<phoe>
like, they're all in one single package now
Cymew has joined #lisp
<kuribas>
he is very stubborn in his view, but has been a big force in the free software movement.
<phoe>
keyword not in the CL sense of meaning, obviously; they're not constant in elisp.
<kuribas>
And he is (sadly) right in many ways.
<kuribas>
Especially the gradual erosion of privacy.
<beach>
kuribas: Also, at the time, he complained that Common Lisp was (still is) "huge", but since then, other languages have become even bigger.
<phoe>
kuribas: many of the choices made in CL were not made because they were good at that moment, but because they were the best at that moment
<phoe>
the best choice ain't necessarily good
smurfrobot has quit [Ping timeout: 256 seconds]
thodg has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
<kuribas>
PL design is constantly evolving.
<beach>
Not much.
<phoe>
kuribas: often by reinventing the wheels known in the 70s and 80s
<beach>
It seems to be mostly about re-inventing the flat tire.
<kuribas>
beach: I disagree
<kuribas>
there's a lot of progress in type theory
on_ion has joined #lisp
<beach>
kuribas: Fine. But that's off topic, so let's move to Common Lisp instead.
<phoe>
or #lispcafe since that's designed for offtopic things
<kuribas>
fair enough
<xificurC>
beach: really not much? No new multi-threaded GC algorithms? Stack allocation strategies? Optimization techniques?
nowhere_man has joined #lisp
<xificurC>
if it's not clear I'm asking this seriously, I don't follow these topics
<beach>
xificurC: That's strictly speaking not programming-language design, but implementation techniques. There is a lot of work in those domains.
<kuribas>
also logic programming, constraint logic, etc...
<xificurC>
beach: ah ok, I started to worry :)
Smokitch has joined #lisp
<xificurC>
new PL design - colorforth? That's off topic too though
<beach>
kuribas: What are you planning to do with Common Lisp? Just learning for fun, or do you have some projects in mind?
<kuribas>
beach: a job :)
<kuribas>
It's a large data-engine used for processing information comming from power plants.
<beach>
Nice.
<kuribas>
I am not expecting anything in common lisp to be new or surprising...
<kuribas>
but you never know
<beach>
That's basically true, unless you count its unique features like CLOS.
<kuribas>
I have seen CLOS in scheme
<xificurC>
new =/= better
<beach>
But if you stick to the subset that many other languages have, then it doesn't have many surprises.
<kuribas>
I like working in parenthesised languages
<kuribas>
especially with paredit
schjetne has quit [Remote host closed the connection]
schjetne has joined #lisp
schjetne has quit [Remote host closed the connection]
iAmDecim` has quit [Ping timeout: 255 seconds]
shka_ has quit [Ping timeout: 256 seconds]
scymtym has joined #lisp
dddddd has joined #lisp
milanj_ has joined #lisp
nickenchuggets has quit [Read error: Connection reset by peer]
pillton has quit [Remote host closed the connection]
mflem has quit [Read error: Connection reset by peer]
shka_ has joined #lisp
shka_ has quit [Ping timeout: 268 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
troydm has quit [Ping timeout: 256 seconds]
pdv has joined #lisp
makomo has quit [Ping timeout: 265 seconds]
Naergon has quit [Remote host closed the connection]
thodg has quit [Read error: Connection reset by peer]
<beach>
kuribas: So is there a CLOS-like system in the Scheme standard these days? I haven't been following the evolution of the Scheme standard for some time.
<jackdaniel>
beach: there is tiny-CLOS developed in Xerox by Gregor Kiczales, it is part of many scheme implementations
<jackdaniel>
racket built on top of that library called swindle (which is a tiny-CLOS superset)
LooneyTunes has joined #lisp
<jackdaniel>
tiny-CLOS has its MOP (it is a subset of Common Lisp's CLOS of course)
<beach>
Thanks. Not quite what I was asking, though.
<jackdaniel>
uhm
<mange>
I'm pretty sure there's nothing CLOS-like in the Scheme standard. I haven't looked at it for a while, but I think I would remember that.
MoziM has quit [Ping timeout: 276 seconds]
ealfonso has quit [Ping timeout: 276 seconds]
MoziM has joined #lisp
markoong has joined #lisp
<beach>
mange: Thanks.
<jackdaniel>
given the context these pointers were relevant though, because kuribas was talking about de-facto state of scheme ecosystem
nowhere_man has quit [Read error: Connection reset by peer]
<jackdaniel>
just as we claim that CL may be used with threads (though they are absent in the standard)
nowhere_man has joined #lisp
<shrdlu68>
beach: I have an off-topic question.
krwq has quit [Remote host closed the connection]
<beach>
shrdlu68: What's that?
<shrdlu68>
Is it correct to say that languages are not inherently "slow" or "fast"?
<beach>
Pretty much. It's a characteristic of the implementation. However...
<beach>
Some languages make it very hard to implement efficiently.
<shrdlu68>
Would python be one of those?
<beach>
I suspect so, but I am not up to date with respect to Python.
<beach>
For example, if you can add a slot to an instance at run-time, then essentially a slot lookup must always go through a hash table to check whether the slot exists.
<shrdlu68>
I see.
<jdz>
It's amazing what can be done actually, JavaScript and V8 is a prime example.
mange has quit [Ping timeout: 268 seconds]
<beach>
But then, there are compilation techniques that make the (usually correct) assumption that instances are basically class-based.
<beach>
jdz: Yes, and the Self people proved that prototype-based languages can be compiled efficiently.
heisig has joined #lisp
<beach>
shrdlu68: So the Common Lisp creators carefully avoided mechanism that were not sufficiently investigated at the time. These days, we could probably push the envelope a bit more if we wanted to.
vaporatorius has quit [Ping timeout: 256 seconds]
<shrdlu68>
Huh, I never thought of implementation techniques influencing language design.
<beach>
Oh, definitely. Or else, you very likely get a crap language.
<beach>
... which can be observed, I guess.
<beach>
TCL comes to mind.
<xificurC>
it's a question of what the goal is though, right. If you don't care about speed you don't have to think about whether the implementation will have a chance to compile into something fast.
<xificurC>
TCL was never meant to be a general purpose language AFAIK, just a glue like shells
<beach>
xificurC: Right. That's how I characterize "scripting languages" when I talk to industry. They are languages that are basically designed to be slow, sometimes because the creator knew nothing about language implementation.
<beach>
xificurC: So here is my favorite typical scenario: An application is developed using a static language such as C++ "for speed". Then some configuration or scripting capabilities are needed, so they add a slow implementation of a dynamic language, like TCL. Then the advanced users can only program using that language, so there is now a lot of code that is slow, for a combined slow application.
<on_ion>
i think of it like textual config file formats became more complex and turned into scripting langs
troydm has joined #lisp
<beach>
Yes, that happens too.
<beach>
And that's even worse, because then no real thought was put into the design of the language.
<on_ion>
they are more like effects than causes perhaps
Folkol_ has quit [Ping timeout: 276 seconds]
<p_l>
also languages that get build up without any proper parsing
<p_l>
(using s-expressions cheats around it by pretty much removing the need to write a parser)
<xificurC>
beach: of course misusing the language will cost you. If you write a bash script that launches a program and does some pre/post-processing you haven't done much harm. If you write the whole thing in bash you might have
<p_l>
depends on what the bash program does
<p_l>
(also, bash ranks pretty high when compared to "random arse language somebody hacked up for their application")
<xificurC>
UNIX is based on having many small C programs, which are often glued together with a shell script
<xificurC>
p_l: second
<xificurC>
I wonder what was using a lisp machine like
Smokitch has quit [Quit: Leaving.]
troydm has quit [Ping timeout: 240 seconds]
smurfrobot has joined #lisp
<xificurC>
beach: how much are you aiming for speed with SICL? Do you want to be competitive with SBCL?
nowhere_man has quit [Read error: Connection reset by peer]
nowhereman_ has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<p_l>
xificurC: you'd write your own functions and call them directly
<p_l>
Genera at some point added more "interface" in the form of Command Processor (which survives in CLIM Listener)
<p_l>
Plus of course quickly hacking up GUI apps
thodg has joined #lisp
<p_l>
Don't know much on TI Explorer systems, but Genera had a sort-of quick UI creator
<xificurC>
p_l: write your own functions and call them directly doesn't sound much different than bash
<p_l>
except you don't have to work through abtraction of pipes etc.
light2yellow has joined #lisp
<xificurC>
I'm just saying the sentence didn't really explain the difference
<kuribas>
shrdlu68: sbcl is about as fast as ghc (haskell), which is quite impressive.
<shrdlu68>
xificurC: As I understand, there were no interrupt-style system calls. It was all like one large CL system.
<p_l>
older lisp machines would be like booting into full-screen REPL with basic windowing system
<p_l>
(Some LOGO systems were a bit similar)
<kuribas>
Didn't they invent the GUI as well?
<p_l>
not invent, no
<p_l>
early lisp machines had very simple GUI - you had the basics that were afaik taken from older MIT PDP-10 TV system (reflected in the package name "TV")
<p_l>
Over time the situation changed
<p_l>
but remember that early lisp machines (CONS) were I think mid-70s, CADR was I think late 70s? got commercialized in first few years of 1980s
varjag has joined #lisp
<kuribas>
they had garbage collection built in
wigust- has quit [Ping timeout: 245 seconds]
<p_l>
if you run SBCL directly on bare metal (nyef experimented with it) you'd have essentially the same case for GC
troydm has joined #lisp
<p_l>
what LispMachines had extra was support for directly typed memory as well as things like forwarding pointers and advanced (comparatively) MMU
andrei-n has joined #lisp
ealfonso has joined #lisp
<p_l>
there were microcode assists on 3600 for GC, but overall it was less "GC is built into hw" and more "hardware is built for high-level language including hw-level typing"
Smokitch has joined #lisp
ealfonso has quit [Client Quit]
hhdave has joined #lisp
<kuribas>
this is mostly irrelevant today, as special purpose cpu's don't have the speed advantage.
<kuribas>
especially considering the popularity of Python, which performs quite poorly.
troydm has quit [Ping timeout: 245 seconds]
<beach>
xificurC: I am definitely aiming for speed. But I am more concerned about safety and debugging, so there might be situations where I can't compete. For example, SBCL trusts the programmer to supply correct DYNAMIC-EXTENT declarations. I don't think I want to do that.
Kundry_Wag has joined #lisp
<shka>
beach: so what will dynamic-extent even do?
Guest3664 is now known as kolb
smurfrobot has joined #lisp
_cosmonaut_ has joined #lisp
<beach>
shka: Possibly not much. Perhaps I will attempt to prove it correct only if it is explicitly given. But I haven't made up my mind.
rstandy has joined #lisp
Folkol_ has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
pagnol has joined #lisp
smurfrobot has quit [Remote host closed the connection]
thodg has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
sz0 has joined #lisp
EvW has quit [Ping timeout: 265 seconds]
Folkol_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
smurfrobot has quit [Remote host closed the connection]
dmiles has quit [Read error: Connection reset by peer]
orivej has quit [Ping timeout: 264 seconds]
thodg has joined #lisp
smurfrobot has joined #lisp
skeuomorf has quit [Ping timeout: 245 seconds]
Kundry_Wag has joined #lisp
_cosmonaut_ has quit [Quit: Leaving.]
_cosmonaut_ has joined #lisp
Kaz has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
m00natic has joined #lisp
EvW1 has joined #lisp
lumm has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<kuribas>
you give up a large part of safety when programming in a dynamic language
<jdz>
What safety is that?
markoong has quit [Quit: Konversation terminated!]
<jdz>
In the presence of random bit flips in memory I trust my run-time type checks more than the static ones.
milanj_ has quit [Quit: This computer has gone to sleep]
<kuribas>
I never got random bit flips...
<jdz>
Haha, a bold claim.
<kuribas>
and they might flip the tag as well...
<jdz>
Yes, and that's where the type checks come in.
<jdz>
Along with other type checks like the range of integers.
varjag has quit [Ping timeout: 264 seconds]
<jdz>
Google DRAM errors in the wild.
<shka>
EEC memory is here for a reason
<jdz>
Not even talking about Rowhammer.
<jdz>
shka: I personally don't know anybody with ECC ram in their laptop.
<kuribas>
a type error due to human error is much, much more likely
<beach>
kuribas: The kind of safety I was referring to was more about de-allocating live objects, not de-allocating dead ones, de-referencing pointers to dead objects, etc.
<jdz>
kuribas: Human logic error is even more likely.
red-dot has joined #lisp
<kuribas>
how are you going to check the type if the tag is corrupted?
<jdz>
What I personally would like is all the statically compiled binaries not throwing away all the type information done at compile time.
smurfrobot has joined #lisp
varjag has joined #lisp
lumm has quit [Quit: lumm]
lumm_ has joined #lisp
<jdz>
kuribas: If a function expects a number, and gets a cons cell, the type check will fail, and an error will be signalled.
lumm_ is now known as lumm
<beach>
kuribas: A tag would be corrupted only if the implementation is buggy. I would fix that problem by fixing the bug.
<kuribas>
jdz: in haskell you can add type information with Data.Typeable
<kuribas>
beach: you are talking about random bit flips. They would affect the tag as well.
LooneyTunes has quit [Ping timeout: 245 seconds]
<shka>
kuribas: fix your hardware
<beach>
kuribas: I was talking about no such thing.
<kuribas>
right, jdz was
<jdz>
kuribas: So now you're talking about delayed (dynamic) type checking, right?
<kuribas>
jdz: yes
<jdz>
So which part of "safety" are we losing when we're programming in a dynamic language?
Folkol_ has joined #lisp
<kuribas>
jdz: the assurance the program doesn't crash with a type error.
thinkpad has quit [Quit: lawl]
<beach>
kuribas: That's not quite true.
<jdz>
kuribas: so how does dynamic type checking help here?
smurfrobot has quit [Ping timeout: 268 seconds]
<beach>
kuribas: In a typical static programming language, you can't define a type that is "any integer except 0", so you get crashes when you divide by 0.
<xificurC>
I think he's saying x :: Int -> Int won't allow (x "foo") to be compiled
<kuribas>
beach: yes, division is not total
<kuribas>
xificurC: yes
<jdz>
kuribas: We definitely have that in CL.
smurfrobot has joined #lisp
<kuribas>
jdz: does CL have type inference?
<jdz>
Of course.
<beach>
kuribas: Either way, the additional type safety offered by static programming languages comes at a price. There are certain programs you can not express that way, and I myself believe that there is a price to pay in terms of development time.
<shka>
kuribas: yes
<shka>
static type safety is overrated imho
<beach>
kuribas: The Common Lisp language does not specify it, but good implementations definitely do it. In particular SBCL.
dmiles has joined #lisp
lumm_ has joined #lisp
<kuribas>
beach: I think otherwise, there is nothing that you cannot express in a static programming language with a sufficiently expressive type system. I find the development time shorter, because I get immediate feedback in my IDE.
<kuribas>
beach: ah cool
<beach>
kuribas: Good for you.
lumm has quit [Ping timeout: 240 seconds]
lumm_ is now known as lumm
<jdz>
Anyway, I'm programming in dynamic programming language and am not giving up any safety.
<kuribas>
jdz: I don't know about CL, but I programmed in Python, and getting crashes and weird error messages is quite common.
<beach>
kuribas: A good Common Lisp implementation should not "crash" unless you lie to the compiler.
<jdz>
Interesting. So why are you discussing this here if you have not done any programming in CL?
smurfrobot has quit [Ping timeout: 268 seconds]
<kuribas>
I did only scheme and CL, which aren't really safe.
<kuribas>
emacs lisp
<beach>
kuribas: I use SBCL daily, and I never see any crashes.
<beach>
kuribas: I never lie to the compiler.
<kuribas>
beach: does it tell you when there is a mismatch?
<xificurC>
I think you need to agree on what *crash* means
<jackdaniel>
languages are usually safe, it's programs written in them what may crash ;-)
<beach>
kuribas: Sure, either at compile time or at run time.
<kuribas>
anyway, this is offtopic...
<beach>
Indeed.
<shrdlu68>
(safety 100%)
<xificurC>
(defun x (y) (+ 2 y)) (x "foo") <- kuribas is talking about these crashes, which won't compile in e.g. haskell
<kuribas>
I'll be in lispcafe if you like to discuss this :)
thinkpad has joined #lisp
<kuribas>
xificurC: yeah
thodg has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
<dxtr>
So is there a way of converting dates in the format "Fri May 04 18:54:24 +0000 2009" to ISO8601?
azimut has quit [Ping timeout: 240 seconds]
smurfrobot has quit [Remote host closed the connection]
dented42 has joined #lisp
azimut has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
Smokitch has quit [Quit: Leaving.]
thodg has joined #lisp
lumm_ has joined #lisp
Folkol_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<jackdaniel>
dxtr: local-time has some parsing functions and functions to print dates in different formats
<jackdaniel>
(it is a library)
lumm has quit [Ping timeout: 264 seconds]
lumm_ is now known as lumm
Smokitch has joined #lisp
milanj_ has joined #lisp
EvW1 has quit [Ping timeout: 276 seconds]
thodg has quit [Read error: Connection reset by peer]
<dxtr>
jackdaniel: Yeah I ended up using a combination of cl-date-time-parser and local-time
jmercouris has joined #lisp
<jmercouris>
Xach: I have a brief question about skippy, can you pass a list of "make-image-data" into :image-data for "make-image"?
<jmercouris>
I'm trying to render many squares at once instead of a single square per "frame" of the gif
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
smurfrobot has joined #lisp
red-dot has joined #lisp
lumm has quit [Ping timeout: 245 seconds]
rstandy has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
TCZ has joined #lisp
AetherWind has quit [Quit: Leaving]
lumm has joined #lisp
edgar-rft has quit [Quit: edgar-rft]
malice has joined #lisp
Kaz` has joined #lisp
dmh has quit [Quit: Connection closed for inactivity]
lumm has quit [Read error: Connection reset by peer]
thodg has joined #lisp
Kaz has quit [Ping timeout: 264 seconds]
Kevslinger has quit [Quit: Connection closed for inactivity]
lumm has joined #lisp
Folkol_ has joined #lisp
sz0 has quit [Quit: Connection closed for inactivity]
<kuribas>
beach: you think the best way to learn CL is just the hyperspec?
Kevslinger has joined #lisp
<jmercouris>
kuribas: I doubt it
<jmercouris>
I can't imagine how the hyperspec could engage anyone to read it cover to cover
dented42 has joined #lisp
sunset_NOVA has joined #lisp
lumm has quit [Ping timeout: 260 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
Smokitch has quit [Quit: Leaving.]
<shrdlu68>
For beginners, Graham's "Ansi Common Lisp" might be a better entry point.
Folkol_ has quit [Ping timeout: 260 seconds]
Smokitch has joined #lisp
<shrdlu68>
I know it's not popular here, being a pre-standard work, but I thoroughly enjoyed reading CLTL, and I've seen others echo the same sentiment here.
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<kuribas>
jmercouris: yeah, it seems rather dry, and filled with minute details
Folkol_ has joined #lisp
<shrdlu68>
It's an excellent reference once you're comfortable with the language, though.
<jmercouris>
Yeah, it would be like suggesting somebody read a dictionary to learn english
<kuribas>
I did learn python by reading the spec...
smurfrobot has quit [Remote host closed the connection]
<jmercouris>
If it works for you, what can I say :D
<Xof>
there's a python specification?
<kuribas>
the python spec is rather small though
thodg has quit [Read error: Connection reset by peer]
<kuribas>
python language reference rather
<jmercouris>
Xof: Of course there is! The only implementation :D
<kuribas>
jmercouris: which one, CPyton, PyPy, Cyton?
<kuribas>
which are all subtly different :)
<shrdlu68>
...CLPython
<jackdaniel>
I don't know why internal CMU/SBCL compiler architecture comes over and over again
<kuribas>
is there a good text in dead tree format?
Arcaelyx has quit [Ping timeout: 276 seconds]
<kuribas>
hmm "Paradigms of Artificial Intelligence Programming"
<kuribas>
sounds interesting
<p_l>
kuribas: there's no such thing as python spec, afaik :)
<p_l>
you have the mess of special cases known as CPython, and a bunch of projects that try to run the same stuff
EvW has joined #lisp
heisig has quit [Quit: Leaving]
<LdBeth>
The Python compiler was included in CMUCL’s source tree
smurfrobot has joined #lisp
TCZ has quit [Quit: Leaving]
random-nick has joined #lisp
msmith has quit [Quit: Leaving.]
fraya_ has joined #lisp
smurfrobot has quit [Remote host closed the connection]
fraya has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 260 seconds]
light2yellow has quit [Ping timeout: 260 seconds]
light2yellow has joined #lisp
<xificurC>
kuribas: I know PCL (practical common lisp), LoL (Land of Lisp), another LOL (let over lambda), On Lisp, Lisp in Small Pieces, PAIP you mentioned, AMOP (the Art of the MetaObject Protocol). Surely there's more. I started with PCL which was recommended to me, I think here in IRC. I also enjoyed LoL. The others are probably not written as a guide to
<xificurC>
CL
scymtym has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
<LdBeth>
For me it’s more fun to learn the history
orivej has quit [Ping timeout: 264 seconds]
Kundry_Wag has quit [Ping timeout: 256 seconds]
kuribas has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
smurfrobot has joined #lisp
fikka has joined #lisp
smurfrobot has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 256 seconds]
kuribas has joined #lisp
<kuribas>
is "Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp" a good book?
<shka>
clearly, this makes him excelent book author
mindCrime has joined #lisp
<beach>
kuribas: Most people here would probably recommend PCL for someone in your situation.
<shka>
or Land Of Lisp
<kuribas>
isn't there a reference which is a bit more friendly than hyperspec?
<shka>
i like Common Lisp The Language second edition for that
<beach>
kuribas: I am unaware of a reference other than the Common Lisp HyperSpec. But CLtL2 is a good book. You just have to be careful about stuff that did not end up in the standard.
<Xach>
kuribas: not really. the hyperspec isn't something to start with to learn, but it's a very good reference.
<kuribas>
oh, googling "common lisp reference" gives me quite a few interesting links
Krisostoomus has joined #lisp
nowhereman_ has joined #lisp
<Xach>
There are things that are "friendly" that don't quite act as "reference"
<Xach>
the common lisp quick reference is good but perhaps not friendly...terse, though