pranavats has left #commonlisp [Error from remote client]
livoreno has quit [Ping timeout: 276 seconds]
livoreno has joined #commonlisp
pranavats has joined #commonlisp
specbot has quit [Remote host closed the connection]
minion has quit [Read error: Connection reset by peer]
minion has joined #commonlisp
specbot has joined #commonlisp
kiki_lamb has joined #commonlisp
mon_aaraj has quit [Ping timeout: 272 seconds]
mon_aaraj has joined #commonlisp
akoana has quit [Quit: leaving]
anticomputer has quit [Remote host closed the connection]
azimut has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
azimut has joined #commonlisp
pranavats has left #commonlisp [Error from remote client]
karlosz has joined #commonlisp
mon_aaraj has quit [Ping timeout: 255 seconds]
mon_aaraj has joined #commonlisp
karlosz has quit [Quit: karlosz]
karlosz has joined #commonlisp
karlosz has quit [Quit: karlosz]
anticomputer has quit [Quit: quit]
anticomputer_ has joined #commonlisp
azimut has quit [Remote host closed the connection]
azimut has joined #commonlisp
prokhor has joined #commonlisp
prokhor_ has quit [Ping timeout: 255 seconds]
pranavats has joined #commonlisp
hineios8 has joined #commonlisp
hineios has quit [Ping timeout: 240 seconds]
hineios8 is now known as hineios
karlosz has joined #commonlisp
pranavats has left #commonlisp [Disconnected: Replaced by new connection]
pranavats has joined #commonlisp
yauhsien has joined #commonlisp
yauhsien has quit [Ping timeout: 268 seconds]
karlosz has quit [Quit: karlosz]
karlosz has joined #commonlisp
karlosz_ has joined #commonlisp
karlosz has quit [Ping timeout: 268 seconds]
karlosz_ is now known as karlosz
<jeosol>
Good morning all!
<jeosol>
Are there resources for deploying CL applications (SBCL). I was doing some experiments, testing different scenarios - and wanted to share some results
<jeosol>
As some of you know, I have been working on deployment last few weeks. I looked at: (1) bare metal REPL, (2) docker container standalone and (3) container on kubernetes cluster in GKE
<contrapunctus>
(the "Scripting and building executables" chapter in the cl-cookbook)
<jeosol>
thanks for that link contrapunctus
<jeosol>
I am actually looking at distributed options and wanted to some experiments but disappointed in the results, some of which are expected
<jeosol>
Here are my preliminaries results: apologies for the format
<jeosol>
I tried to run my workloads on a Google Kubernetes Cluster. Results below
<jeosol>
Test scenario: Send requests from machine A (Django server) to SBCL workers (on machine A or B or GCP)
<jeosol>
- Machine A - Dev machine,
<jeosol>
- Machine B - Test machine (both in same network, but requires DNS lookup to send jobs to B)
<jeosol>
- I can run workers (SBCL repls) on both machines A and B
<jeosol>
- All requests start from the Django app on machine A
<jeosol>
* (Django is a python web framework)
<jeosol>
Test 1: Machine A (Django) to Machine A SBCL REPL (simple) localhost:8888: < 2secs
<jeosol>
Test 2: Machine A (Django) to Machine B SBCL REPL (simple) (site DNS lookup): ~ 4.2 seconds
<jeosol>
Test 3: Machine A (Django) to SBCL on GKE pod (use ingress IP): ~16 seconds
<jeosol>
This is making me rethink how I package the SBCL workers.
aartaka has quit [Ping timeout: 272 seconds]
subpsunym has quit [Quit: reboots]
<pjb>
jeosol: perhaps your containers are rebooted each time you send a request? The key would be not to restart anything. Perhaps use slime or sly remotely?
<jeosol>
pjb: thanks for that input. No, the pods have been running for days, no restarts at all
<jeosol>
I can see the logs, and can send small requests, and see SBCL responding.
<jeosol>
The issue is probably sending requests and data all over the place. I am just trying to test different options
<jeosol>
but I need the workers to be up and restart if they go down, hence my looking at K8s
<jeosol>
I will look into it more, but it doesn't make sense for SBCL in docker container to run longer.
<jeosol>
It is the same if I run it locally on same machine, but it's a bit faster that container elsewhere but slower than bare metal REPL
<jeosol>
pjb: thanks for the input. I got a lot of help from the guys here to get to this point.
shka has joined #commonlisp
jolby has quit [Quit: Client closed]
dtman34 has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
smlckz has quit [Quit: WeeChat 3.2.1]
puhi has quit [Quit: (;´Д`)]
saturn2 has quit [Ping timeout: 260 seconds]
dtman34 has joined #commonlisp
Inline has quit [Remote host closed the connection]
pranavats has left #commonlisp [Error from remote client]
dtman34_ has joined #commonlisp
puhi has joined #commonlisp
dtman34 has quit [Ping timeout: 272 seconds]
karlosz has quit [Quit: karlosz]
mon_aaraj has quit [Ping timeout: 276 seconds]
aartaka has joined #commonlisp
MajorBiscuit has joined #commonlisp
mon_aaraj has joined #commonlisp
clone_of_saturn has joined #commonlisp
clone_of_saturn is now known as saturn2
Major_Biscuit has joined #commonlisp
MajorBiscuit has quit [Ping timeout: 268 seconds]
jolby has joined #commonlisp
pranavats has joined #commonlisp
Inline has joined #commonlisp
pve has joined #commonlisp
jolby has quit [Quit: Client closed]
<aeth>
jeosol: if you control the environment (which containers would imply), then imo the easiest way to do things would be to use one of many binary or scripting solutions (either portable or implementation-specific) to basically work as an entry point for loading ASDF systems...
<aeth>
even if it's just loading your system and then doing (your-system:main) inside that script, that makes it so much easier to work with than treating scripts separately because now you can use SLIME all of the way up until you deploy
<aeth>
If you don't control the environment fully, then build a standalone binary, basically bundling a complete SBCL or other implementation. Afaik, in some ways this is simpler because you can just load the libraries and then write the binary.
aartaka has quit [Ping timeout: 272 seconds]
aartaka has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
contrapunctus has joined #commonlisp
Th30n has joined #commonlisp
taiju has joined #commonlisp
karlosz has joined #commonlisp
<aeth>
jeosol: the lispcookbook has general solutions, but if you're just using containers, then you can just `#!/path/to/your/sbcl --script` on a chmod +x .lisp file or whatever the particular non-SBCL implementation-specific way to do it is. Or more portably you can just load the script from the command line like e.g. `sbcl --non-interactive --load /path/to/your/entry-point.lisp` (should be easier to switch
<aeth>
implementations, just change the flags). Either way, I try to keep that file very simple and rely on ASDF systems (ideally quickloaded from ~/quicklisp/local-projects/) for nearly everything when I control the environment completely.
<aeth>
I do the latter for gitlab ci, which uses docker.
grumpybear has joined #commonlisp
<aeth>
You could try all of the 5+ ways to do it to see which one is faster. You can also try to make sure to use the latest SBCL. The default one in the containers might be an older one with fewer optimizations.
Patternmaster has quit [Ping timeout: 240 seconds]
Patternmaster has joined #commonlisp
azimut has quit [Ping timeout: 268 seconds]
aruscher[m] has quit [Quit: You have been kicked for being idle]
thewaves has quit [Quit: You have been kicked for being idle]
causal has joined #commonlisp
<contrapunctus>
When I place the cursor in an `asdf:defsystem` form, eldoc shows me `(defsystem name &body options)`. Is there any existing way to specify the grammar acceptable to a form, so tools like eldoc can display it, and programmers see something more concrete than `&body options`?
<contrapunctus>
Another example that comes to mind is `loop`.
<jdz>
contrapunctus: Those forms have pretty complicated grammars that will not fit in minibuffer (or even whole frame).
karlosz has quit [Quit: karlosz]
OlCe has quit [Remote host closed the connection]
<contrapunctus>
I see...
jmdaemon has quit [Ping timeout: 272 seconds]
subpsunym has joined #commonlisp
aartaka has quit [Ping timeout: 268 seconds]
aartaka has joined #commonlisp
OlCe` has joined #commonlisp
yauhsien has joined #commonlisp
random-nick has joined #commonlisp
yauhsien has quit [Ping timeout: 268 seconds]
aartaka has quit [Ping timeout: 264 seconds]
aartaka has joined #commonlisp
taiju has quit [Ping timeout: 240 seconds]
notzmv has quit [Ping timeout: 240 seconds]
lisp123 has joined #commonlisp
<lisp123>
I'm looking for the minimal set of benefits for macros (i.e. all other benefits can be expressed out of these)
<lisp123>
My memory was there are 2 - evaluating at compile time (or lack of evaluating then) and controlling evaluation
<lisp123>
Is it fair to say all other benefits are directly related to both of these?
<lisp123>
For example syntatical abstraction I would fall under evaluating at compile time
<lisp123>
As it is only possible because of that
<lisp123>
A more precise way to say it would be 'macroexpansion at compile time'
mon_aaraj has quit [Ping timeout: 272 seconds]
<jackdaniel>
abstracting away syntax is a quality on its own terms
<jackdaniel>
it renders many design patterns unnecessary (because they may be encoded in a form of a new syntax abstraction)
mon_aaraj has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
aartaka has quit [Ping timeout: 240 seconds]
shka has quit [Ping timeout: 268 seconds]
aartaka has joined #commonlisp
mon_aaraj has quit [Ping timeout: 272 seconds]
shka has joined #commonlisp
mon_aaraj has joined #commonlisp
defaultxr has quit [Ping timeout: 240 seconds]
<jeosol>
aeth: thanks for your pointers. I will respond in no particular order
<jeosol>
aeth: I update SBCL every month and rebuild the containers so this test is running 2.2.6. I primary only use SBCL and the code has not been tested with any other implementation for few years now
<jeosol>
aeth: I rebuild the containers from source in two stages. (1) just sbcl with need system libs and (2) I add my systems on top of that
notzmv has joined #commonlisp
<jeosol>
aeth: I load the system similar to how you described. I have a *.lisp file and a script *.sh file that calls *.lisp file on startup. I build a final core file in the container. Ideally, I would like to just move the core file
<jeosol>
aeth: this takes 20 mins for a small example. In any case, afterwards, I start the container which starts a repl and launches a hunchentoot server.
<jeosol>
aeth: I think I am doing things similar as you described. The build would be faster, if I can just move executables or core files so I am not building twice, once on my machine, then once inside the container
<jeosol>
aeth: when you say "you can just load the libraries, and write the binary", I assume you mean dumping the core file right? If so, this is what I do already. Is similar build process whether inside or outside container. I load the corefile which makes it start the repl almost instantaneously
mon_aaraj has quit [Ping timeout: 255 seconds]
mon_aaraj has joined #commonlisp
lisp123 has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
<lisp123>
jackdaniel: ok
rogersm has quit [Quit: Leaving...]
mon_aaraj has quit [Ping timeout: 240 seconds]
Dynom has joined #commonlisp
mon_aaraj has joined #commonlisp
<pjb>
lisp123: lisp macros are compiler hooks.
<lisp123>
pjb: what is the definition of hooks here
<pjb>
Same as in OOP.
nij- has joined #commonlisp
<lisp123>
pjb: i see, thanks
<pjb>
lisp123: it's a point of customization.
<pjb>
The user code can provide a function to extend the program.
<pjb>
So macros let you extend the compiler, by adding new syntax and new constructs.
<_death>
macros can be expanded (over and over) by an interpreter only (yes, I know about CL's minimal compilation, not the point)
mon_aaraj has quit [Ping timeout: 255 seconds]
<lisp123>
pjb: is it extending the compiler if the definition of macros is already a part of the compiler?
Josh_2 has joined #commonlisp
<pjb>
lisp123: yes, macros are loaded in the compilation environment to be able to do their work.
<_death>
so (i) you can have macros without compilation and (ii) you can have compile-time evaluation without macros (think eval-when)
<pjb>
_death: it's irrelevant if interpreted or compiled, it's a semantic question.
mon_aaraj has joined #commonlisp
<nij->
I'm using ql:quickload. Does it look for all asd files recursively (completely) under local project dirs?
<pjb>
nij-: AFAIK, yes.
<Josh_2>
Follows sym links as well
<lisp123>
pjb: hmmm what is the difference between compiler and interpreter here
<pjb>
lisp123: as _death mentionned, the interpreter must perform minimal compilation, ie. macroexpansion and a few other details. So it makes no difference if an interpreter or a compiler is used for macros.
<beach>
pjb: Are you sure about what an interpreter has to do?
<beach>
I never checked that, since I am not planning to have one.
Josh_2 has quit [Ping timeout: 240 seconds]
<lisp123>
pjb: the fact that the standard has the concept of *macroexpand-hook* lends credence to macros are compiler hooks
yauhsien has joined #commonlisp
<pjb>
Err, no I must confuse with the minimal implementation of CL:COMPILE and CL:COMPILE-FILE. An interpreter could re-expand the macros each time.
taiju has joined #commonlisp
<pjb>
lisp123: well, this variable is a macroexpansion hook. The macro hooks are implicit with DEFMACRO.
<beach>
lisp123: Even without *MACROEXPAND-HOOK*, a common way of viewing macros is that they add new syntax to the base language. And recognizing syntax is all the front-end of the compiler does.
<_death>
what's true is that macros fit well with compilation.. that's one reason they were favored over fexprs
<lisp123>
Users who put their own function into *macroexpand-hook* should consider saving the previous value of the hook, and calling that value from their own.
<lisp123>
What is an example of overriding this variable?
<pjb>
lisp123: you could do it to count the number of times a macro call is expanded.
<lisp123>
beach: Thanks, that I understand ('..all the front-end of the compiler does..')
<nij->
pjb thanks :)
nij- has left #commonlisp [Using Circe, the loveliest of all IRC clients]
yauhsien has quit [Ping timeout: 268 seconds]
<lisp123>
pjb: Interesting. I think I get the 'macros are compiler hooks' better now, its an easier way to look at it from a non-lisp perspective
<beach>
lisp123: It is as if you could add new statements to an "ordinary" language, like new loops, new conditionals, etc.
<pjb>
lisp123: for example, "bare" CL has only IF as conditionnal. By defining the COND macros, we add to the CL language a new conditionnal instruction.
<pjb>
lisp123: and you can use the same mechanism, to add your own instructions to the CL language.
<beach>
lisp123: Since such statements are recognized specially by the compiler (i.e., they are not function calls), macros provide the possibility of programming the compiler.
<lisp123>
pjb beach: Where I'm getting stuck is that I am viewing that above as "part" of the compiler already vs. something that macros 'extend' a compiler
<lisp123>
In the sense there is a pre-defined method of how a compiler evaluates a form
<beach>
lisp123: The macro facility is part of the compiler for sure. But the syntax that you can provide with new macros is not.
<lisp123>
But could you argue the syntax is already there in the sense that the evaluation of the form is predefined, and then the macrofunction is used (in the case of a macro)
<beach>
lisp123: Here is another piece of evidence: The standard allows for special operators to be implemented as macros and vice versa. So there is really no distinction between the two. And special operators are definitely part of the job of the compiler to recognize and compile correctly.
<lisp123>
As in I don't fully view (most likely wrongly) as macros adding syntax, because i always follow the rules of evaluation and then do the macro expansion as part of BAU
<pjb>
the point is that it's not only syntax, it's also semantics.
<pjb>
For example, there's no parallellism in CL. But you could write a macro: (in-parallel form1 … formn) that would execute the forms in parallel.
<pjb>
lisp123: in CL, there's no rule of evaluation that evaluates subforms in parallel. Here, we add a new semantic to the language.
<pjb>
The subforms of in-parallel are not evaluated in any specific order: they're evaluated at the same time.
<_death>
that's just syntactic sugar though.. macros are about syntax because they need to be idempotent (you can violate this, but it'll get you in trouble..)
<White_Flame>
lisp123: right, I would say that reader macros can add syntax in a very literal sense
<White_Flame>
but the broader sense of the word does include what programs tend to call semantics as well
<White_Flame>
and to throw more into the mix, I'd say that macros are on the layer of a preprocessor before the core "compiler" itself is invoked.
<White_Flame>
but of course it's a prerequisite to the compilation of forms and thus is called by the compiler
<lisp123>
Semantically I agree with the definition of macros as compiler hooks
waleee has joined #commonlisp
<lisp123>
White_Flame: You expressed it much better than I could, that's how I have been thinking of macros
<White_Flame>
in modern terms, the macro system might also be called a "transpiler", converting from DSL to natively supported terms ;)
<lisp123>
preprocessor = facility in the language that allows certain types of forms to be macroexpanded
<lisp123>
beach: Now with standard operators being implemented by macros and the whole circularity of read-time, compile-time, run-time, maybe its best to ignore anything but semantics
<lisp123>
That might be the angle
<beach>
You can do that if you want. But I take the side of Paul Wilson who says that Lisp has a two-level syntax. One is the sequence of characters that READ deals with, and the other is the S-expression syntax of special forms. From that point of view, macros are all about adding new (second-level) syntax to the language.
<beach>
Lisp special operators are not defined in terms of sequences of characters after all.
<beach>
And if you write a macro for others to use, its documentation will be indistinguishable from a Common Lisp HyperSpec page describing a special operator.
<beach>
I don't think I have anything else to contribute to this discussion.
<_death>
(to be more precise, macros often violate idempotence to some degree, e.g. by generating new symbols for use in expansions.. the consequences are relatively mild in that case)
<pjb>
macros can have compilation-time side effects. Eg defvar makes the compiler note that a variable exist.
<pjb>
Repeating a defconstant form can often signal an error.
<hayley>
I do agree with Paul Wilson's definition. One of the great things one learns is that syntax is unimportant, but yet one may feel the need to make new syntax. These two observations aren't in contradiction, as the former reflects on the character syntax, and the latter on list syntax.
<_death>
pjb: it's the expansion that has these side effects
<_death>
(macroexpand '(defvar foo 123)) won't have the compiler note
<pjb>
with well written macros, yes.
lisp123 has quit [Remote host closed the connection]
<_death>
hayley: both kinds of syntax are important (to the human)
lisp123 has joined #commonlisp
<White_Flame>
interning still passes a definition of idempotence, as the return value will still be the same across multiple calls
<White_Flame>
even though it's a side effect. same thing with caching systems
mon_aaraj has quit [Ping timeout: 240 seconds]
<_death>
it's not just that we write 'foo and not (quote foo), but also that we write 123.6 and not CXIII+I/VI ;)
<_death>
(I mean III/V, sigh)
<hayley>
Sure. More specifically, introducing a new feature does not require new character syntax.
<White_Flame>
and another X ;)
<_death>
my roman is weak
mon_aaraj has joined #commonlisp
* White_Flame
revokes _death's laurels
<jackdaniel>
it's simple: I, II, III, IIII and so on
<White_Flame>
Achievement Unlocked: Human readability maximized
<jackdaniel>
maxIIIIIIIIIIIIIIImized
<_death>
if we go by edit distance.. some errors may actually be more apparent.. compare III... for designating 123 and III... for designating 223..
<_death>
maybe we can market it as a new language safety feature
<White_Flame>
can't wait to see numeric guid literals in such a system
lisp123 has quit [Read error: Connection reset by peer]
<_death>
most-positive-fixnum
<_death>
so this suggests that syntax can (and does) significantly affect semantics, not just pragmatics
<jackdaniel>
"A change of perspective is worth 80 IQ points" (Alan Kay), and "Good abstraction eliminates thought" (paraphrase, don't remember who said that) = macros \o/
<_death>
sounds like Whitehead on civilization
Catie has joined #commonlisp
Th30n has quit [Quit: WeeChat 3.5]
SunClonus has joined #commonlisp
igemnace has joined #commonlisp
son0p has quit [Ping timeout: 240 seconds]
dtman34_ has quit [Read error: Connection reset by peer]
dtman34 has joined #commonlisp
Josh_2 has joined #commonlisp
hannibal_ad_port has joined #commonlisp
NotThatRPG has joined #commonlisp
SunClonus has quit [Read error: Connection reset by peer]
jeosol has quit [Quit: Client closed]
jeosol has joined #commonlisp
waleee has quit [Quit: WeeChat 3.6]
waleee has joined #commonlisp
serbest has joined #commonlisp
serbest has quit [Quit: Leaving]
tyson2 has joined #commonlisp
Major_Biscuit has quit [Quit: WeeChat 3.5]
OlCe` has quit [Read error: Connection reset by peer]
razetime has joined #commonlisp
totoro has quit [*.net *.split]
totoro has joined #commonlisp
random-nick has quit [Ping timeout: 268 seconds]
taiju has quit [Ping timeout: 244 seconds]
orestarod has joined #commonlisp
<jcowan>
Schemers call syntax of the first kind "lexical syntax" and of the second kind "syntax": ( ) abcdef 10/12 belong to the lexical syntax, whereas if, lambda, case, etc. belong to the syntax. This agrees with the usage in other PLs
<jcowan>
"Syntax doesn't matter" means that if you or your Lisp don't tlike the syntax of some code, you can shim it without changing the code. "Syntax matters" means that you can abstract over it instead of being stuck with hard-coded syntax
jeosol has quit [Quit: Client closed]
mon_aaraj has quit [Ping timeout: 260 seconds]
aartaka has quit [Ping timeout: 255 seconds]
mon_aaraj has joined #commonlisp
<White_Flame>
"Only when you unbox the value will you know if the syntax mattered or not." - Erwin Schrödinger
molson has quit [Remote host closed the connection]
Posterdati has joined #commonlisp
molson has joined #commonlisp
<White_Flame>
jcowan: what's the difference between shimming & abstracting over, in that context?
<White_Flame>
(if I'm reading it correctly, if in both cases you don't have to change the code)
molson has quit [Remote host closed the connection]
defaultxr has joined #commonlisp
jeosol has joined #commonlisp
molson has joined #commonlisp
yottabyte has joined #commonlisp
moosh has quit [Ping timeout: 244 seconds]
moosh has joined #commonlisp
NotThatRPG has quit [Ping timeout: 272 seconds]
mon_aaraj has quit [Ping timeout: 268 seconds]
mon_aaraj has joined #commonlisp
mon_aaraj has quit [Ping timeout: 268 seconds]
mon_aaraj has joined #commonlisp
mon_aaraj has quit [Ping timeout: 268 seconds]
mon_aaraj has joined #commonlisp
anticomputer_ has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
son0p has joined #commonlisp
igemnace has quit [Remote host closed the connection]
azimut has joined #commonlisp
mon_aaraj has quit [Ping timeout: 272 seconds]
mon_aaraj has joined #commonlisp
aartaka has joined #commonlisp
<pve>
I tried making a "syntax" macro that looks for the pattern "a <- b" and transforms it into (setf a b). It's silly, but making it was a nice learning experience in macrology.
<pve>
If anyone would care to comment regarding the actual practicality of something like this, that would be great :) My use case is something like "small quick scripts".
<aeth>
jeosol: yeah, my bad, I was also responding to your messages in order and by getting to the end of your messages it was clear that my advice was probably irrelevant
<aeth>
I usually read chat in reverse order, too. Oops.
<aeth>
pve: I did something very similar, but as a joke. I did a C++ << based hello world in Lisp
<aeth>
obviously not complete since it was just a proof of concept, but it basically did an infix to prefix transformation... I ignored precedence for the sake of the joke (since that's 90% of the work of infix) so it has to be the same operator.
<aeth>
#I(...) becomes (infix ...) which does the transformation
<aeth>
iirc
<aeth>
(no comments/documentation so I'm just guessing)
<pve>
yep
<aeth>
when you do advanced macros you kind of have to M-. and macroexpand-1 to be sure. That's the downside of something like your approach.
<pve>
sure
<pve>
mine isn't exactly a joke, more like a casual exploration into what-if
<pve>
I enjoy doing that
thuna` has quit [Remote host closed the connection]
thuna` has joined #commonlisp
morganw has joined #commonlisp
<fitzsim>
lisp-hello-world is funny
rogersm has joined #commonlisp
karlosz has joined #commonlisp
azimut_ has joined #commonlisp
<aeth>
fitzsim: yeah, but I'm surprised how much code it takes to get the hello world working
pranavats has left #commonlisp [Error from remote client]
hashfunc1128 has joined #commonlisp
<fitzsim>
I wonder how much code the reverse would take
thuna` has quit [Remote host closed the connection]
azimut has quit [Ping timeout: 268 seconds]
thuna` has joined #commonlisp
karlosz has quit [Quit: karlosz]
<aeth>
implemnting just enough of Common Lisp to do the equivalent hello world that looks something like this? (format t "Hello, ~A~%" "world!")
<aeth>
probably not *that* hard if your language has the ability to do so without first putting it into a string.
<aeth>
The problem is that most languages won't let you do that
<aeth>
I think you can use the C preprocessor in C++ so... maybe it's possible? How much can you abuse it?
<aeth>
of course, my C++-style hello world has the implication to it that you can write some similar things in it as long as you don't go too far, so you can't just hardcode FORMAT, you'd need to have at least one level (non-recursively) of s-expression handling to handle the FORMAT. And a FORMAT string parser.
<aeth>
so it's probably either very hard or impossible, but only because the Common Lisp hello world usually uses a format string.
<White_Flame>
that would skip (exposed) string construction APIs entirely
<aeth>
(to be clear, making the last write-string into a write-line still forces you to implement 3 things, it's just replacing terpri with write-line)
Dynom has quit [Quit: WeeChat 3.5]
asarch has quit [Quit: Leaving]
NotThatRPG has joined #commonlisp
karlosz has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
morganw has quit [Remote host closed the connection]
hashfunc1128 has quit [Ping timeout: 244 seconds]
kiki_lamb has quit [Quit: leaving]
yauhsien has joined #commonlisp
yauhsien has quit [Ping timeout: 240 seconds]
pve has quit [Quit: leaving]
akoana has joined #commonlisp
triffid has quit [Ping timeout: 268 seconds]
triffid has joined #commonlisp
shka has quit [Ping timeout: 264 seconds]
OlCe`` has quit [Remote host closed the connection]
<jcowan>
abstraction is about writing code in he first place.
zagura has quit [Remote host closed the connection]
mrcom_ has quit [Remote host closed the connection]
mrcom has joined #commonlisp
kevingal has joined #commonlisp
OlCe`` has joined #commonlisp
karlosz has quit [Ping timeout: 268 seconds]
karlosz has joined #commonlisp
orestarod has quit [Ping timeout: 255 seconds]
karlosz has quit [Client Quit]
karlosz has joined #commonlisp
zagura has joined #commonlisp
karlosz has quit [Client Quit]
karlosz has joined #commonlisp
karlosz has quit [Client Quit]
karlosz has joined #commonlisp
karlosz has quit [Client Quit]
karlosz has joined #commonlisp
random-nick has quit [Ping timeout: 240 seconds]
serbest has joined #commonlisp
karlosz has quit [Ping timeout: 268 seconds]
karlosz has joined #commonlisp
livoreno has quit [Ping timeout: 268 seconds]
thuna` has quit [Remote host closed the connection]
kevingal has quit [Read error: Connection reset by peer]