<jmercouris>
Oh I see, it's been a while since I've used ECL, sorry for the confusion
<beach>
iarebatman1: You should ask jackdaniel. He is the maintainer of ECL.
<p_l>
iarebatman1: I used ECL on windows in the past
heisig has joined #lisp
<p_l>
iarebatman1: you want to setup yourself a working C++ compilation environment, I recommend getting MinGW/MSYS2 unless you're adventurous and want MSVC
<p_l>
iarebatman1: then it will pretty much work outright
maxxcan has quit [Quit: maxxcan]
<p_l>
I had success building EQL5 (ECL + Qt5 wrapper) on windows using mingw configured through Qt libs installer
<p_l>
for compile-file to work you'll need to run with the right paths etc. from that environment
pfdietz has joined #lisp
LiamH has joined #lisp
<iarebatman1>
p_l Yeah that's why I'm a bit confused.. I have msys2 working - and I built ecl with it. When I run the "compile-file" instruction as specified, I get an error back that C::BUILDER is undefined
<iarebatman1>
I also built ecl with msvc and got the same result
<p_l>
iarebatman1: are you running it from "developer prompt" in case of MSVC?
<iarebatman1>
I made sure gcc was in my path as well, but that didn't seem to matter
<iarebatman1>
let me try that. good test
<p_l>
because just GCC being in path might be not enough
<p_l>
so make sure you use the full environment
<iarebatman1>
Sorry, I misspoke a moment ago. "compile-file" always produces the *.fasc file - but it will never try to produce the .o file, even though I'm specifying the :system-p t option
<iarebatman1>
when I try to use (asdf:make-build :system-name :type :program), I get
<iarebatman1>
Condition of type: UNDEFINED-FUNCTIONThe function C::BUILDER is undefined.
<iarebatman1>
that's running ecl from the visual studio command prompt
<p_l>
hmm
<jmercouris>
and batman, have you had success with the same procedure on a different OS?
<p_l>
I don't recall encountering that :/
<jmercouris>
just to rule out the possibility that perhaps there isn't something wrong with your ASDF file or program itself?
<iarebatman1>
jmercouris, I haven't tried on linux yet. I assume it works because that's happy path
<iarebatman1>
jmercouris - I can try in a bit, but I'm basically compile a hello-world app
<jmercouris>
why not eliminate as many variables as possible and try first on Linux to verify that it is an OS specific problem?
<iarebatman1>
no other asdf systems as dependencies
<iarebatman1>
yeah I'll have to try that in a bit I guess. I am not sure what else to try.
<iarebatman1>
I just tried setting the CC environment variable, but that didn't matter
<jmercouris>
or perhaps it did, and the problem is multi-factored
<jmercouris>
the only way to know is to start with the most basic assumptions and build up from there, just like any kind of debugging
cosimone has joined #lisp
iarebatman1 has quit [Ping timeout: 260 seconds]
cosimone has quit [Client Quit]
cosimone has joined #lisp
asarch has quit [Ping timeout: 268 seconds]
frgo has quit [Read error: Connection reset by peer]
frgo_ has joined #lisp
flip214 has quit [Ping timeout: 272 seconds]
varjagg has joined #lisp
flip214 has joined #lisp
<pjb>
iarebatman: well, more seriously, the question is whether there's still anybody using MS-Windows?
<pjb>
iarebatman: my strategy is to develop on macOS (because of the 4K+ screen on my iMac), deploy on Linux, and wait for customers to ask for a Windows version, when I would compile my program with ccl on MS-Windows. This never occurs.
<iarebatman>
Truthfully, I am exploring options for game development purposes.. I can’t bring myself to be OK with 40MB+ basic executables , so I was hoping ECL would be a good option for me to try. I’m sort of new to CL still though.
<iarebatman>
If I can easily cross compile from ECL with clang to windows from Linux, I would be good with that option as well
<iarebatman>
But their docs for cross compilation isn’t very extensive..
<jmercouris>
40MB+ basic executables? modern games have absolutely gigantic piles of assets, I think you are solving a non-problem, have any of your potential customers complained about the binary size?
<jmercouris>
has anyone ever said "man, I would love to play this game, it's unfortunate that it takes up 40mb of disk space on my 2tb hard drive"
<iarebatman>
I understand that , and I can’t disagree with your points. However, when I see a modern game that’s less than 100MB with assets included and starts up noticeably fast, I am impressed
<iarebatman>
May be a non issue technically , but it’s something that would eat at me - I don’t like how the entire internet is basically OK with bloat
<pjb>
iarebatman: it's not that ti's OK with it. It's that writing and configuring small executables takes resources. Think that you don't have an army of programmers to do that (instead of implementing the functionalities of your game). You are alone.
<pjb>
iarebatman: you are alone, so choose what you work on wisely!
<pjb>
Is the work of reducing the size from 40MB to 4MB (taking weeks of your time) really worth anything, vs. working the same time developping your game?
<pjb>
Is asking the question itself worth your time!?!?
<pjb>
iarebatman: and, fundamentally, the time it takes to develop the game, computers with twice the memory (RAM or Storage), and half the price will be available!
<pjb>
iarebatman: electronicians have it easy, they use a universe where there are 10^80 particules!
<heisig>
iarebatman: To be fair, SBCL also supports compression, so its more like 17MB instead of 40 MB.
<pjb>
On the other hand, you still only have only 2.5e9 seconds to live!
<iarebatman>
Lol fair points
<pjb>
So again, choose wisely how you spend only very limited and very discrete number of seconds.
<iarebatman>
And I wasn’t aware of sbcl having good compression like that
<heisig>
And I wouldn't call these few megabytes 'bloat' either. They are a full-blown CL environment including a compiler and a great debugger.
<p_l>
heisig: unfortunately compression is contra-productive if you're going to run multiple instances
<p_l>
and sometimes you desperately need those few megabytes less
Oladon_work has joined #lisp
hhdave has quit [Quit: hhdave]
<heisig>
p_l: I know. But that is not an issue if your goal is shipping a product.
shka_ has joined #lisp
<p_l>
heisig: I have exactly such an issue - need to shave megabytes off, have as wide as possible arch support, and need to ship
<p_l>
ECL is pretty much the only game in town (CLISP... maaaaybe, but it got other issues)
<White_Flame>
well, you could always do static code generation from your lisp if you don't need to do fancy runtime compilation stuff
<White_Flame>
as a heavyweight deployment step
<p_l>
got enough need for complete CL environment to not be able to do that
<pjb>
Actually, if you only have a single program using ECL, there's no win, since you have to install the 20+MB libecl.so
<pjb>
Only if you started to rewrite all the unix programs in CL and compile them in ECL, would you amortize this overheard to something similar to C.
gareppa has joined #lisp
<iarebatman>
I thought libecl was more like 3MB?
<jmercouris>
p_l: I bet a commercial implementation with a tree shaker could make smaller executables
rippa has joined #lisp
gareppa has quit [Client Quit]
orivej has joined #lisp
<iarebatman>
P_l - I looked at ferret before ecl just as an experiment. It does something similar, but the tooling basically sucks. No repl even
<pjb>
iarebatman: no, it's about the same size as libc.
gareppa has joined #lisp
gareppa has quit [Quit: Leaving]
<p_l>
jmercouris: no commercial implementation covers the same breadth of platforms as ECL
jmercouris has quit [Ping timeout: 246 seconds]
<p_l>
As for size of libecl - I'm prepping a statically linked executable builder with mucl and ECL for the project
<p_l>
Development can take place on SBCL, but statically linked ECL is deployment target
<pjb>
Now of course, there's an alternative. Use MoCL (commercial), or improve cclic (both are CL to C translators), so that we can just compile the code with a normal C compiler (and very little run-time).
<pjb>
They're subsets of CL however, no run-time compiling (which is good, since Apple forbids run-time compilation in the AppStore.
<pjb>
)
elinow has joined #lisp
<iarebatman>
This guy claims msvc compiles libecl.dll down to 1.5MB - that a falsehood?
<White_Flame>
but in any case, the embedding of the CL runtime is very comparable to the jvm, python etc
<iarebatman>
That thread honestly is what made me thing of trying out ecl with a simple app to check sizes
<White_Flame>
in terms of size
<White_Flame>
although the other languages can be larger with all the libraries included
asarch has joined #lisp
<shka_>
ECL is sweet for compact stuff
<shka_>
overall, it is a nifty implementation, i am glad that it exists
<shka_>
It makes CL better ^_^
cosimone has quit [Quit: WeeChat 2.4]
cosimone has joined #lisp
<iarebatman>
So.. I checked the change log for ecl and immediately saw this line. I haven’t been able to test yet, but I assume this will fix my issue from earlier.
<iarebatman>
Just in case anyone else runs into that..
v0|d has joined #lisp
cosimone has quit [Quit: WeeChat 2.4]
<p_l>
iarebatman: I can't give you numbers now, but I had in the past acquired libecl that were under 5MB of size
EvW1 has joined #lisp
m00natic has quit [Remote host closed the connection]
elinow has quit [Ping timeout: 245 seconds]
asarch has quit [Quit: Leaving]
elinow has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
edgar-rft has joined #lisp
warweasle has quit [Quit: working]
cosimone has joined #lisp
lavaflow has joined #lisp
sveit has quit [Quit: Bye]
simplegauss has quit [Quit: Bye]
iarebatman1 has joined #lisp
smazga has quit [Ping timeout: 272 seconds]
Oladon_work has quit [Ping timeout: 260 seconds]
saravia has joined #lisp
oni-on-ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
saravia has quit [Remote host closed the connection]
lavaflow has quit [Ping timeout: 268 seconds]
saravia has joined #lisp
amerlyq has quit [Quit: amerlyq]
vlatkoB has quit [Remote host closed the connection]
cosimone has quit [Quit: WeeChat 2.4]
smazga has joined #lisp
heisig has quit [Quit: Leaving]
kushal has quit [Remote host closed the connection]
kushal has joined #lisp
arwn has joined #lisp
arwn has left #lisp ["WeeChat 2.5"]
EvW1 has quit [Ping timeout: 250 seconds]
cosimone has joined #lisp
cosimone has quit [Ping timeout: 252 seconds]
cosimone has joined #lisp
gravicappa has quit [Ping timeout: 245 seconds]
EvW has joined #lisp
mindCrime_ has quit [Ping timeout: 272 seconds]
heisig has joined #lisp
heisig has quit [Client Quit]
iarebatman1 has quit [Remote host closed the connection]
Aruseus has joined #lisp
ptiyoyip has joined #lisp
ptiyoyip has quit [Client Quit]
dgfhdfg has quit [Ping timeout: 268 seconds]
oni-on-ion has quit [Ping timeout: 264 seconds]
rgrau has quit [Ping timeout: 244 seconds]
Lord_of_Life has quit [Ping timeout: 244 seconds]
Lord_of_Life has joined #lisp
vms14 has joined #lisp
gravicappa has joined #lisp
jmercouris has joined #lisp
pls has joined #lisp
pls has quit [Remote host closed the connection]
shka_ has quit [Ping timeout: 245 seconds]
pls153 has joined #lisp
<pls153>
iarebatman1: you need (require :cmp) on Windows, since the default compiler there is the bytecode one
elinow has quit [Ping timeout: 244 seconds]
samlamamma has joined #lisp
<pls153>
iarebatman1: and yes, libecl.dll was about 1.5 MB (a few years ago); on my current Linux, libecl.so is about 12 MB
fourdplanner has joined #lisp
whartung has quit [Remote host closed the connection]
whartung has joined #lisp
whartung has quit [Remote host closed the connection]
whartung has joined #lisp
fourdplanner is now known as belfonse
<samlamamma>
Does anyone here know why there's a Cleavir2 and a Cleavir package in SICL?
<Bike>
cleavir2 is a refactoring.
<Bike>
there's a #sicl channel, also.
elinow has joined #lisp
pls153 has quit [Remote host closed the connection]
pfdietz has quit [Remote host closed the connection]
<samlamamma>
Bike: Thank you!
elinow has quit [Read error: Connection reset by peer]
ptiyoyip has joined #lisp
stepnem has quit [Ping timeout: 272 seconds]
stepnem has joined #lisp
<semz>
is there a consensus whether using #. to generate case statements, variable bindings, ... is a good idea or code golf nonsense?
<Bike>
probably not. i think #. for case is basically fine, though.
asarch has joined #lisp
karswell has quit [Read error: Connection reset by peer]
<vms14>
guys can you tell me something about macros?
<vms14>
I want to get the "essence" of macros
<vms14>
or their power
karswell has joined #lisp
mindthelion has joined #lisp
<vms14>
but I'm not realizing what could be done with macros that couldn't be done without them
<semz>
a macro pretty much by definition can only do what can be done without it, but it may do so much more readably and involving much less work
techquila has quit [Ping timeout: 258 seconds]
sauvin_ is now known as Sauvin
gravicappa has quit [Ping timeout: 245 seconds]
<jmercouris>
well, yeah, technically any turing complete language can do anything...however the question is, what can you do more easily with macros
<jmercouris>
vms14: I think a good place to look at would be some projects and how they use macros, just clone some popular lisp projects and search defmacro
<jmercouris>
vms14: if you understand how macros work, then the examples should be readable to you and a valuable source of insight
Bike has quit [Quit: Bike]
<aeth>
vms14: Lots of languages have metaprogramming, but it's almost always pretty painful, and few dare to try it. Some are tolerable. With Lisp, it's trivial, especially once you learn the `', syntax
<aeth>
You don't need macros even in CL, with a few exceptions, where the extremely trivial define-modify-macro might be good enough.
stepnem_ has joined #lisp
stepnem has quit [Ping timeout: 246 seconds]
<aeth>
Generally, macros are just going to be syntactic sugar over UNWIND-PROTECT, DEFUN/DEFPARAMETER/etc., or an elaborate loop.
<jmercouris>
woah woah, macros have other cool features, such as, not necessarily evaluating their arguments at compile time
fourdplanner has joined #lisp
asarch has quit [Ping timeout: 268 seconds]
<aeth>
jmercouris: For the most part, it's about the API you want to expose, though. The cool macros could just be done with a function and quoting. e.g. "(with-html (:html (:body (:a (:href ..." vs. "(with-html '(:html (:body (:a (:href ..."
<aeth>
Except, of course, the macro is probably going to be generating an HTML string at compile time.
<jmercouris>
indeed
belfonse has quit [Ping timeout: 272 seconds]
varjagg has quit [Quit: ERC (IRC client for Emacs 26.1)]
vms14 has quit [Quit: WeeChat 2.3]
techquila has joined #lisp
<aeth>
And if you really want to be fancy with language generation you could generate a format string at compile time with your macro, which might be what FORMATTER is for: (funcall (formatter "Hello, ~A!~%") t "world")
mindthelion has quit [Ping timeout: 272 seconds]
karswell has quit [Remote host closed the connection]
asarch has joined #lisp
liberiga has joined #lisp
<aeth>
A bit inefficient because it's working with a lambda with a &rest, but it's also doing a lot of stuff at compile time that would otherwise be done at runtime (imagine an elaborate generated HTML template there) so it's probably a net gain.
<no-defun-allowed>
has anyone tried to make Franz's clim2 work on other CL implementations?
Aruseus has quit [Remote host closed the connection]
mindCrime has quit [Ping timeout: 272 seconds]
<pjb>
semz: OR, you can consider that definining a set of values (enum) for CASE should be abstracted away in a single macro (instead of #.), to ensure more consistency.
wxie has joined #lisp
<pjb>
semz: that macro would define a macro to wrap case specific to each enum.
<semz>
fair point
<pjb>
note that this is somewhat contradictory to the lisp spirit and genericity: a lisp expression could return an union of several types, and you could dispatch them in a sigle CASE. (case (command-or-color) (blue …) (red …) (up …) (down …) (move …) (stop …) (42 (bazinga!)))
colluphid has quit [Ping timeout: 246 seconds]
colluphid has joined #lisp
wxie has quit [Ping timeout: 250 seconds]
LiamH has quit [Quit: Leaving.]
troydm has quit [Ping timeout: 246 seconds]
troydm has joined #lisp
Bike has joined #lisp
jlpeters has joined #lisp
jxy has quit [Quit: leaving]
<aeth>
pjb: except you probably want ecase or ccase so you get a failure on unexpected input instead of NIL
random-nick has quit [Ping timeout: 272 seconds]
mindCrime_ has quit [Ping timeout: 272 seconds]
samlamamma has quit [Ping timeout: 248 seconds]
<aeth>
semz: Most things that can be done in #. can be done more clearly in DEFMACRO. You rarely need the #. and it's mostly when you would do `(foo ,bar) but the form isn't quoted directly, e.g. the type in check-type, e.g. (check-type foo (integer 0 #.(expt 3 2)))
<aeth>
But even in that example you could just DEFTYPE the type right above the function that uses that CHECK-TYPE
orivej has joined #lisp
ebrasca has joined #lisp
alexanderbarbosa has joined #lisp
jxy has joined #lisp
superkumasan has quit [Ping timeout: 268 seconds]
cosimone has quit [Ping timeout: 264 seconds]
Nomenclatura has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
dgfhdfg has joined #lisp
ptiyoyip has quit [Ping timeout: 248 seconds]
fourdplanner has quit [Read error: Connection reset by peer]
smazga has quit [Quit: leaving]
fourdplanner has joined #lisp
jmercouris has quit [Remote host closed the connection]
asarch has quit [Quit: Leaving]
_jrjsmrtn has joined #lisp
spm_ has joined #lisp
spm_ has quit [Remote host closed the connection]
__jrjsmrtn__ has quit [Ping timeout: 246 seconds]
lucasb has quit [Quit: Connection closed for inactivity]
alexanderbarbosa has quit [Remote host closed the connection]
ebrasca has quit [Remote host closed the connection]
saravia has quit [Remote host closed the connection]