varjag has quit [Read error: Connection reset by peer]
varjagg has joined #lisp
gxt_ has joined #lisp
cantstanya has joined #lisp
prxq_ has joined #lisp
prxq has quit [Ping timeout: 258 seconds]
jason_m has joined #lisp
varjagg has quit [Read error: Connection reset by peer]
varjagg has joined #lisp
ltriant has joined #lisp
anewuser has joined #lisp
varjagg has quit [Ping timeout: 246 seconds]
iAmDecim has joined #lisp
ltriant has quit [Ping timeout: 245 seconds]
iAmDecim has quit [Ping timeout: 245 seconds]
EvW has quit [Ping timeout: 250 seconds]
torbo has quit [Remote host closed the connection]
ltriant has joined #lisp
j0nd0e has joined #lisp
keep_learning_M has quit [Quit: This computer has gone to sleep]
jason_m has quit [Ping timeout: 246 seconds]
iAmDecim has joined #lisp
varjag has joined #lisp
Arcaelyx has quit [Ping timeout: 245 seconds]
dave0 has joined #lisp
<dave0>
hi
iAmDecim has quit [Ping timeout: 272 seconds]
varjag has quit [Read error: Connection reset by peer]
iAmDecim has joined #lisp
jack_rabbit_ has quit [Ping timeout: 250 seconds]
Jeanne-Kamikaze has joined #lisp
iAmDecim has quit [Ping timeout: 245 seconds]
liberiga has joined #lisp
dave0 has quit [Quit: dave's not here]
Bike has quit [Quit: Lost terminal]
<beach>
Good morning everyone!
gravicappa has joined #lisp
<beach>
afiddegnum: Are you still around?
cyraxjoe has quit [Read error: Connection reset by peer]
cyraxjoe has joined #lisp
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
mathrick has quit [Ping timeout: 276 seconds]
MCP_ has quit [Ping timeout: 268 seconds]
FreeBirdLjj has joined #lisp
vlatkoB has joined #lisp
mathrick has joined #lisp
mathrick has quit [Ping timeout: 276 seconds]
mathrick has joined #lisp
liberiga has quit [Ping timeout: 260 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
<afiddegnum>
beach: yes
<afiddegnum>
i m here
MCP_ has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
j0nd0e has quit [Remote host closed the connection]
MCP_ has quit [Ping timeout: 248 seconds]
keep_learning_M has joined #lisp
anewuser has quit [Quit: anewuser]
sauvin has joined #lisp
gxt_ has quit [Quit: WeeChat 2.5]
<beach>
afiddegnum: Every language has "special forms", i.e. expressions or statements that are not function calls, and that need to be defined by the language. In a C-like language, it might be the assignment, like a[i] = 234, or a conditional, like if (x < 3) fun(x).
<beach>
In most languages, if you need a special form that doesn't already exist, then you have to wait for the new version of the standard and then for current compilers to implement the new special form. In Common Lisp, you write a macro, that transform the form you want to see (but that doesn't yet exist) into one or more existing form types.
<beach>
And presto, you have extended the syntax of the language.
<beach>
So, for instance, let's say you have a special application that uses Fibonacci numbers a lot. You may wish for a looping construction such as `for each Fibonacci number x do <something>'.
<beach>
In Common Lisp, you just write a macro for-each-fibonacci-number, that transforms such forms into a TAGBODY and GO that will do the looping. And, in fact, this is precisely the technique used in the built-in Common Lisp macro LOOP.
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 245 seconds]
flamebeard has joined #lisp
iAmDecim has joined #lisp
Jeanne-Kamikaze has quit [Remote host closed the connection]
Inline has quit [Quit: Leaving]
sellout- has quit [Ping timeout: 244 seconds]
FennecCode has quit [Quit: ERC (IRC client for Emacs 26.2)]
iAmDecim has quit [Ping timeout: 246 seconds]
<afiddegnum>
beach: i think my problem is, after reading most docs about it, i have a fair picture of what is it like, but how to apply to my daily scenarios, decided to learn lisp because of metaprogramming, which is a feature i m in dire need.
<afiddegnum>
but how do i apply the concept of macros to my i.e applications,
<afiddegnum>
well i dont want repeatedly i.e build an html page over and over, templating tools, i.e have their limitations
<beach>
The way I usually do it is that I wait until I see some boilerplate code that is repeated several times and that I can't easily express as a functional abstraction.
<afiddegnum>
what i m envisoning myself doing is to build something like html->head->corewidget->left_and_right:sidebars etc...
<afiddegnum>
there are lots of repetitions in code that handle the presentation logics; UI, widgets etc...
<beach>
I don't think you should start by thinking about macros. An application typically has only a few macros defined. You will see it as your code gets bigger.
<afiddegnum>
but the data logic could be semi-abstracted
<beach>
Sure, but most of the abstractions you need can be written as functions.
<beach>
So don't force your ideas into macros.
<afiddegnum>
yes, functions, classes etc... but i still want to understand where macro influcences the functions or other codes? what does it do?
<ecraven>
I mostly use simple macros for delaying evaluation in some way, lots of with-.. macros that might take a thunk argument, but to prevent that, I just wrap that in a macro
<ck_>
afiddegnum: have you ever used (unless ..) ?
<ecraven>
I've written a few more complex macros for things like defining custom types of structures
<beach>
afiddegnum: Think of classes as data abstractions, of functions as control abstractions, and of macros as syntactic abstractions.
<beach>
afiddegnum: Perhaps it is very hard to understand the purpose of macros until you have the situation I mentioned, i.e., boilerplate code that you can't turn into functions.
dave9 has joined #lisp
<afiddegnum>
ck_: yes in a Racket tutorial
JohnMS_WORK has joined #lisp
<beach>
afiddegnum: I will be quiet now so that I won't add noise to the discussion.
<afiddegnum>
some noises can be useful :)
<ck_>
afiddegnum: I only asked because of your question "where macro influences the functions or other ocdes". The common lisp unless is a macro. (unless a b) means the compiler sees that as if you'd written (if a nil b).
<afiddegnum>
ok
dave0 has joined #lisp
vlatkoB_ has joined #lisp
gareppa has joined #lisp
gareppa has quit [Remote host closed the connection]
<LdBeth>
>what i m envisoning myself doing is to build something like html->head->corewidget->left_and_right:sidebars etc...
<LdBeth>
Common Lisp macro is designed for producing lisp code, and what you’re looking for is probably a meta programming system producing HTML/DOM trees
vlatkoB has quit [Ping timeout: 245 seconds]
<LdBeth>
What lisp macro features is doing metaparogramming with homoiconicity
<LdBeth>
While you can use any reasonable programming languages to meta program any other languages
<ecraven>
beach: what are macros that couldn't be replaced by turning things into thunks or quasiquotes (that you then analyze at runtime)? [just speaking about functionality, not efficiency]
slyrus_ has joined #lisp
slyrus1 has joined #lisp
<pjb>
ck_: (macroexpand-1 '(unless (= a b) (print a) (setf a b))) #| --> (IF (NOT (= A B)) (PROGN (PRINT A) (SETF A B))) ; T |#
<pjb>
or that..
<beach>
ecraven: Macros don't do anything that can't be done that way. You are describing an interpreter that can be Turing complete.
slyrus__ has quit [Ping timeout: 248 seconds]
slyrus has quit [Ping timeout: 272 seconds]
<ck_>
pjb: I still don't know why you're telling me this. Yes, I know.
<ecraven>
good point ;)
<pjb>
ck_: you missed the progn!
<ck_>
pjb: I used a simplified example, in which there is no progn!
<ck_>
your move again
<pjb>
simplified examples are misleading.
<pjb>
program sources are not.
<ck_>
(unless a b) is not a program source, then? I'll make a note of that, so I don't accidentally ever type it as part of a program
<ck_>
but you're missing the entire point. A asks about macros, B answers (with an answer you don't like, granted), and you address B with a correction
ltriant has quit [Remote host closed the connection]
ltriant has joined #lisp
<pjb>
ck_: No, it's not. It's a template. a stands for any expression, but b stands for any SEQUENCE of expression.
<beach>
afiddegnum: Again, it is not clear that your use case requires macros, so forget about them until you can't get rid of boilerplate code without them.
<afiddegnum>
ok, thanks for your contributions, i m still reading through, I believe Macros fit into what i wanted to do but i just want to know how and when to use it right
zaquest has quit [Remote host closed the connection]
<flip768>
ck_: "having blinkers on"?
liberiga has joined #lisp
ggole has joined #lisp
zaquest has joined #lisp
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 244 seconds]
Lord_of_Life has quit [Ping timeout: 268 seconds]
Lord_of_Life has joined #lisp
dave0 has quit [Quit: dave's not here]
milivoj has joined #lisp
FreeBirdLjj has joined #lisp
themsay has joined #lisp
Kevslinger has quit [Quit: Connection closed for inactivity]
prxq has quit [Read error: No route to host]
FreeBirdLjj has quit [Ping timeout: 248 seconds]
hhdave has joined #lisp
marcopersson has joined #lisp
<marcopersson>
Hello
<beach>
Hello marcopersson.
<marcopersson>
How come (typep #(1 2) '(vector string)) return t? It seems like typep ignores the element type?
<beach>
marcopersson: Well, the element type is not INTEGER or NUMBER here.
<beach>
As I recall, #(...) returns a simple vector.
<beach>
And it has element-type T.
<beach>
So let's check what (VECTOR STRING) means...
<beach>
"only those vectors are included whose actual array element type is the result of upgrading element type"
<beach>
And in SBCL, (UPGRADED-ARRAY-ELEMENT-TYPE 'STRING) evaluates to T.
<beach>
... meaning SBCL does not have a specialized array type for strings, which is not surprising.
<beach>
So you get the same result as if you asked (typep #(1 2) '(vector t))
gareppa has joined #lisp
<beach>
marcopersson: Does that make sense to you?
gareppa has quit [Remote host closed the connection]
<marcopersson>
I think so.. So the type specifier is this case isn't so much about the contents of the vector, as it is about the representation, and since this is not a specialized vector, the element type in this case doesn't really matter because of that?
<beach>
Right, the type of an array is not directly related to its contents. It has to do with how it is represented.
<marcopersson>
Okay, so if I can only get type checking (from SBCL) of array element-types if SBCL support that specialization
<beach>
If you want the type checking to be automatic, then yes.
<marcopersson>
Okay, thanks for the help!
<beach>
Nothing prevents you from wrapping (SETF AREF) in something that will check the type, though.
<beach>
Sure.
<beach>
Wrapping would be a good idea anyway, since your array most likely represents some application data type, so you would want to hide the fact that you are using an array to represent that data type.
<beach>
Arrays (and lists) are not abstract data types.
<marcopersson>
Okay, so it would be a good idea wrappen it in a (check-type) then
<beach>
Very likely, yes.
datajerk_ has quit [Ping timeout: 258 seconds]
<marcopersson>
Hmm, does it then even make sense to (declare (type)) vectors' and arrays' element types if they're not specialized? I assume then that SBCLcan't take advantage of that extra information for optimization when it's not actually guarranteed from the representation
<beach>
Like for example, if your vector represents a graph, you would want an abstraction such as ADD-VERTEX, hiding the fact that the graph is represented as a vector. It is then natural to check that a vertex was given.
<marcopersson>
Yeah makes sense
<beach>
It doesn't make sense. The standard says that declaring a type is the same as wrapping all references to the variable in THE.
<marcopersson>
Okay, good to know
<beach>
So, if the type is not a specialized array, then it will check that the array has element-type T.
<marcopersson>
Which as long as it's an array is true right?
gareppa has joined #lisp
<beach>
Only if it is an unspecialized array, which is what you asked about.
<marcopersson>
Yeah, thanks
<beach>
Anytime.
<beach>
I would not be so obsessed with types if I were you.
gareppa has quit [Client Quit]
<beach>
Stuff like that is best put off until later in the project.
<beach>
Otherwise, you will end up writing a lot of declarations that you will often change later.
<beach>
That's one of the problems with statically typed languages. They force you to provide information that often does not remain true for very long.
<marcopersson>
Yeah, I shouldn't really be focusing on it at all, since this is just a prototype, and I won't be allowed to write the final product in CL anyway. I just ended up playing with types, and just got suprised by the whole (typep #(1 2) '(vector string)) thing and wanted to know more
<beach>
If you really want to do that kind of stuff, define application types with DEFTYPE and use those types. Then there is only one place to modify later on.
<beach>
I see yes.
<marcopersson>
Good advice, thanks. And yeah I won't have any luck convincing C#/C++ programmers at my comp. to start a production CL project, so C# it is..
kaun_ has joined #lisp
liberiga has quit [Quit: Leaving]
datajerk has joined #lisp
igemnace has quit [Ping timeout: 268 seconds]
<beach>
I am sorry to hear that, but I am not surprised.
<marcopersson>
Yeah, at least I get to do the prototype in a language of my choice
Necktwi has quit [Ping timeout: 248 seconds]
<beach>
Trying to convince won't work. Showing what you can do, presumable faster than your colleagues might.
<marcopersson>
Yeah, the problem then becomes "What about when you leave?", the whole finding developers/maintenance spiel
frgo has quit [Remote host closed the connection]
<beach>
Do your colleagues know that it is impossible to write a C++ program that is both modular and fast?
<beach>
marcopersson: Oh, but then they have not made a risk analysis.
frgo has joined #lisp
<beach>
If they did, they would notice that training people is less costly than the loss of productivity working with inferior tools.
milanj has quit [Quit: This computer has gone to sleep]
<beach>
Of course, most industry people have no training in software engineering.
<beach>
So they don't know about risk analysis.
mathrick has quit [Ping timeout: 276 seconds]
Lord_Nightmare has quit [Ping timeout: 245 seconds]
frgo_ has joined #lisp
frgo has quit [Read error: Connection reset by peer]
Lord_Nightmare has joined #lisp
frgo_ has quit [Client Quit]
mathrick has joined #lisp
<marcopersson>
For this project specifically writing it in C# does give the advantage that it becomes a 1st class citizen in the runtime that is the subject of the program
<beach>
And the value of advantages like that can be estimated in the risk analysis too.
<beach>
But people use their gut feeling instead, which is typically orders of magnitude off.
<beach>
But I'll quit now, because it's off topic.
<marcopersson>
Oh yeah, sorry
igemnace has joined #lisp
sammich has quit [Read error: Connection reset by peer]
sammich has joined #lisp
sammich has quit [Changing host]
sammich has joined #lisp
froggey has joined #lisp
milanj has joined #lisp
amerlyq has joined #lisp
afiddegnum is now known as afidegnum
anonymous314 has quit [Remote host closed the connection]
manualcrank has quit [Quit: WeeChat 1.9.1]
gareppa has joined #lisp
gareppa has quit [Remote host closed the connection]
zotan has quit [Ping timeout: 248 seconds]
zotan has joined #lisp
marcopersson has quit [Remote host closed the connection]
femi has quit [Ping timeout: 246 seconds]
frgo has joined #lisp
FreeBirdLjj has joined #lisp
pfdietz has quit [Remote host closed the connection]
scymtym has quit [Read error: Connection reset by peer]
no-defun-allowed has quit [Remote host closed the connection]
LdBeth has quit [Read error: Connection reset by peer]
femi has joined #lisp
FreeBirdLjj has quit [Ping timeout: 258 seconds]
orivej has joined #lisp
liambrown has quit [Ping timeout: 252 seconds]
Jachy has quit [Ping timeout: 252 seconds]
colelyman has quit [Ping timeout: 252 seconds]
akanouras has quit [Ping timeout: 250 seconds]
nonlinear[m] has quit [Ping timeout: 265 seconds]
iarebatman has quit [Ping timeout: 276 seconds]
katco has quit [Ping timeout: 276 seconds]
sciamano has quit [Ping timeout: 276 seconds]
Godel[m] has quit [Ping timeout: 276 seconds]
djeis[m] has quit [Ping timeout: 276 seconds]
dtw has quit [Ping timeout: 276 seconds]
irdr has quit [Remote host closed the connection]
irdr has joined #lisp
femi has quit [Ping timeout: 248 seconds]
fivo has joined #lisp
femi has joined #lisp
dddddd has joined #lisp
pjb has quit [Read error: Connection reset by peer]
milanj has quit [Quit: This computer has gone to sleep]
keep_learning_M has quit [Quit: This computer has gone to sleep]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
jason_m has joined #lisp
FreeBirdLjj has joined #lisp
red-dot has joined #lisp
dddddd has quit [Remote host closed the connection]
dmiles has joined #lisp
dddddd has joined #lisp
FreeBirdLjj has quit [Ping timeout: 245 seconds]
dgfhdfg has joined #lisp
wigust has joined #lisp
iAmDecim has quit [Remote host closed the connection]
wigust- has quit [Ping timeout: 258 seconds]
ga is now known as gaius_
gaius_ is now known as ga
Arcaelyx has joined #lisp
jason_m has quit [Ping timeout: 245 seconds]
ga is now known as gaius_
gaius_ is now known as ga
t58 has joined #lisp
d3 has joined #lisp
<d3>
something
ebrasca has joined #lisp
d3 has left #lisp [#lisp]
<Josh_2>
Land of Lisp and Let Over λ :O
MCP_ has joined #lisp
mindCrime has joined #lisp
sluggo has joined #lisp
sluggo is now known as Bike
kaun_ has joined #lisp
[rg] has joined #lisp
EvW has joined #lisp
jcowan has joined #lisp
<jcowan>
I figure that uninterned symbols ("gensyms" for short) have three distinguishing properties: 1) they are never eq to anything else; 2) they are not read-print invariant; 3) they can be freely garbage collected even when interned symbols cannot be.
<jcowan>
Does anyone actually depend on property 2?
[rg] has quit [Remote host closed the connection]
EvW has quit [Remote host closed the connection]
<dlowe>
property 2 follows from property 1
<dlowe>
it doesn't seem like a useful thing on its own
warweasle has quit [Quit: be back later.]
anewuser has joined #lisp
jmercouris has joined #lisp
kaun_ has quit [Ping timeout: 264 seconds]
milivoj has quit [Quit: Lost terminal]
ebrasca has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 245 seconds]
anewuser has quit [Read error: Connection reset by peer]
cosimone has joined #lisp
fivo has quit [Quit: WeeChat 1.9.1]
JohnMS has joined #lisp
JohnMS has quit [Client Quit]
dale_ has joined #lisp
dale_ is now known as dale
varjag has joined #lisp
JohnMS_WORK has quit [Ping timeout: 245 seconds]
FreeBirdLjj has joined #lisp
lucasb has joined #lisp
miklos1 has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
saravia has joined #lisp
jmercouris has quit [Ping timeout: 245 seconds]
z0d is now known as z00d
z00d is now known as z0d
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
miklos1 has quit [Remote host closed the connection]
Inline has joined #lisp
FreeBirdLjj has quit [Ping timeout: 246 seconds]
smazga has joined #lisp
anewuser has joined #lisp
NickBusey6 has joined #lisp
NickBusey has quit [Ping timeout: 248 seconds]
wxie has joined #lisp
mason is now known as BadHobbit
gareppa has joined #lisp
BadHobbit is now known as mason
oni-on-ion has joined #lisp
saravia has quit [Remote host closed the connection]
varjag has quit [Ping timeout: 245 seconds]
jmercouris has joined #lisp
varjag has joined #lisp
lavaflow has joined #lisp
FreeBirdLjj has joined #lisp
smazga has quit [Ping timeout: 245 seconds]
gareppa has quit [Quit: Leaving]
froggey has quit [Remote host closed the connection]
smazga has joined #lisp
wxie has quit [Ping timeout: 264 seconds]
froggey has joined #lisp
jxy has quit [Quit: leaving]
FreeBirdLjj has quit [Remote host closed the connection]
jmercouris has quit [Remote host closed the connection]
Arcaelyx has quit [Ping timeout: 244 seconds]
sjl has joined #lisp
scymtym has joined #lisp
jmercouris has joined #lisp
FreeBirdLjj has joined #lisp
kaun_ has joined #lisp
kaun_ has quit [Remote host closed the connection]
jxy has joined #lisp
kaun_ has joined #lisp
<jcowan>
dlowe: That's what I was thinking. So you can approach property 1 as a limit by using ordinary symbols long statistically-random symbol-names instead of gensyms, at the expense of property 2.
<dlowe>
most gensym implementations I've seen just have a number they append
smazga has quit [Ping timeout: 246 seconds]
smazga has joined #lisp
ebrasca has joined #lisp
<jcowan>
By gensyms I mean uninterned symbols in general, whether produced by GENSYM or no.
<dlowe>
oh, right.
Lycurgus has quit [Quit: Exeunt]
iskander has quit [Ping timeout: 264 seconds]
q9929t has joined #lisp
jmercouris has quit [Remote host closed the connection]
FreeBirdLjj has quit [Remote host closed the connection]
iskander has joined #lisp
FreeBirdLjj has joined #lisp
q9929t has quit [Quit: q9929t]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
kaun_ has quit [Read error: Connection reset by peer]
manualcrank has joined #lisp
flamebeard has quit []
kaun_ has joined #lisp
varjag has quit [Ping timeout: 245 seconds]
orivej has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
ggole has quit [Quit: Leaving]
shka_ has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
Arcaelyx has joined #lisp
hhdave has quit [Quit: hhdave]
red-dot has joined #lisp
kaun_ has quit [Read error: Connection reset by peer]
sjl has left #lisp ["WeeChat 2.3-dev"]
frgo_ has joined #lisp
frgo has quit [Ping timeout: 244 seconds]
frgo_ has quit [Ping timeout: 248 seconds]
EvW has joined #lisp
Aruseus has joined #lisp
khisanth_ has quit [Ping timeout: 258 seconds]
khisanth_ has joined #lisp
hiroaki has joined #lisp
xkapastel has joined #lisp
oni-on-ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
alexanderbarbosa has joined #lisp
smazga has quit [Ping timeout: 258 seconds]
mathrick has joined #lisp
sauvin has quit [Ping timeout: 248 seconds]
sauvin has joined #lisp
sauvin has quit [Max SendQ exceeded]
sauvin has joined #lisp
reaper has joined #lisp
sauvin has quit [Max SendQ exceeded]
sauvin has joined #lisp
<reaper>
Hi, CL newbie here. I am looking to build a text editor as a way to learn CL
<reaper>
Looking around for cross platform GUI libraries, I find the most of them are outdated or not maintained
<reaper>
any recommendations?
<Xach>
reaper: my recommendation would be to do something else to learn CL.
sauvin has quit [Read error: Connection reset by peer]
<Xach>
The GUI tools will present an obstacle that is not a helpful part of learning
<Xach>
If your main goal is to learn CL so you can use free, portable, nice GUI tools, you will have to write those tools.
<Xach>
(or find someone with a lot of skill and time to do it for you)
<reaper>
I had tried to use CL a few years back and coming back to it. My main goal was to try build an editor and I thought that it would be good learning project for CL
<reaper>
Are those tool too difficult to write, any starting point?
<Xach>
reaper: I think the state of reusable tools in that domain would be pretty frustrating as a first learning project.
<Xach>
I think it's difficult to write because there are a lot of details to get right to get something useful.
<dlowe>
That's true in the OSS world, but LispWorks has a capable GUI library
<dlowe>
and they have a free tier for their compiler/IDE
<Xach>
Yes. I've heard good things about LispWorks CAPI.
themsay has quit [Ping timeout: 246 seconds]
<dlowe>
I hacked up an inventory control system for the company I worked for many years ago, and it was quite easy
<dlowe>
I agree that if you're sticking with the open source software, cross-platform GUI is not really a thing people work on
<reaper>
nice, looks like LispWorks is a good place to start
<dlowe>
cl-gtk might work for you with some hassle
<dlowe>
I know there's at least a windows gtk
<Xach>
I don't think there's anything that is mature, ready to use, portable, and free.
<reaper>
is it worth the effort to try CFFI with Qt5?
<Xach>
reaper: maybe! you know, maybe i'm selling the qt stuff short. there are qt libraries already made that you could try to reuse.
<reaper>
haha, thanks! Will spend some time trying out a few libraries
<no-defun-allowed>
so, then you can run (ql:quickload :quicklisp-slime-helper) in Lisp and it'll get SLIME and tell you exactly what to put in ~/.emacs
<afidegnum>
i have added (ql:add-to-init-file) already
red-dot has joined #lisp
<afidegnum>
ok
<afidegnum>
ah, all is good now,
<afidegnum>
thanks a lot,
<afidegnum>
aggressive learning mode :)
<no-defun-allowed>
alexanderbarbosa: except that there are very useful tools you usually get in other language's standard libraries in quicklisp, like alexandria, cl-ppcre, and domain-specific stuff like handling JSON
smazga has quit [Quit: leaving]
saravia has quit [Remote host closed the connection]
<alexanderbarbosa>
no-defun-allowed: indeed, really important tools...for advanced user :D
khisanth_ has joined #lisp
<edgar-rft>
alexanderbarbosa: with CL you'll become an advanced user pretty fast :-)
<alexanderbarbosa>
edgar-rft: fair.
<edgar-rft>
at least for me it was faster than with many other languages
<alexanderbarbosa>
afidegnum: Practical Common Lisp and A Gentle Introduction to Symbolic Computation books are awesome