grnman_ has quit [Remote host closed the connection]
krjli has quit [Remote host closed the connection]
DHARMAKAYA has joined #lisp
orivej has quit [Ping timeout: 252 seconds]
zefram22 has quit [Quit: zefram22]
zefram22 has joined #lisp
hypercube has joined #lisp
monolithic has quit [Remote host closed the connection]
rumbler31 has joined #lisp
xsperry has joined #lisp
kevingal has quit [Remote host closed the connection]
rumbler31 has quit [Ping timeout: 245 seconds]
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
nij has joined #lisp
ivysaur has joined #lisp
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
ivysaur has left #lisp ["Leaving"]
ivysaur has joined #lisp
karlosz has quit [Ping timeout: 265 seconds]
nij has quit [Quit: ERC (IRC client for Emacs 27.2)]
anticrisis has quit [Read error: Connection reset by peer]
contrapunctus has left #lisp ["Disconnected: closed"]
anticrisis has joined #lisp
contrapunctus has joined #lisp
ivysaur has quit [Quit: Leaving]
ivysaur has joined #lisp
ivysaur has quit [Quit: Leaving]
karlosz has joined #lisp
hypercube has quit [Quit: WeeChat 3.1]
karlosz has quit [Ping timeout: 252 seconds]
DHARMAKAYA has joined #lisp
ivysaur has joined #lisp
ikrabbe has joined #lisp
ikrabbe|2 has quit [Ping timeout: 246 seconds]
igemnace has joined #lisp
ikrabbe has quit [Ping timeout: 240 seconds]
ivyysaur has joined #lisp
Sheilong has quit []
klltkr has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
klltkr has joined #lisp
klltkr has quit [Client Quit]
zefram22 has quit [Quit: zefram22]
zefram22 has joined #lisp
zefram22 has quit [Remote host closed the connection]
zefram22 has joined #lisp
vv8 has joined #lisp
ivysaur has quit [Quit: Connection closed]
ivyysaur has quit [Quit: Leaving]
karlosz has joined #lisp
ivysaur has joined #lisp
karlosz has quit [Ping timeout: 252 seconds]
<ivysaur>
hi, is email reg needed to join lispcafe?
<Josh_2>
Whats the fastest way I can read the number of lines in a file?
<Josh_2>
I can do it in about 0.1 seconds using wc -l. Right now I'm using cl-csv to iterate line by line and its doing 100,000 lines maybe every 5 seconds and theres over 13 million
<no-defun-allowed>
Yes, cl-csv is also doing a lot of parsing presumably.
<Josh_2>
yeh I was just thinking that
<no-defun-allowed>
How fast do you care for? A naive solution would be to repeatedly read-sequence into a buffer, counting the number of #\Newline characters (assuming you use Unix newlines, not Windows).
<Josh_2>
I think I will try that now
<Josh_2>
Just curious. Eventually I will have to let cl-csv parse the file
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
<no-defun-allowed>
If that is the case, then just parse it. You'll get a line count too.
<Josh_2>
Its pretty quick to just count the lines the way you said no-defun-allowed
<Josh_2>
Maybe takes 1/2 seconds
<Nilby>
Right now my Lisp version of wc -l takes about 0.1 seconds per megabyte.
<Josh_2>
megabyte?
<Nilby>
or per 100 mb actually
<Josh_2>
more like it :P
<Josh_2>
This file is 1.1G
sp41 has quit [Quit: Lost terminal]
<no-defun-allowed>
I am sure there is some further trickery you can do with, say, mmap-ing the file to bypass the stream interface, and then even some SIMD instructions (basically broadcast #x20, load some bytes from file, compare equal bytes, logcount?) but that's getting too cheeky.
tophullyte has joined #lisp
<Josh_2>
I might be able to just load the entire file into ram, that would probably speed things up
<Nilby>
my wc takes 1.504 seconds to do 1.1 GB
raeda has quit [Quit: Leaving]
Lycurgus has joined #lisp
mindCrime has quit [Ping timeout: 260 seconds]
<Nilby>
Sadly my slow CSV reader takes 51 seconds to read a 1.1GB CSV. I should probably do what no-defun-allowed said and speed it up with mmap and SIMD.
ivysaur has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
Hm, that suggestion was just for counting lines. I don't have a plan for SIMD-ifying CSV parsing, though I guess it's doable.
<no-defun-allowed>
Someone did it for JSON after all.
Alfr has quit [Quit: Leaving]
zefram22 has quit [Quit: zefram22]
zefram22 has joined #lisp
hineios6 has joined #lisp
hineios has quit [Ping timeout: 252 seconds]
hineios6 is now known as hineios
aindilis has quit [Ping timeout: 245 seconds]
hypercube has joined #lisp
prxq_ has joined #lisp
hypercube has quit [Client Quit]
<Josh_2>
sbcl seems to have just given up on me
prxq has quit [Ping timeout: 246 seconds]
remby has joined #lisp
CrashTestDummy has joined #lisp
<Josh_2>
I suppose tomorrow I could try with trivial-mmap
<beach>
Good morning everyone!
CrashTestDummy3 has quit [Ping timeout: 252 seconds]
<Josh_2>
G'mornin
Nilby has quit [Ping timeout: 245 seconds]
zefram22 has quit [Ping timeout: 245 seconds]
<Josh_2>
Well cl-csv gets stuck 6,500,000 entries in
zefram22 has joined #lisp
<Jachy>
Josh_2: is your SBCL's dynamic-space-size high enough?
<Josh_2>
Yep, I set it to 8gb
<Josh_2>
This was some code test my mate was given that he had to do in Java, cant let the CL side down now can I
CrashTestDummy2 has joined #lisp
ebrasca has quit [Remote host closed the connection]
CrashTestDummy3 has joined #lisp
mindCrime has joined #lisp
CrashTestDummy has quit [Ping timeout: 240 seconds]
CrashTestDummy2 has quit [Ping timeout: 240 seconds]
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
CrashTestDummy2 has joined #lisp
tophullyte has quit [Ping timeout: 252 seconds]
CrashTestDummy3 has quit [Ping timeout: 240 seconds]
tophullyte has joined #lisp
zefram22 has quit [Ping timeout: 240 seconds]
aindilis has joined #lisp
semz has quit [Ping timeout: 250 seconds]
tempest_` has joined #lisp
tempest_nox has quit [Ping timeout: 246 seconds]
DHARMAKAYA has joined #lisp
overalls has joined #lisp
tempest_` has quit [Remote host closed the connection]
semz has joined #lisp
tophullyte has quit [Quit: Leaving]
tempest_nox has joined #lisp
Bike has quit [Quit: sleep]
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
DHARMAKAYA has joined #lisp
mister_m` has quit [Remote host closed the connection]
hypercube has joined #lisp
mindCrime has quit [Ping timeout: 252 seconds]
mindCrime has joined #lisp
mindCrime has quit [Ping timeout: 268 seconds]
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
DHARMAKAYA has joined #lisp
raeda has joined #lisp
<jeosol>
Josh_2: I think you can get it to work. I once used SBCL to used a 60GB file (text file) without much problems. You'd probably have to play with the dynamic-space-size though.
thinkpad has quit [Ping timeout: 245 seconds]
thinkpad has joined #lisp
waleee-cl has quit [Quit: Connection closed for inactivity]
sm2n has quit [Remote host closed the connection]
sm2n has joined #lisp
shka_ has joined #lisp
daphnis has joined #lisp
<beach>
phoe: I don't know whether you are aware of this Clojure talk from 2015, but it talks about condition systems: https://www.youtube.com/watch?v=zp0OEDcAro0 The Common Lisp condition system is sort of the model for the "ideas" in the talk.
<beach>
I am not sure whether to be delighted or saddened by what I learned about Clojure in this talk, though of course, it not being a language with an independent standard, it may have changed since this talk.
<phoe>
beach: I am, thank you
<beach>
And what did you think about it?
<phoe>
I watched it a long long long time ago and can no longer say
skapata has quit [Remote host closed the connection]
<beach>
OK, don't worry about it then.
<beach>
The speaker doesn't say explicitly, but he favors what you told the WebAssembly people, namely "give me control structures, not exceptions"
<phoe>
:D
raeda has quit [Remote host closed the connection]
raeda has joined #lisp
andrei-n has joined #lisp
overalls has quit [Ping timeout: 240 seconds]
<beach>
phoe: The other interesting thing about the talk is that he seems to use the same terminology as you have now popularized, i.e., that "exception" and "condition" mean different things.
pillton has joined #lisp
Alfr has joined #lisp
<moon-child>
beach: can not languages with standards change over time?
<beach>
Good question. I would say "not really", because the name would have to be different, at least with a specific version attached. The very purpose of a standard is that it never changes.
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
<beach>
When referring to any standard, one would refer to a particular document that must remain the same forever.
<moon-child>
Hmmm. I think stability is something you can _enable_ (or encourage) with a standard, but that its main purpose is to be an abstract expression of a language's semantics.
narimiran has joined #lisp
Sauvin has joined #lisp
zefram22 has joined #lisp
<beach>
Sure, I am not talking about the purpose of a standard for a particular language. I am just saying that "a standard" means a precise document published at a particular date and that will never change. If you want your language to evolve, it can no longer be referred to as being what that document defines.
<beach>
... so you can change your language, but you can't change the standards document.
Lycurgus has quit [Ping timeout: 240 seconds]
tophullyte has joined #lisp
* beach
should learn to shut up more often.
<jeosol>
beach: I disagree about shutting up; there are those of us that learn from these tidbits ..
<jeosol>
:-)
<beach>
jeosol: Yes, and others who seem to take great pleasure in disagreeing for the hell of it, and that sometimes makes me upset.
<jeosol>
You correct people to use the right semantics and words, each function parameters in the lambda list than variables. While it takes time, getting the right terminology often makes communication easier
<beach>
I totally agree.
<jeosol>
each -> e.g.,
<jackdaniel>
that's where the new standard idea domes in :)
<jackdaniel>
comes*
varjagg has joined #lisp
<imode>
beach: if a language standard never changes... C++?
<imode>
can we never change the kilogram standard then.
<no-defun-allowed>
C++ changes a lot.
<imode>
ah, I'm late to this party and that was already covered.
<imode>
they're definitely different languages.
<jackdaniel>
imode: "updating" common lisp standard is a running gag on this channel :)
yottabyte has quit [Quit: Connection closed for inactivity]
<no-defun-allowed>
you se the problem with CL is that it doesn't have the JavaScript variable hoisting rules, I have a patch to the CLHS which adds the hoisting rules and it will make CL 1000× more popular
<jeosol>
hoisting?
<moon-child>
js has fake lexical scope
tempest_nox has quit [Remote host closed the connection]
<beach>
imode: Clearly, I am not expressing myself very well. There can't be more than one standards document that claims to be THE standards document for C++. Like I said, the language may evolve, but different versions of the language must be defined by different documents.
<pillton>
..and that is what C++ does e.g. C++98, C++03, C++11, C++14, C++17, C++20, ... You are making perfect sense beach.
<beach>
pillton: Thanks! (Whew!)
mathrick has quit [Ping timeout: 260 seconds]
varjagg has quit [Ping timeout: 252 seconds]
<imode>
dynamic scoping is nice.
gzj has joined #lisp
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
thomasb06 has joined #lisp
pillton has quit [Quit: ERC (IRC client for Emacs 27.2)]
tophullyte has quit [Ping timeout: 245 seconds]
zefram22 has quit [Ping timeout: 252 seconds]
gaqwas has quit [Ping timeout: 252 seconds]
ikrabbe has joined #lisp
<remby>
must be tough for a compiler to enforce that :P
<beach>
remby: To enforce what?
<remby>
which versions of the C++ standard are in use
semz has quit [Ping timeout: 245 seconds]
overalls has joined #lisp
<no-defun-allowed>
Technically, I suppose you are supposed to use C++20 as of last December.
<jackdaniel>
ANSI C 89 for the win! :)
<jackdaniel>
that said, even C standard evolves (imo in saner direction than C++ standard)
<remby>
but I suppose the standards are backwards compatible so it's not bad?
<moon-child>
not completely compatible, but largely so
<remby>
so you can use features from C++ 20 in a C++ 03 codebase
<jackdaniel>
say you introduce a new reserved keyword, like _Complex
<jackdaniel>
and the old code uses the name _Complex as a variable name - it won't work
<remby>
oof
<moon-child>
jackdaniel: spec reserves __* and _[A-Z]*
<jackdaniel>
but languages are very similar, so usually a minimal amount of porting is needed
<moon-child>
so if your code was using that previously it was technically nonconformant
<jackdaniel>
mhm
<remby>
I guess C++ will become a lisp eventually :P
<moon-child>
however, there were actual (small) compat breaks. E.G. removal of gets, making vlas an optional feature
<moon-child>
remby: greenspun's law comes to mind
<moon-child>
as well as steele quote about java
sukaeto has quit [Quit: WeeChat 1.6]
<remby>
oh, what was the steele qoute?
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
<moon-child>
'And you're right: we were not out to win over the Lisp programmers; we were after the C++ programmers. We managed to drag a lot of them about halfway to Lisp. Aren't you happy?'
contrapunctus has joined #lisp
<remby>
also this trend when it comes to growing languages I do seem to notice ... it's almost nefarious even
<remby>
ah nice haha
gzj has quit [Quit: Leaving]
<moon-child>
though phoe also points out that they also dragged a lot of lisp people about halfway back to c++. ¯\_(ツ)_/¯
<remby>
I get competing compilers, but competing languages? mysterious
<no-defun-allowed>
"Notice that no one mentions that this way they also managed to drag a lot of Lisp programmers about halfway back to C++." — phoe
<Jachy>
Many C++ devs were already using the new features anyway in the form of things included in the Boost library, so for a lot of shops it hasn't been too bad
<remby>
I see
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
<remby>
would you consider the lisp special forms to be statements?
<remby>
or can those be done in lisp too
<no-defun-allowed>
No, Lisp special forms are still "expressions" like anything else.
<jackdaniel>
afair the standard says that special operators may be implemented as ordinary functions (and it is at the implementer's discretion)
daphnis has quit [Ping timeout: 265 seconds]
<no-defun-allowed>
IF is a special form, but it still returns a value unlike a "statement", e.g. (if t 1 2) ⇒ 1
daphnis has joined #lisp
OlCe has joined #lisp
<beach>
remby: The term "statement" is used in Common Lisp only to mean the elements of a TAGBODY that are not labels.
<remby>
beach, ok
<remby>
do implementations actually implement stuff like IF as functions?
<remby>
just curious
<beach>
No.
<jackdaniel>
that would be inefficient
<beach>
But some special operators my be implemented as macros.
<no-defun-allowed>
I thought the standard said special operators may be implemented as ordinary functions, not macros.
<beach>
Oh?
<jackdaniel>
I've meant operators, not functions (when I've said the thing above)
<no-defun-allowed>
Oh crap, I mean the other way around. The opposite of what jackdaniel said.
<beach>
Yes.
<jackdaniel>
braino:)
<no-defun-allowed>
I forgot what I was doing while copying what jackdaniel said :)
<beach>
remby: Most (all?) special operators are considered as such because they have an evaluation rule that does not allow them to be functions.
bitmapper has quit [Quit: Connection closed for inactivity]
<beach>
remby: Some other standard operators that also can't be functions, but that could be implemented using other operators, are defined to be macros.
semz has joined #lisp
<remby>
I see
<beach>
remby: So as special operators, you are left with those operators that are truly basic, and that can't be expressed as functions.
<beach>
There are a few exceptions to that rule, but not many. Like LET* could be expressed as a macro expanding to nested LETs, but it would be a messy macro because of declarations.
zaquest has quit [Remote host closed the connection]
zaquest has joined #lisp
ikrabbe has joined #lisp
thinkpad has quit [Ping timeout: 246 seconds]
monolithic has joined #lisp
thinkpad has joined #lisp
zefram22 has quit [Ping timeout: 240 seconds]
flazh has quit [Ping timeout: 240 seconds]
zzappie has quit [Ping timeout: 240 seconds]
zzappie has joined #lisp
gzj has quit [Remote host closed the connection]
nij has joined #lisp
<nij>
Hello :) Is there a way to automatically dump the "closure" for a function? For example, for #'f as in (defun f (x) (g x)), the dumping should pull the information of #'g as well, and so on. The goal is to get the minimal data that reproduces #'f at the moment it's dumped.
<beach>
What is the meaning of "dump"?
<jackdaniel>
nij: do you mean "serialize to file"?
<nij>
jackdaniel: not necessarily to a file
<nij>
but yeah, that'd be a proof of concept
<nij>
beach: by dump i mean to create something that can reproduce #'f (at the moment of dumping) later
<jackdaniel>
there is no such way, g may be a function that is loaded without its source form
<beach>
nij: What is the meaning of "reproduce"?
<beach>
"define", "execute", "print"?
<nij>
beach: By reproduce I mean to have an entity that gives the same result as #'f would at the moment of being dumped.
<Odin->
You'd need the ability to a.) get at the source of each function and b.) get at the lexical environment closed over by each closure, I think.
<Odin->
And I think neither of those is covered by the standard.
<nij>
jackdaniel: Hm. But if we can get the source, then that's possible?
<beach>
nij: That would be an undecidable problem.
<beach>
nij: Still not possible. A function can refer to the global environment.
<nij>
Odin-: Yeah.. I'm aware the standard doesn't do this. I'm wondering if it's possible.
<nij>
beach: Oh.. you mean i have to take a copy of the real world..
<beach>
Yes, in general. But that's doable in many Common Lisp implementations.
<Odin->
beach: But the global environment can be changed out from under it _anyway_, right?
<nij>
Then I should modulo my question with real-world/probabilistic content.
<Odin->
That is, if the function relies on the global environment, it's already fragile, no?
<beach>
Odin-: Well, if you do SAVE-LISP-AND-DIE or equivalent, you are sure to have "dumped" it with everything in can refer to.
<nij>
beach: yes, but that's not minimal
heisig has joined #lisp
<beach>
nij: Minimal would be undecidable.
<nij>
Odin-: depends on the context
<nij>
beach: oh, why undecidable?!
<Odin->
beach: Well, not external things. Like I/O streams. Right?
<Odin->
Reduction to the halting problem is always fun.
<beach>
nij: Also, if you have a call to EVAL, then all bets are off, and that could very well be the case.
<beach>
(defun f (x) (eval (read)))
<nij>
The fact that we cannot take a minimal snapshot of some meaningful entities delights /me.
<Nilby>
But it is still useful in practice to try, since most programs are finite and provable.
<nij>
Oops, /me should be the subject.
<nij>
beach: What if I redefine "minimal" as in that everything that shows up in the form needs to be pulled?
<beach>
What you are looking for is the term "conservative approximation".
<nij>
(I just fancy a lisp machine that can communicate functions at one go.)
<nij>
(And the philosophical reason, which is minor but relevant.)
<jackdaniel>
sometimes it is possible to "dump" a function itself, but not functions that are called by it
<ChoHag>
You can in theory create the perfect closure you're referring to, whether you can get at its contents is another matter, but only without run-time mutation.
<Odin->
Wouldn't the presence of 'eval' in the form then drag everything in the image in?
<jackdaniel>
(not portably of course)
<beach>
Defining a conservative approximation is a way to get around undecidability, in effect, but you still have the lack of tools.
<nij>
jackdaniel: if all functions' source codes are remembered, that should be possible?
<nij>
beach lack of tools?
<jackdaniel>
no, because not all functions are written in lisp
<ChoHag>
Odin-: Yes it would include all the "unwritten" assumptions made by the interpreter.
<jackdaniel>
some may be written in assembly for that instance
<nij>
jackdaniel: suppose everything is written in lisp!
<nij>
lisp can be written in lisp as well.. so include that
<beach>
nij: Whatever your Common Lisp implementation provides you with to get the source etc. of functions. Also remember that G can be a closure, so you need to get to its static environment. Few Common Lisp implementations would allow that.
<nij>
i might have to always assume a minimal lisp that's behind
<beach>
nij: G could be defined like this: (let ((y 234)) (defun g (x) (+ x y)))
<Odin->
I mean, even if the interpreter/compiler is written in Lisp, that doesn't mean that it's sensibly available as Lisp from inside the runtime. In any case, you'd run into a bootstrap problem restoring that...
<beach>
nij: We have been through this before I seem to remember.
<ChoHag>
Don't need much to implement the minimal lisp that's behind..
<nij>
jackdaniel: since i'm looking at forms, in that case I just have to remember that foo does that.
<nij>
beach: we stopped at a protocol then
<nij>
I remember people did this through some black magic
<jackdaniel>
it doesn't make sense to me; but that may be my bad
<nij>
when the client needs to evaluate a function
<nij>
it actually asks the server to compute it
<nij>
ChoHag: oh yes , this i agree
<nij>
beach: But I wasn't satisfied by that..
<beach>
nij: The essence was that there is no way to get the source form of such a function.
<nij>
Odin-: hmmmmmmmmmmmm I still don't fully understand.. could you perhaps elaborate more?..
<nij>
beach: that's the de facto, yes
<nij>
But if we force each compiled function to also remember its source code, wouldn't it be possible?
<nij>
We just embed the source code as text in a segment.
<beach>
nij: Again, the (let ((y...)) is not part of the source code.
<Odin->
You need the lexical environment as well.
cipherch1ss has joined #lisp
<beach>
nij: You can have (let ((y 234)) (defun g (x) ...) (defun h (x) (setf y x))) and H could have been called before you want the "closure" of F.
<nij>
Oh.. so it might be unrealistic to require that..
<Odin->
Which, obviously, _is_ kept around, but there's no easy way to get at it.
<nij>
Damn
<nij>
Great food of thoughts. I think I need to think more on this.
<nij>
Indeed there are lots of failing point.
<Odin->
Oh, and yes, the lexical environments of different closures don't have to be independent ... so you may need to dump multiple functions at a time.
<nij>
Yeah, Odin- .. I'm even thinking how to merge two minimal dumps.
<beach>
Odin-: I think you mean the "static environment", no?
<nij>
but that's even more unachievable i guess
<Odin->
beach: Probably, come to think of the etymology.
<Odin->
beach: That is, I do mean the actual bindings, not just whatever 'let' forms established them.
cipherchess has quit [Ping timeout: 246 seconds]
<beach>
Odin-: Yes, I think it is usually called the "static environment". The term "lexical environment" usually means what is manipulated at compile time.
<Odin->
That's a distinction that makes sense, but I hadn't considered before.
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
cipherch1ss has quit [Ping timeout: 252 seconds]
cipherchess has joined #lisp
cranium_ has quit [Quit: Leaving]
cranium_ has joined #lisp
<flip214>
minion: memo for nature: Sorry, I have nearly zero experience with emacs and slime, so I can't say what you're gonna miss. I'm find with what I have
<minion>
Remembered. I'll tell nature when he/she/it next speaks.
vegansbane6963 has joined #lisp
ikrabbe has joined #lisp
gzj has joined #lisp
<scymtym>
nij: maybe look at pkhuong's "common cold". if i remember correctly, it allows capturing and serializing the lexical environment, but not the transitive closure of called functions you are also looking for. the link seems dead now, but maybe it will be restored: https://irclog.tymoon.eu/freenode/lisp?around=1497521995#1497521995
<nij>
scymtym: that deadlink make me very curious
<scymtym>
nij: even if somebody has a copy, it likely does not do everything you mentioned (and it works only in SBCL)
<nij>
Yeah.. but I think I understand the crux more. I need to think carefully again and make the minimal assumptions for that would work.
<nij>
E.g.. we need to modulo real-world (including randomness) factors, we need to assume all functions remember their source code and lexical env.. which are already nonrealistic.
srandon111 has quit [Ping timeout: 240 seconds]
aartaka has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
aartaka_d has quit [Ping timeout: 245 seconds]
gzj has quit [Remote host closed the connection]
srandon111 has joined #lisp
gzj has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
nij has quit [Quit: ERC (IRC client for Emacs 27.2)]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
daphnis_ has joined #lisp
daphnis has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
theothornhill has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
ikrabbe has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
kevingal has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
aeth has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
Bike has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
aeth has joined #lisp
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
aeth has quit [Ping timeout: 246 seconds]
penguwin7 has joined #lisp
penguwin has quit [Ping timeout: 245 seconds]
penguwin7 is now known as penguwin
amb007 has quit [Read error: Connection reset by peer]
32NAABC2Y has joined #lisp
Oddity has joined #lisp
aeth has joined #lisp
amb007 has joined #lisp
Oddity- has quit [Ping timeout: 245 seconds]
daphnis_ has quit [Ping timeout: 265 seconds]
32NAABC2Y has quit [Ping timeout: 245 seconds]
Lycurgus has quit [Quit: Exeunt]
aartaka has quit [Ping timeout: 265 seconds]
aartaka has joined #lisp
<Josh_2>
jeosol: I gave SBCL 8gb space, still froze up
skapata has joined #lisp
<Nilby>
If you have repitition in your data, you might try converting strings to symbols, and numbers parsed.
Alfr is now known as Guest55772
Guest55772 has quit [Killed (egan.freenode.net (Nickname regained by services))]
Alfr has joined #lisp
<jeosol>
Josh_2: Oh really? Hmm. It is one-off task or something you'd have to do repeatedly. In my case, I had to extract several large 3d arrays (5 million elements) from the scattered data, so I got a file-stream to the file, and used do loop and cl-ppcre to match certain parts of the file and extra data afterwards
<Josh_2>
I'm basically just messing about with a code test my friend had
<jeosol>
Josh_2: if the data is well formatted, you can just extract it yourself.
<jeosol>
Oh I see, ok
<Josh_2>
it is well formatted data. At some point today I will mmap the file and just use cl-csv to parse each row individually
<jeosol>
yeah, I think the latter approach should work. For my case, I described, it was impossible to read the whole file so I opted to process it and extra the required data
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
random-nick has joined #lisp
curtosis has joined #lisp
frgo has quit [*.net *.split]
jonatack has quit [*.net *.split]
semz has quit [*.net *.split]
thinkpad has quit [*.net *.split]
cosimone has quit [*.net *.split]
kopiyka has quit [*.net *.split]
mrchampion has quit [*.net *.split]
__jrjsmrtn__ has quit [*.net *.split]
beaky has quit [*.net *.split]
Shinmera has quit [*.net *.split]
TMA has quit [*.net *.split]
Nilby has quit [Ping timeout: 250 seconds]
semz has joined #lisp
thinkpad has joined #lisp
frgo has joined #lisp
jonatack has joined #lisp
cosimone has joined #lisp
kopiyka has joined #lisp
mrchampion has joined #lisp
TMA has joined #lisp
__jrjsmrtn__ has joined #lisp
Shinmera has joined #lisp
beaky has joined #lisp
kmeow has quit [Remote host closed the connection]
daphnis has joined #lisp
gzj has quit [Read error: Connection reset by peer]
gzj has joined #lisp
luckless has quit [Remote host closed the connection]
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
aartaka_d has joined #lisp
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
<splittist>
Josh_2: do you need the full set of extracted data 'in memory'? (I know we keep asking these questions.) If each line is independent (and, if it's CSV, it probably is) then snarfing the whole thing in one hit and keeping it as e.g. strings is awfully general, but probably not what you need, and maybe not what the java version is doing.
aartaka has quit [Ping timeout: 246 seconds]
luckless has joined #lisp
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
zefram22 has joined #lisp
gzj has quit [Remote host closed the connection]
yitzi has joined #lisp
gzj has joined #lisp
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
gzj has quit [Remote host closed the connection]
<Josh_2>
splittist: i think it would be easier to have it all in memory, that way I can play around with it
<Josh_2>
well my friend failed to even load it into Java
gzj has joined #lisp
cosimone has quit [Remote host closed the connection]
<jmercouris>
always preferable to work with CSVs as a stream
<jmercouris>
you don't know how long they will be
<jmercouris>
s/always/frequently
sukaeto has joined #lisp
thinkpad has quit [Ping timeout: 245 seconds]
gzj has quit [Ping timeout: 240 seconds]
_heisig has joined #lisp
thinkpad has joined #lisp
heisig has quit [Ping timeout: 265 seconds]
cosimone has joined #lisp
theothornhill has quit [Ping timeout: 260 seconds]
theothornhill has joined #lisp
thinkpad has quit [Ping timeout: 246 seconds]
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
_heisig is now known as heisig
IPmonger has joined #lisp
aeth has quit [Ping timeout: 240 seconds]
aeth has joined #lisp
thinkpad has joined #lisp
thinkpad has quit [Read error: Connection reset by peer]
waleee-cl has joined #lisp
wsinatra has joined #lisp
aeth has quit [Ping timeout: 240 seconds]
curtosis is now known as curtosis[away]
aeth has joined #lisp
thinkpad has joined #lisp
theothornhill has quit [Remote host closed the connection]
curtosis[away] has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
daphnis has quit [Ping timeout: 265 seconds]
MichaelRaskin has quit [Remote host closed the connection]
cage_ has joined #lisp
<aeth>
Not directly Lisp related, but just a heads up for anyone who doesn't follow nerd news, any @umn.edu email could have been introducing vulnerabilities to your FOSS project for someone's research paper. They have been banned from the Linux kernel for doing so.
gzj has joined #lisp
<aeth>
The details seem to rely on C use-after-free bugs, but some CL implementations are written in C or C++ so that doesn't make this channel immune.
varjag has quit [Quit: ERC (IRC client for Emacs 26.3)]
matty has joined #lisp
gzj has quit [Ping timeout: 240 seconds]
hendursaga has quit [Remote host closed the connection]
MichaelRaskin has joined #lisp
hendursaga has joined #lisp
edvardo_ has quit [Remote host closed the connection]
theothornhill has joined #lisp
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 252 seconds]
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 260 seconds]
zefram22 has quit [Ping timeout: 265 seconds]
<Bike>
given the paper is about linux, i don't see why they would also hit random other projects
bitmapper has joined #lisp
ljavorsk has quit [Ping timeout: 240 seconds]
theothornhill has quit [Ping timeout: 252 seconds]
andrei-n has quit [Quit: Leaving]
theothornhill has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
theothor` has joined #lisp
nature has joined #lisp
theothornhill has quit [Ping timeout: 252 seconds]
CrashTestDummy has joined #lisp
theothor` has quit [Remote host closed the connection]
CrashTestDummy2 has quit [Ping timeout: 268 seconds]
klltkr has joined #lisp
Sheilong has joined #lisp
yitzi has quit [Quit: yitzi]
long4mud has quit [Ping timeout: 240 seconds]
thomasb06 has quit [Remote host closed the connection]
varjagg has joined #lisp
sp41 has joined #lisp
sp41 has quit [Client Quit]
sp41 has joined #lisp
matty has quit [Remote host closed the connection]
hendursaga has quit [Remote host closed the connection]
hendursaga has joined #lisp
f4r59 has joined #lisp
f4r5 has quit [Read error: Connection reset by peer]
cosimone` has joined #lisp
cosimone has quit [Ping timeout: 245 seconds]
OlCe has joined #lisp
cosimone` has quit [Read error: Connection reset by peer]
cosimone` has joined #lisp
srhm has joined #lisp
aeth has quit [Ping timeout: 240 seconds]
ebrasca has joined #lisp
hypercube has joined #lisp
aeth has joined #lisp
<jdz>
Supply chain attacks are all the rage now.
jeosol has quit [Quit: Connection closed]
imode has joined #lisp
gareppa has joined #lisp
gareppa has quit [Remote host closed the connection]
gzj has joined #lisp
curtosis has joined #lisp
curtosis is now known as curtosis[away]
andrei-n has joined #lisp
gzj has quit [Ping timeout: 252 seconds]
yacatuco__ has joined #lisp
_paul0 has joined #lisp
mseddon12 has joined #lisp
docl_ has joined #lisp
Gromboli5 has joined #lisp
casual_friday_ has joined #lisp
jurov_ has joined #lisp
jrm2 has joined #lisp
mrSpec` has joined #lisp
Noisytoot_ has joined #lisp
glamas_ has joined #lisp
markasoftware_ has joined #lisp
kslt1_ has joined #lisp
phadthai_ has joined #lisp
sxmx1 has joined #lisp
Iolo_ has joined #lisp
deltab_ has joined #lisp
snits_ has joined #lisp
quazimod1 has joined #lisp
xlei_ has joined #lisp
Noisytoot has quit [Disconnected by services]
Noisytoot_ is now known as Noisytoot
curtosis[away] has quit [*.net *.split]
Gromboli has quit [*.net *.split]
phantomics has quit [*.net *.split]
notzmv has quit [*.net *.split]
paul0 has quit [*.net *.split]
glamas has quit [*.net *.split]
ukari has quit [*.net *.split]
mrSpec has quit [*.net *.split]
jurov has quit [*.net *.split]
yacatuco_ has quit [*.net *.split]
davros has quit [*.net *.split]
kslt1 has quit [*.net *.split]
sjl has quit [*.net *.split]
quazimodo has quit [*.net *.split]
mseddon1 has quit [*.net *.split]
casual_friday has quit [*.net *.split]
jrm has quit [*.net *.split]
Iolo has quit [*.net *.split]
docl has quit [*.net *.split]
deltab has quit [*.net *.split]
snits has quit [*.net *.split]
markasoftware has quit [*.net *.split]
xlei has quit [*.net *.split]
phadthai has quit [*.net *.split]
sxmx has quit [*.net *.split]
Khisanth has quit [*.net *.split]
Gromboli5 is now known as Gromboli
xlei_ is now known as xlei
jrm2 is now known as jrm
mseddon12 is now known as mseddon1
Iolo_ is now known as Iolo
varjagg is now known as varjag
phantomics has joined #lisp
Khisanth has joined #lisp
davros has joined #lisp
sjl has joined #lisp
DHARMAKAYA has joined #lisp
klltkr has quit [Ping timeout: 240 seconds]
klltkr has joined #lisp
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
tophullyte has joined #lisp
Sauvin has quit [Remote host closed the connection]
hypercube has quit [Quit: WeeChat 3.1]
bitmapper has quit [Quit: Connection closed for inactivity]
orivej has joined #lisp
kslt1_ has quit [Quit: leaving]
saganman has joined #lisp
deltab_ is now known as deltab
ebrasca has quit [Remote host closed the connection]
gaqwas has joined #lisp
kslt1_ has joined #lisp
<sveit>
hi. i was wondering about the semantics of dynamic-extent. is the following an allowed use of dynamic-extent? (let ((x (list 'a))) (let ((y x)) (declare (dynamic-extent y)) (rplacd y 'b)) x)
kslt1_ has quit [Quit: leaving]
<copec>
Does anyone see emacs become slow and laggy after doing a trace on some functions
zzappie has quit [Ping timeout: 240 seconds]
kslt1 has joined #lisp
anticrisis has joined #lisp
cranium_ has quit [Quit: Leaving]
theothornhill has joined #lisp
<jackdaniel>
emacs has a decent performance until its buffers exceed some relatively big size
<jackdaniel>
you may try to C-c o your REPL buffer
<jackdaniel>
sometimes it helps
surabax has quit [Quit: Leaving]
kslt1 has quit [Quit: leaving]
* copec
tries
<Josh_2>
I don't get this, I've given SBCL 8gb dynamic space, it gets about halfway through my dataset and just stops
Duuqnd has joined #lisp
<Shinmera>
How big is the dataset?
<Josh_2>
1.1gb
<Shinmera>
utf8 strings?
<Josh_2>
I'm not sure about that
<Shinmera>
loading that into the native UTF32 strings will already incur a x4 explosion of size about.
<copec>
What is it stopped on if you interrupt the thread?
<Shinmera>
so that's 4.4GB. Then add to that other copies and cruft and that there's space needed for multiple generations, and you might run into GC problems with that set.
<Shinmera>
even at 8GB heap.
<Shinmera>
try increasing it to 32GB or what, even if you don't have that much RAM.
<Josh_2>
Well I can load them as ascii
<copec>
Shinmera: Do you think the request packet is getting lost, so it is just sitting there waiting? https://unaen.org/pb/31h
<Shinmera>
hmm. hard to say.
<copec>
It stops at arbitrary domain names and just sits at the same point (SB-BSD-SOCKETS::CALL-WITH-SOCKET-ADDR
<copec>
I'm not sure if it is at a level that it is up to (proverbial) you to resend requests, or if that is in the ip stack
ebrasca has joined #lisp
<Shinmera>
Maybe, though the library should definitely guard against such problems.
karlosz has joined #lisp
zzappie has joined #lisp
notzmv has joined #lisp
dunk has quit [Ping timeout: 260 seconds]
buoy49 has quit [Read error: Connection reset by peer]
jerme_ has quit [Read error: Connection reset by peer]
sz0 has quit [Read error: Connection reset by peer]
b20n has quit [Read error: Connection reset by peer]
spikhoff has quit [Read error: Connection reset by peer]
alanz has quit [Read error: Connection reset by peer]
casual_friday_ has quit [Quit: %bye%]
CL-ASHOK has joined #lisp
<CL-ASHOK>
I saw some questions in the log re rich text editor & websites with Lisp
mindCrime has joined #lisp
<CL-ASHOK>
For that individual (or anyone else), check out https://writer.math.dev as its a clean rich text editor (you can copy the code from GitHub) which will output to HTML
jerme_ has joined #lisp
alanz has joined #lisp
Lord_of_Life_ has joined #lisp
buoy49 has joined #lisp
b20n has joined #lisp
<CL-ASHOK>
I'm in the process of building a static version of Wordpress via Lisp (basically have a database of content, then get lisp to generate all the html files, then host the html files statically), that could be a good alternative
spikhoff has joined #lisp
dunk has joined #lisp
sz0 has joined #lisp
<kagevf>
CL-ASHOK: do you use nyxt? asking because you could use it to write browser level tests in lisp for your site
<kagevf>
I've been dabbling with that approach recently ... it's fun :)
<CL-ASHOK>
Didn't hear of it until you mentioned it, but looks pretty cool
<CL-ASHOK>
with emacs / vim bindings
<CL-ASHOK>
is it a browser or a command line?
Lord_of_Life has quit [Ping timeout: 260 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<Shinmera>
CL-ASHOK: there's coleslaw for static site generation
<CL-ASHOK>
@shinmera - nice, I hadn't heard of it. I just finished my version at work today :) Very basic version via html-template and some loops
saganman has quit [Quit: tinkerty tonk]
cage_ has quit [Quit: Leaving]
<kagevf>
CL-ASHOK: it's a browser, but you can start a swank server on it and connect to it from emacs
kslt1 has joined #lisp
<CL-ASHOK>
kagevf nice, good to see new browsers coming up, otherwise Chrome & Safari are dominating too much. And Lisp gets a mention in it too :D
<CL-ASHOK>
I'll definitely check it out
<kagevf>
it's written in CL! :)
<CL-ASHOK>
:shock:
<CL-ASHOK>
That's awesome
<Josh_2>
Okay cool managed to parse all that data and I'm barely using any ram
<Josh_2>
using about 1.8gb I think
<Josh_2>
not bad for a 1.1gb file
theothornhill has quit [Ping timeout: 252 seconds]
pve_ has joined #lisp
djuber has joined #lisp
pve has quit [Ping timeout: 260 seconds]
attila_lendvai has quit [Ping timeout: 268 seconds]
pve_ has quit [Ping timeout: 240 seconds]
alanz has quit [Ping timeout: 258 seconds]
<Josh_2>
takes about 2 minutes 20 seconds to convert all 13 million lines
alanz has joined #lisp
anticrisis_ has joined #lisp
DGASAU has quit [Read error: Connection reset by peer]
anticrisis has quit [Ping timeout: 240 seconds]
gaqwas has quit [Ping timeout: 240 seconds]
<CL-ASHOK>
that's fast
<Josh_2>
Would be nice if I could dump the lisp image with all of that data in it
<Josh_2>
save me converting it over and over
<CL-ASHOK>
which persistent store you are using?
albusp has quit [Quit: albusp]
albusp has joined #lisp
<Josh_2>
none
<Josh_2>
It would be cool if SBCL could remember what it had in memory and you dump all of it, dump an image with 1.8gb of data in it
<Krystof>
does save-lisp-and-die not do what you want?
CL-ASHOK has quit [Quit: Ping timeout (120 seconds)]
narimiran has quit [Ping timeout: 265 seconds]
<Josh_2>
how big is a short-float on SBCL?
<mfiano>
The same as a single-float
DGASAU has joined #lisp
<Josh_2>
save-lisp-and-die saves the bare minimum state in order to restore the image, it doesn't dump your ram etc
<Krystof>
um
<Josh_2>
although that would be a cool feature, using your lisp image as a database
aartaka_d has quit [Read error: Connection reset by peer]
<Krystof>
it absolutely does dump the whole of the reachable lisp heap
aartaka has joined #lisp
<Josh_2>
It does? *think*
<Josh_2>
maybe I should give it a try then
aartaka_d has joined #lisp
<jmercouris>
yes it absolutely does
<jmercouris>
and I've used to to preload data into a lisp program
<Josh_2>
I must be doing something wrong, my binary is 50mb, not 1.6gb
<CL-ASHOK>
I haven't used it, but it got some positive feedback online
<mfiano>
Then you aren't holding onto that data and the GC is reclaiming it
<mfiano>
Reference anything you don't want free'd
CL-ASHOK has quit [Quit: Connection closed]
CL-ASHOK has joined #lisp
grnman_ has joined #lisp
akoana has joined #lisp
gaqwas has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
casual_friday has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
<Josh_2>
Well I dont know how to do that persistantly
Spawns_Carpeting has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
<Josh_2>
I tried referencing the variable in my toplevel function but that doesn't work, so idk what i'm supposed to do
<kagevf>
Josh_2: maybe try using defvar?
<kagevf>
to assign it
Spawns_Carpeting has joined #lisp
shka_ has quit [Ping timeout: 240 seconds]
<CL-ASHOK>
Shinmera Is there an easy way to reset all of portables settings so that I can just re-use my own .emacs file?
<Shinmera>
no
<CL-ASHOK>
Cool thanks
mrSpec` has quit [Changing host]
mrSpec` has joined #lisp
mrSpec` is now known as mrSpec
andrei-n has quit [Quit: Leaving]
<Shinmera>
You'll have to make do with putting customisations into config/user.el.
<Josh_2>
kagevf: I used defparameter when I tried
<Josh_2>
Anyway gotta dash
<CL-ASHOK>
Yep, that's what I'm doing. I must have made a mistake in my file somewhere, paredit is no longer working, so need to debug now
aartaka_d has quit [Ping timeout: 240 seconds]
anticrisis_ has quit [Read error: Connection reset by peer]
Duuqnd has quit [Quit: Connection closed]
__jrjsmrtn__ has quit [Ping timeout: 245 seconds]
__jrjsmrtn__ has joined #lisp
nature has quit [Ping timeout: 260 seconds]
Nilby has joined #lisp
CL-ASHOK has quit [Quit: Ping timeout (120 seconds)]
CL-ASHOK has joined #lisp
hypercube has joined #lisp
CL-ASHOK has quit [Quit: Ping timeout (120 seconds)]
gaqwas has quit [Ping timeout: 252 seconds]
CL-ASHOK has joined #lisp
heisig has quit [Quit: Leaving]
<srandon111>
anybody on netbsd here?
CL-ASHOK has quit [Quit: Ping timeout (120 seconds)]
mathrick has quit [Read error: Connection reset by peer]
mathrick has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
random-nick has quit [Ping timeout: 260 seconds]
<kagevf>
if nfs is netbsd, then I guess I am
<kagevf>
ah, nope ... it's freebsd ... nm
CL-ASHOK has joined #lisp
<CL-ASHOK>
Shinmera: Do you know which is the mode which causes all the files to shown in the mini buffer when searching for files C-x C-f? Can't seem to find which mode to disable
Bike has quit [Quit: Lost terminal]
orivej has quit [Ping timeout: 240 seconds]
DGASAU has quit [Read error: Connection reset by peer]
pillton has joined #lisp
DGASAU has joined #lisp
orivej has joined #lisp
<copec>
Shinmera: After doing some poking around with dns-client, it looks like dropped packets is exactly the problem, if a particular dns query udp packet gets dropped along the path, then dns-client just sits forever
<copec>
It doesn't show up until you are going through a list doing a lot of lookups
<copec>
Then you run in the occasional drop
<copec>
I solved it by using dnsmasq locally (macos box)
cosimone` has quit [Read error: Connection reset by peer]
<kagevf>
what was the mode CL-ASHOK ?
<CL-ASHOK>
I think (Ido-mode -1)
<CL-ASHOK>
will do it
<CL-ASHOK>
If you open portacle, and go C-h m, you can see many of the minor modes and then disable them
<kagevf>
does portacle turn ido mode on by default?
<CL-ASHOK>
I also removed smex from some of the portacle settings files, unlikely that was the reason for removing the file suggestions, but perhaps (since I did at same time as Ido)
<CL-ASHOK>
yes I believe it does
<CL-ASHOK>
Now my issue is binding Capslock to Meta on Windows...if anybody knows how (I don't have Admin privileges on my work computer, so can't edit the registry)
<kagevf>
I haven't tried turning on ido mode yet, but will at some point ... heard it's pretty nice
<CL-ASHOK>
I think its pretty good - just my mind at work its hard to get into "full" emacs / lisp mode, so trying to make it as basic as possible
<CL-ASHOK>
since I'm multitasking between ms word / excel / email / emacs and other programs
mindCrime has quit [Ping timeout: 252 seconds]
<kagevf>
CL-ASHOK: did a quick ddg ... it looks like for windows you have to use a 3rd party app to remap keys ... apparently can't even do it in wsl
zzappie has quit [Remote host closed the connection]
<CL-ASHOK>
kagevf: Could you send me the link? Wasn't able to find something when I searched
<CL-ASHOK>
Theres SharpKeys, but that also edits the registry, which I think will reset on my machine (according to my IT Helpdesk)
<Nilby>
CL-ASHOK: AutoHotKey
<Nilby>
If you can install it
anticrisis has joined #lisp
<kagevf>
CL-ASHOK: also "power tools" was another one
CL-ASHOK has quit [Ping timeout: 240 seconds]
CL-ASHOK has joined #lisp
CL-ASHOK has quit [Client Quit]
tempest_nox has joined #lisp
madage has quit [Ping timeout: 240 seconds]
DGASAU has quit [Ping timeout: 240 seconds]
spaethnl has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
anticrisis_ has joined #lisp
rumbler31 has quit [Remote host closed the connection]
vutral_ has joined #lisp
anticrisis has quit [Ping timeout: 240 seconds]
DGASAU has joined #lisp
semz has quit [Ping timeout: 245 seconds]
DGASAU has quit [Read error: Connection reset by peer]
klltkr has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]