<aeth>
pjb: I use org-mode near-daily and it's good for what it is... notes, todo lists, a miniature spreadsheet, etc.
<aeth>
pjb: Markdown is better for generating lightly-formatted HTML, though, imo. In part because it's standardized, unlike org-mode, which has a ton of stuff that's heavily dependent on Emacs (like the spreadsheet functionality that's literally built into its tables)
saravia has quit [Client Quit]
<aeth>
I wouldn't choose org-mode over Markdown for HTML generation, just like I wouldn't choose org-mode over LaTeX for PDFs/books.
saravia has joined #lisp
saravia has quit [Client Quit]
alexanderbarbosa has quit [Remote host closed the connection]
ivansviatenko has quit [Read error: Connection reset by peer]
v0|d has quit [Read error: Connection reset by peer]
saravia has joined #lisp
saravia has quit [Remote host closed the connection]
saravia has joined #lisp
saravia has quit [Remote host closed the connection]
karlosz_ has quit [Quit: karlosz_]
pplzk has left #lisp ["Killed buffer"]
saravia has joined #lisp
permagreen has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 272 seconds]
saravia has quit [Remote host closed the connection]
libertyprime has joined #lisp
ebrasca has quit [Remote host closed the connection]
cosimone has quit [Quit: WeeChat 2.5]
Josh_2 has quit [Remote host closed the connection]
Josh_2 has joined #lisp
jgodbout has joined #lisp
alexanderbarbosa has joined #lisp
theblacksquid has quit [Read error: Connection reset by peer]
<alexanderbarbosa>
anyone knows how to clean previous sbcl custom prefixed instalations files? clean and dist-clean aint that
nil has quit [Quit: Fairfarren.]
jgodbout has quit [Ping timeout: 272 seconds]
nil has joined #lisp
semz has quit [Ping timeout: 264 seconds]
gxt has quit [Ping timeout: 260 seconds]
semz has joined #lisp
semz has joined #lisp
semz has quit [Changing host]
_whitelogger has joined #lisp
<pjb>
alexanderbarbosa: git clean -pfx ?
zotan has quit [Ping timeout: 264 seconds]
zotan has joined #lisp
parab has quit [Quit: parab]
xkapastel has quit [Quit: Connection closed for inactivity]
abhixec has quit [Quit: leaving]
abhixec has joined #lisp
<mrcode_>
does anyone know how to solve a 'warning unused variable autotype_tmp' error from cffi groveller ? seems to prevent loading of a package
<pjb>
/join #lispcafe
<pjb>
add: (declare (ignore autotype_tmp))
<pjb>
mrcode_: warnings should not prevent anything.
<mrcode_>
thx pjb . you're right. seems like the groveller segfaults under sbcl 1.5.5
<mrcode_>
thx for help
mindthelion has joined #lisp
<iarebatm`>
Can anyone recommend a library for parsing arbitrary date/time strings into some sort of standard datetime representation?
<iarebatm`>
simple-date-time seems to recommend local-time, but local-time doesn't parse formats such as "01/01/2019". net-telent-date is marked as deprecated...
techquila has quit [Ping timeout: 250 seconds]
<iarebatm`>
what's the right thing to do in this case, parse out the date parts and construct my own local-time manually?
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
jgodbout has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
abhixec has quit [Quit: leaving]
jonh has joined #lisp
EvW has quit [Ping timeout: 250 seconds]
Necktwi has joined #lisp
Necktwi has quit [Quit: leaving]
Necktwi has joined #lisp
karlosz_ has joined #lisp
_whitelogger_ has joined #lisp
<beach>
Good morning everyone!
karlosz_ has quit [Quit: karlosz_]
refpga has joined #lisp
libertyprime has quit [Ping timeout: 245 seconds]
Josh_2 has quit [Remote host closed the connection]
Josh_2 has joined #lisp
Bike has quit [Quit: Lost terminal]
libertyprime has joined #lisp
vt240 has joined #lisp
<alexanderbarbosa>
:D
torbo has quit [Remote host closed the connection]
superkumasan has quit [Ping timeout: 245 seconds]
<jgodbout>
:)
<jgodbout>
Good evening btw
<beach>
Hello jgodbout.
wigust has joined #lisp
<beach>
jgodbout: For things like registration, you can communicate with minion using /msg.
wigust- has quit [Ping timeout: 268 seconds]
<jgodbout>
should be added to the common-lisp page, generally I just copy/paste
<jgodbout>
ty though
<beach>
ywlcm
Necktwi has quit [Ping timeout: 258 seconds]
<no-defun-allowed>
M-x abbrev-mode
libertyprime has quit [Ping timeout: 246 seconds]
<beach>
no-defun-allowed: Thanks. I usually feel so alone in this quest. :)
<no-defun-allowed>
beach: I should thank you for bringing up the mode though, now I can write `((lambda (x) x) 2) evto 2` and feel slightly less icky by using Unicode arrows.
<beach>
Exactly.
<beach>
It's a mystery to me why it is not used by more people.
Harag has quit [Ping timeout: 245 seconds]
<no-defun-allowed>
`((lambda (x) x) 2) ↦ 2` Emacs has a weird pause when I load any unicode characters though, possibly because it has to load a fallback font since CMU Typewriter Text doesn't have that character.
<beach>
I can't imagine having to type things like "first-class global environments", "Common Lisp HyperSpec", "(admittedly small) family", etc. whenever I want to mention those concepts. :)
FennecCode has joined #lisp
<beach>
... and since I am apparently turning dyslexic, I would make typos trying to type those phrases each time, thereby slowing me down even more.
<no-defun-allowed>
Hm, macOS has an abbrev expander but I always thought it was annoying (since it is bound to autocorrection), which would be handy since Emacs isn't my matrix client.
<beach>
Now, what I would really like is to be able to use the same abbrev expander everywhere, in the editor, on the command line, etc.
<beach>
But that will take another few years, I would think.
<no-defun-allowed>
Excellent! The already half-broken input box on riot.im also breaks macOS's autocorrect too.
<beach>
Hmm.
<no-defun-allowed>
Maybe matrix-client.el is calling again. Anyways, abbrev is very neat, thanks for mentioning it, beach.
<beach>
Oh, sure. It definitely is very useful.
anewuser has quit [Quit: anewuser]
libertyprime has joined #lisp
aeth has quit [Ping timeout: 258 seconds]
waron has joined #lisp
noobineer has quit [Ping timeout: 244 seconds]
_whitelogger has joined #lisp
jgodbout has quit [Ping timeout: 245 seconds]
jgodbout has joined #lisp
refpga has quit [Ping timeout: 246 seconds]
refpga has joined #lisp
jgodbout has quit [Ping timeout: 246 seconds]
Harag has joined #lisp
lalitmee has joined #lisp
zotan has quit [Ping timeout: 252 seconds]
zotan has joined #lisp
<pjb>
beach: the problem, is to remember the abbreviations you used for those in-extenso expressions!
akoana has left #lisp ["Leaving"]
alexanderbarbosa has left #lisp ["ERC (IRC client for Emacs 27.0.50)"]
<no-defun-allowed>
pjb: In that case, you don't lose anything by forgetting all your abbrevs.
Necktwi has joined #lisp
Necktwi has quit [Ping timeout: 246 seconds]
Frobozz has quit [Read error: Connection reset by peer]
Necktwi has joined #lisp
<beach>
pjb: No, that's not a problem. Not for me at least.
<pjb>
I'd be more an automatic completion guy…
<beach>
I use that too. They are not mutually exclusive.
<pjb>
But from what I see how it behaves on smartphones, it's unsatisfactory. Perhaps with a neuralink?
<no-defun-allowed>
It wouldn't need to be so intrusive on a physical keyboard.
<no-defun-allowed>
And a neuralink is probably another 10 years away, given the dumb hype you get from Elon, and would cost more than your computer.
sauvin has joined #lisp
orivej has joined #lisp
libertyprime has quit [Read error: Connection reset by peer]
dale has quit [Quit: My computer has gone to sleep]
Necktwi has quit [Ping timeout: 245 seconds]
Necktwi has joined #lisp
Necktwi has quit [Remote host closed the connection]
libertyprime has joined #lisp
FennecCode has quit [Quit: ERC (IRC client for Emacs 26.2)]
kushal has joined #lisp
Kaisyu7 has quit [Quit: ERC (IRC client for Emacs 26.2)]
mathrick has quit [Remote host closed the connection]
mathrick has joined #lisp
edgar-rft has quit [Remote host closed the connection]
edgar-rft has joined #lisp
gko has joined #lisp
JohnMS_WORK has joined #lisp
froggey has quit [Ping timeout: 248 seconds]
frgo has quit [Ping timeout: 272 seconds]
froggey has joined #lisp
Kaisyu7 has joined #lisp
gko has quit [Remote host closed the connection]
flamebeard has joined #lisp
vlatkoB has joined #lisp
libertyprime has quit [Ping timeout: 268 seconds]
Harag has quit [Ping timeout: 268 seconds]
libertyprime has joined #lisp
Harag has joined #lisp
Lycurgus has quit [Quit: Exeunt]
Ricchi has quit [Read error: Connection reset by peer]
Ricchi has joined #lisp
<JohnMS_WORK>
I'm unable to find any examples of sharing C++ classes with ECL. Does anyone else know of any?
<pjb>
JohnMS_WORK: perhaps you'd want to try clasp?
lalitmee has quit [Ping timeout: 268 seconds]
<JohnMS_WORK>
I can check it out.
aeth has joined #lisp
JohnMS has joined #lisp
JohnMS_WORK has quit [Ping timeout: 268 seconds]
scymtym has quit [Read error: Connection reset by peer]
ltriant has quit [Quit: leaving]
quazimodo has joined #lisp
quazimodo has quit [Ping timeout: 248 seconds]
zotan has quit [Ping timeout: 264 seconds]
zotan has joined #lisp
jprajzne has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
flamebeard has quit [Remote host closed the connection]
gxt has joined #lisp
flamebeard has joined #lisp
lalitmee has joined #lisp
flamebeard has quit [Ping timeout: 272 seconds]
Harag has quit [Ping timeout: 272 seconds]
PuercoPop has quit [Ping timeout: 245 seconds]
PuercoPop has joined #lisp
scymtym has joined #lisp
jasom has quit [Ping timeout: 264 seconds]
flamebeard has joined #lisp
Lord_of_Life has quit [Ping timeout: 268 seconds]
Lord_of_Life has joined #lisp
SaganMan has joined #lisp
schweers has joined #lisp
knicklux has joined #lisp
MrMc has joined #lisp
<MrMc>
How do I create a vector of complex numbers? I am doing the following in SBCL but get a warning (MAKE-ARRAY 1024 :ELEMENT-TYPE 'COMPLEX :INITIAL-ELEMENT (COMPLEX 0 0) :FILL-POINTER 0)
<no-defun-allowed>
What warning?
<jackdaniel>
MrMc:
<jackdaniel>
ops
<MrMc>
the warning is :INITIAL-ELEMENT 0 is not a COMPLEX
<jackdaniel>
MrMc: what you arguably want is element-type (complex float)
flamebeard has quit [Remote host closed the connection]
pnp has joined #lisp
<jackdaniel>
because #c(0 0) is 0
<jackdaniel>
while #c(0.0 0.0) *is not*
<jackdaniel>
if you put (complex 0.0 0.0) as an initial element there will be no warning too, but if you decide on complex floats then specyfing it as element type may help the compiler
<MrMc>
Thanks for the quick response
flamebeard has joined #lisp
<MrMc>
So my definition should be (MAKE-ARRAY 1024 :ELEMENT-TYPE '(COMPLEX FLOAT) :INITIAL-ELEMENT (COMPLEX 0.0 0.0) :FILL-POINTER 0)
pnp has left #lisp [#lisp]
manualcrank has quit [Quit: WeeChat 1.9.1]
orivej has joined #lisp
nanoz has joined #lisp
amerlyq has joined #lisp
<MrMc>
jackdaniel:thanks the warning is gone I used (MAKE-ARRAY 1024 :ELEMENT-TYPE '(COMPLEX
<MrMc>
*** pnp (557327b4@unaffiliated/pnpuff) has left channel #lisp: #lisp
Josh_2 has quit [Remote host closed the connection]
Josh_2 has joined #lisp
cosimone has quit [Quit: WeeChat 2.5]
xristos has joined #lisp
xristos has quit [Client Quit]
MrMc has joined #lisp
cosimone has joined #lisp
cosimone has quit [Client Quit]
cosimone has joined #lisp
cosimone has quit [Client Quit]
xristos has joined #lisp
<MrMc>
I am trying to use (bordeaux-fft:fft source) and get an error: debugger invoked on a TYPE-ERROR in thread The value #(#C(-1197.0d0 2047.0d0) .... ) is not of type (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*))
<jackdaniel>
are you sure your array is simple? (i.e it is not displaced or anything)
<no-defun-allowed>
You might get some slack from bordeaux-fft using bordeaux-fft:sfft, but otherwise it expects an array with :element-type (complex double-float).
<no-defun-allowed>
For example (bordeaux-fft:sfft #(1 1 1 0 0 0 0 0)) works fine.
<MrMc>
The array I am passing to the function is created as folows (make-array samples-to-allocate :element-type '(complex double-float) :initial-element (complex 0.0d0 0.0d0) :fill-pointer 0)
<no-defun-allowed>
Yeah, a fill pointer will make an array non-simple IIRC.
<no-defun-allowed>
Are you sure you need it? It looks you likely know how many samples you are going to transform.
<MrMc>
I will remove the fill-pointer
<no-defun-allowed>
Then you have a simple-array and bordeaux-fft:fft will be happy.
refpga has quit [Ping timeout: 248 seconds]
papachan has joined #lisp
refpga has joined #lisp
<MrMc>
no-defun-allowed:removing the fill pointer did not resolve my problem but bordeaux-fft:sfft works
Necktwi has joined #lisp
lucasb has joined #lisp
dddddd has joined #lisp
<ebrasca>
Hi
gravicappa has quit [Ping timeout: 268 seconds]
gravicappa has joined #lisp
gareppa has quit [Quit: Leaving]
<beach>
Hello ebrasca.
<LdBeth>
Good evening
<ebrasca>
Do you think whe can have documentation like in open genera?
<beach>
It is being worked on.
<beach>
jackdaniel has done some work on a CLIM-based documentation system. Either way, something like that (Concordia, was it?) would have to be defined to be used in something like CLIM, and McCLIM is quite usable now.
<LdBeth>
Good to know that. But Concordia was based on ZEWI
<LdBeth>
So I think the first thing to work on is get a Zmacs replacement.
<beach>
I would like to see an IDE based on McCLIM...
<beach>
with a listener (which we already have) that can do much more than SLIME, ...
<beach>
an inspector (which we also have) that can do much more than the SLIME inspector, ...
<beach>
an editor (that we don't have, but it is being worked on) that can do much more than Emacs can for Common Lisp code, ...
<beach>
and a debugger (that we don't have, and for which we only have some ideas) that would be worthy of the name, unlike what we now have.
pv^ has joined #lisp
<jonatack>
gd
<beach>
hl
* beach
is assuming, perhaps incorrectly, that "gd" means "good day" or something like that.
<LdBeth>
beach: about the debugger, are there any source we can get the idea from?
<beach>
LdBeth: Only minor stuff. But let me show you the specification instead. Hold on...
<jonatack>
beach: cheers, typed a git diff alias in the wrong window :)
<beach>
LdBeth: metamodular.com/clordane.pdf
<LdBeth>
Thank you
<beach>
Only 20 pages so far, but the basic idea is there.
<jackdaniel>
right now I'm working on an exciting game in CLIM
<jackdaniel>
it is called checkers!
<beach>
Heh!
EvW has joined #lisp
<jackdaniel>
and will be used to illustrate how approximation works in a terminal backend
<jackdaniel>
(fwiw dragging circles works)
<jackdaniel>
/in a terminal/
<beach>
LdBeth: There are two main ideas with Clordane. One is that I want a debugger to much more than something that lets me examine a backtrace when things go wrong. I also want to be able to set breakpoints, including in some system code. The other is that I want it to be possible for one thread to debug the code in another (or several other) threads in the same image.
<beach>
jonatack: Ah, OK. Heh.
<beach>
jonatack: Are you new here?
<jonatack>
beach: on this channel, yes
lalitmee has quit [Ping timeout: 248 seconds]
<beach>
OK, welcome then.
<jonatack>
ty
pv^ has left #lisp [#lisp]
<p_l>
jackdaniel: that's with pure characters, not anything fancy?
<jackdaniel>
p_l: I'm using ansi escape codes in terminal backend
<jackdaniel>
so colors - yes, sixels - no
<jackdaniel>
mouse tracking works via sgr extension
frgo has joined #lisp
Josh_2` has joined #lisp
Necktwi has quit [Ping timeout: 246 seconds]
Josh_2 has quit [Ping timeout: 272 seconds]
mindCrime has joined #lisp
Josh_2` has quit [Client Quit]
Josh_2 has joined #lisp
<beach>
Oh, and the IDE should obviously contain ways of accessing the documentation in various ways: choosing from menus, clicking on code parts, etc.
<beach>
... which is why I brought up the IDE in the first place.
<LdBeth>
beach: pop up tooltips?
<beach>
Sure, why not.
Bike has joined #lisp
<schweers>
beach: the common lisp editor you’re working on has no UI yet, correct?
<beach>
It does.
<schweers>
What kind?
<LdBeth>
McCLIM, of course
<beach>
It is a McCLIM application, but I tried to make it independent of the UI library.
cosimone has joined #lisp
<schweers>
Ah, cool
<beach>
LdBeth: The thing about a Zmacs-like is that it is not that simple to do. For example, heisig is working on Trucler that provides incremental lexical environments. Those are needed for a sophisticated analysis of the code. And then it needs support from a compiler too, because only a compiler can determine the role of each expression in the code.
<beach>
LdBeth: And scymtym is maintaining Eclector, which is going to be used to parse the code in the buffer.
<beach>
Then that code will be "compiled" using Trucler incremental environments, either by a native compiler or by Cleavir.
mindCrime_ has joined #lisp
LiamH has joined #lisp
warweasle has joined #lisp
<beach>
Then, errors and warnings signaled by the reader and the compiler need to be handled and presented to the user as appropriate feedback.
<beach>
All this at typing speed.
mindCrime__ has joined #lisp
mindCrime has quit [Ping timeout: 248 seconds]
<beach>
LdBeth: As you can see, there are a lot of mutual dependencies here, and all the modules are being worked on. But getting them all done and working together is going to take some more time.
mindCrime_ has quit [Ping timeout: 244 seconds]
nullman has quit [Ping timeout: 272 seconds]
nullman has joined #lisp
MrMc has quit [Ping timeout: 245 seconds]
fitzsim has joined #lisp
<LdBeth>
beach: yes. I’m planning on a tool help deriving code from specification and documents and keep docs updated with them. All these seem can be fit into my design, but I should keep up with the progress now
<beach>
Sounds like a very useful thing.
<beach>
I think I have seen examples of your work. You must have exposed some examples.
jonatack has quit [Ping timeout: 245 seconds]
<beach>
scymtym: Speaking of which, did you ever get around to extracting that new function in Eclector, the one that reads either something that can be returned or something that is skipped?
<beach>
scymtym: As it turns out, in Second Climacs I couldn't find a suitable way of customizing the SICL reader to do what I need, so I copied the main reader function and modified it. That solution is clearly undesirable, so I would like to rip out that code and replace it with Eclector at some point.
Necktwi has joined #lisp
<ebrasca>
beach: You have someting in mind for climacs , have you read someting about lem?
<dlowe>
another name would be a good start
<ebrasca>
dlowe: What do you mean with another name?
<beach>
ebrasca: Yes, but it looks like a traditional Emacs clone.
v0|d has joined #lisp
<ebrasca>
beach: Can you explain what climacs is?
<beach>
ebrasca: Some people feel queasy about the word "climax".
* ebrasca
is searching what "climax" is.
<LdBeth>
GG
<jackdaniel>
it is an orgasm
<beach>
ebrasca: In American English, it means "orgasm", and in Russian it means "menopause".
<v0|d>
lol.
<v0|d>
i bet there is menoplay.
<ebrasca>
But google say it is "culminate in an exciting or impressive event"
<beach>
ebrasca: I'll explain the plan for Second Climacs. The plan is to use a very efficient buffer implementation, and to use the Common Lisp READ function to parse the contents of the buffer, as opposed to using regular expressions. Then the result of parsing the buffer will be handed to the compiler, for further analysis, all at typing speed.
<v0|d>
jackdaniel: hey sup?
<beach>
ebrasca: yes, technically that's all it means.
<jackdaniel>
v0|d: I'm fine, thank you
<ebrasca>
beach: It sound strange.
<v0|d>
jackdaniel: :)
<v0|d>
jackdaniel: does it make sense to make an ecl binary as an efi app?
<v0|d>
i am thinking about it for a while still couldn't get a proper use case.
<beach>
ebrasca: What does?
<jackdaniel>
ecl depends on posix features. unless you put a posix system in your bios it will be hard
<v0|d>
jackdaniel: I know.
<ebrasca>
beach: Does it auto compile when you end someting?
flazh has quit [Quit: flazh]
<beach>
ebrasca: It is supposed to do all this for every character typed.
aoeu256 has joined #lisp
<beach>
ebrasca: So that the feedback will be instantaneous and without any particular keystrokes on the part of the user.
<v0|d>
jackdaniel: i am interested in possible use cases
<v0|d>
let me know if you think a nice one:0
<jackdaniel>
I'm not a big fan of efi myself, so I doubt I'll find any
<LdBeth>
Emacs does that by saving file to disk and call the lint tool on it, which makes me worried about my disk life
<ebrasca>
beach: Can you destroy your system with it? (Like if you editing tcp of your system and you are working remotely on it.)
* ebrasca
is afk , he goes to buy someting and come back later.
<beach>
ebrasca: There are various ways of protecting against such problems.
<LdBeth>
If TCP is handled by a service manager it could be probably restarted, for example
<p_l>
v0|d: it's possible to build ECL as EFI app, though it might take some wrangling in libs
<p_l>
it would be statically linked, though
<beach>
LdBeth: Emacs doesn't analyze Common Lisp code at typing speed. Maybe it does it with some other language.
flazh has joined #lisp
<p_l>
(unless you implement your own dynamic loader, afaik)
<v0|d>
p_l: yeah it sounds to me like porting ecl to DOS 6.22
<v0|d>
yet other than building a bios configurator, no use cases :(
<LdBeth>
beach: I was talk about another language, haven’t made that clear
<beach>
Got it.
<p_l>
the difference is that instead of crappy mishmash of CP/M emulation you're getting interesting API and modern environment
<v0|d>
p_l: don't say, 1k pages of API, read it.
<p_l>
v0|d: you could do more things at EFI level, including things like diagnostic software
<p_l>
v0|d: I've read EFI API
<p_l>
and source code
<p_l>
(first time ~2001?)
<v0|d>
p_l: I share your pain.
<p_l>
no pain there
<v0|d>
heh ok.
saravia has joined #lisp
<p_l>
v0|d: the biggest issue, IMO, is intel pulling bytecode compiler behind expensive license, so bytecode use dropped heavily
<p_l>
and of course GNU didn't care
<v0|d>
so does that mean I cannot write my interpreter in lisp for efi bytecode?
<v0|d>
wow, didn't know that.
<p_l>
you can
<p_l>
it's just that you need to write your own compiler for it
<p_l>
because the only available tools stopped being available for free and now involve hefty license fee
<v0|d>
what 'bout iasl?
<p_l>
the interpreter is open source
<p_l>
v0|d: that's a different bytecode
<v0|d>
i know, does the same apply to it?
<p_l>
no
jonh has left #lisp ["WeeChat 1.9.1"]
<v0|d>
thank god.
<p_l>
for ACPI, intel open sourced their tools
<p_l>
for EFI, the compiler was originally free-as-in-beer included with EFI 1.10 devkit
Necktwi has quit [Ping timeout: 272 seconds]
<v0|d>
how come the name Uefi than?
<p_l>
the devkit remained open source (though was hard to find for some time) but the compiler ended up with high license fee
<p_l>
v0|d: significant changes between 1.10 and 2.0 which also became something actually deployed to more than just Itanium or experimental boards
Lycurgus has joined #lisp
<p_l>
then they put whole reference implementation (also place where some vendors put their extensions) as open source again, with all the changes since 1.10
<p_l>
(that's TianoCore)
<v0|d>
see. that what you've been calling as *read* right?
<v0|d>
i mean the tiano.
<p_l>
I had the devkit in 2001-2002 or so
<p_l>
for EFI 1.10
<p_l>
when TianoCore became available, I of course updated :)
dale_ has joined #lisp
dale_ is now known as dale
<v0|d>
p_l: thnx, you've been most helpful.
<p_l>
v0|d: part of the complexity of UEFI API is that, like in Lisp or Smalltalk, it's very late-binding
jonatack has joined #lisp
<v0|d>
umm?
<v0|d>
late as in runtime services are late?
gareppa has joined #lisp
<p_l>
v0|d: late as in "linking happens late at runtime"
FreeBirdLjj has joined #lisp
<LdBeth>
Or you mean dynamic typing
<p_l>
and the "set of symbols and packages" changes dynamically
<LdBeth>
I see
<p_l>
LdBeth: no, the typing is static~ish
<v0|d>
p_l: you must be refering to system table
<v0|d>
its seems like a gc root to me but nothing else.
<p_l>
you have "protocols" which have static definitions (essentially an array of function pointers), and which are identified by GUID
<p_l>
v0|d: oblist/obarray in older lisps served similar dual purpose
<p_l>
or in SBCL, the global database (iirc?)
<v0|d>
interesting.
<p_l>
COM, CORBA could be considered to have similar approach in many a place
<p_l>
anyway, it's very nice in the sense that you can for example write a disk editor that will understand the same kind of disks that your firmware supports, without actually caring about details other than "block device"
<p_l>
something impossible to fully do on BIOS
<v0|d>
p_l: my eyes bleed when I see those new bios config screens, they are better than win3.1
<p_l>
v0|d: some people go crazy on designing them, yes. OTOH, UEFI having a gui toolkit built in means I could actually safely use serial terminal to configure everything on several machines I managed in the past
<p_l>
becuse you have a toolkit for defining menus, variables available for editing, things like that, and this is then consumed by a component which renders it on console
<p_l>
most people see whatever graphic monstrosity was made to skin it by vendor...
<v0|d>
p_l: heh, a 14.4k BBS perhaps?
<p_l>
I enjoyed the fact that there's a built in so-called VT-UF8 renderer
<p_l>
*VT-UTF8
<v0|d>
llvm ir is so common these days, why don't uefi use it, maybe i'm wrong that llvm doesnt do real 16 code, and this sentence doesn't make sense.
<p_l>
v0|d: LLVM is compiler tech, and its bitcode is not actually hw independent
<p_l>
plus it didn't exist when EFI started out
<p_l>
both FCode and EFIBC are better fits for OPROMs than LLVM bitcode
<p_l>
(hell, x86 real16 code was better choice than LLVM bitcode, because you could reasonably write an emulator for that, and LLVM bitcode is extensible)
<v0|d>
p_l: i agree but since only we are old :p
<v0|d>
nobody knows how to code16 these days.
<v0|d>
ask what a cr0 is.
<p_l>
it's also shitty environment, so there
<p_l>
:P
<v0|d>
i am blamed daily for not knowing pythong programming.
<Josh_2>
good
<Josh_2>
let people be mad
<p_l>
I switched to saying "If it's algol derived I probably can write it, and very probably read it"
khisanth_ has quit [Ping timeout: 272 seconds]
smazga has joined #lisp
<v0|d>
i might try to write an acpi shell in lisp.
<v0|d>
it sounds like a phun project.
<p_l>
more like UEFI. ACPI bytecode itself isn't that capable, even if it's theoretically turing complete (so is x86 page fault...)
<v0|d>
haha.
<ebrasca>
beach: I am back!
gareppa has quit [Quit: Leaving]
Mandus has quit [Ping timeout: 248 seconds]
Mandus has joined #lisp
<ebrasca>
beach: I am making mezzano updates, I like to get some ideas!
<beach>
Good.
Oladon_work has joined #lisp
<ebrasca>
beach: I think you can see more abstract than me.
<beach>
ebrasca: Possibly. I have many years of training and experience.
Lycurgus has quit [Quit: Exeunt]
<ebrasca>
beach: I have some experience and i don't think I have good abstract vision!
<beach>
ebrasca: The literature claims anything can be learned.
<beach>
ebrasca: "experience" does not come by itself with time. It takes active work.
<beach>
ebrasca: But people often need some initial training in order to know how to learn in an efficient and effective way.
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
<Josh_2>
oof
<Josh_2>
someone should probably show me that xD
<Josh_2>
I have about tree fiddy
<beach>
I frequently say something like "in software development, many developers don't have 5 years of experience, but 1 year of experience 5 times". Because they don't learn from it.
<beach>
So even after a very long activity, they don't have much experience.
beach` has joined #lisp
<Oladon_work>
beach: Yes! I keep running into that while trying to hire! :)(
<Oladon_work>
:( rather
lalitmee has joined #lisp
<dlowe>
you know what I find weird is that I never see job openings for more than 5 years experience
beach has quit [Disconnected by services]
beach` is now known as beach
<dlowe>
Like, do you want your applicants to all be 29?
flamebeard has quit []
<dlowe>
Don't you have jobs that could use people with 15 years experience? 20?
<beach>
Oladon_work: I see, yes.
<Josh_2>
beach: what do you mean?
<beach>
Josh_2: By what?
<beach>
Sorry lost connection for a short while.
<Josh_2>
"in software development, many developers don't have 5 years of experience, but 1 year of experience 5 times"
<Oladon_work>
dlowe: I actually hate "years of experience" as a metric, partly because of the "1 year of experience 12 times" issue, but also partly due to the fact that people learn and grow and _experience_ at different rates
<beach>
Josh_2: It's a way of saying that people don't learn and train themselves according to what they did in the past.
<p_l>
dlowe: dunno, I'm currently banking of bedazzling people with "I have as many years of experience as the *TERM* is used"
papachan has quit [Quit: Leaving]
<Josh_2>
beach: yes I understand that, but what is that like in practice?
<Oladon_work>
dlowe: Unfortunately, I haven't been able to figure out a way around using it to weed out all the brand-spanking-new "developers" who just graduated from a coding school and think they're qualified for a senior developer role.
<Josh_2>
5 different jobs doing 5 different things?
<Oladon_work>
Josh_2: Obviously not beach, but typically I see it when someone's been doing the same thing, over and over and over again, for x years
Necktwi has joined #lisp
<p_l>
Oladon_work: pretty hard to do without actually going to interview
<beach>
dlowe: That would require management to realize that this kind of experience is needed. And they usually don't.
<Oladon_work>
No learning, no growing, etc.
<p_l>
and long term experience apparently tends to go into consulting
<Oladon_work>
p_l: Eh, it does help with weeding people out, but I assume you're saying hard to replace it without going to an interview — that's what I've found, but I'm still hopeful that I can discover a way :)
<beach>
Josh_2: They stick to the same language category. If they program in (say) C++, they don't try out a language with automatic memory management, or a dynamic language. They assume all languages are basically the same. They don't analyze their mistakes to improve in the future.
<beach>
etc, etc.
<p_l>
when outside of FAANG 10 years of experience tends to not get you anything better than if you had 3y of experience....
<Josh_2>
hmm alrighty
<Oladon_work>
Ugh, FAANG.
* Oladon_work
has a very low opinion of FAANG developers in general.
<Josh_2>
I have used C++ and Java, I do not like them compared to CL :P
<p_l>
Oladon_work: there's a big variety there
<Oladon_work>
I'm sure there is
<Josh_2>
What is FAANG?
<p_l>
for example, I'm starting to get why first three rungs of hierarchy at Google involve "promoted or out"
<Oladon_work>
But my experience with them thus far is (limited, but) that they all drink the Kool-Aid and think they've been working with "the best of the best" at <company>
<dlowe>
Josh_2: the top paying tech companies
<Oladon_work>
That does all sorts of things to one's world view
<p_l>
Oladon_work: some of them even have best-in-class in many areas
<dlowe>
Oladon_work: just because the best people work at a place doesn't mean you're one of them
<p_l>
but are siloed
<Oladon_work>
For one, it means that if you saw something not working at <company>, it can't possibly work anywhere
<Oladon_work>
dlowe: Of course not, but they're told they are
<p_l>
Oladon_work: people who end up at FAANG straight from uni where they didn't do much work outside of coursework are worst
<Oladon_work>
Yeah
<p_l>
Oladon_work: OTOH, I figure it's exactly why L3 and L4 (with new grads starting at L3) aren't levels you can stay at at Google
<dlowe>
I can't imagine the warped perspective that would come from being hired right from education
<Josh_2>
facebook amazon apple netflix google
<Josh_2>
I see
<dlowe>
p_l: you can stay at L4 now
<Oladon_work>
I'm looking forward to when I can afford to hire promising juniors and train them up myself (well, I and my team)
<Josh_2>
:O
<Josh_2>
You can whip me xD
<Oladon_work>
In the meantime, I'm stuck looking for really good _actual_ senior developers... and finding people who think they're "senior" because they've been doing it for 2 years.
<Oladon_work>
sigh
<Josh_2>
I'll make cups of tea and say nice things sometimes
<Oladon_work>
Josh_2: Heh
<Josh_2>
xD I'll know my place
rippa has joined #lisp
<beach>
Josh_2: I often give talks to people who have been working for many years with software development. But they have no idea about the difference between static and dynamic languages, and they have no clue how a static memory allocator works, nor how automatic memory management works. They know nothing about compiler design, so they have no clue about the relationship between the code they write and what ends up being executed by the
<beach>
processor.
<Josh_2>
hmmm
<beach>
So they think that a dynamic language has to be interpreted, and they think manual memory management has no cost and no pauses, whereas they think that automatic memory management is expensive and gives long pauses.
refpga has quit [Read error: Connection reset by peer]
<Josh_2>
I see
<beach>
I mean, how could they miss something like that after (say) 5 years of working.
<beach>
That is a disgrace.
refpga has joined #lisp
<schweers>
beach: please tell me that at least the part of not knowing about the differnce in static and dynamic languages is hyperbole.
<dlowe>
I too have seen plenty of people who have that assumption
<beach>
schweers: They sometimes know about the difference between static and dynamic *typing*, but I am talking about the separation (or no separation) between compile time and run time.
<schweers>
dlowe: which assumption? The one about memory management?
<schweers>
If that’s what you mean it sounds more realistic. Still pretty sad.
<schweers>
Probably the fault of our education system.
<beach>
Nope, not only.
<beach>
They just don't do any studying on their own.
<beach>
They read no books, no papers, nothing.
<schweers>
Oh right, years of experience. Yeah, then it’s their fault.
<Josh_2>
can't say I read papers, I wouldn't even know where to start
<Josh_2>
but I do try to read books, currenly only CL stuff tho
<Josh_2>
so much to learn!
jprajzne has quit [Quit: Leaving.]
igemnace has quit [Read error: Connection reset by peer]
Necktwi has quit [Quit: leaving]
igemnace has joined #lisp
<schweers>
I still find an idea that Steve Yegge put forth at some time quite interesting. According to him, many programmers only know a single language (or few languages which are very similar to each other). They think that learning a second language will be as hard as learing the first. During this time they will be unproductive and hence they fear for their livelihood.
<Oladon_work>
The second language (as with human languages) is generally _almost_ as hard as the first, minus the concepts you learn the first time around which aren't language-specific
<Oladon_work>
The thing I encounter a lot is people who claim to know multiple languages, but write them all as if they're the same
<ecraven>
Oladon_work: ah, but aren't those concepts very close for most mainstream languages?
<beach>
schweers: I don't think most developers even think that much about what they know and what they should learn.
<schweers>
ecraven: the key may be: mainstream
<Oladon_work>
ecraven: Many concepts are shared across all languages
<Oladon_work>
ecraven: Those concepts don't have to be re-learned when learning a second language — but they also aren't technically part of learning the first language
<schweers>
Learning a new language is also not a thing you do while dropping everything else, although it does help to have proper time and attention for this task.
<beach>
schweers: I tell the industry people I give talk to, to take 4 hours per week for self study.
<beach>
Say, Friday afternoon.
<schweers>
Do you know whether or not this advice is followed?
<beach>
Probably not.
<Josh_2>
How one can sit down and do one thing for four hours
<beach>
If their manager does not allow that, then the manager does not have the best interest of the company and its stakeholders in mind.
<Josh_2>
baffling
<beach>
Josh_2: Did I say "one thing"?
<schweers>
I then do wonder why they bothered to listen to you in the first place.
<Josh_2>
no
<beach>
schweers: Someone bought food.
<schweers>
I mean: why did the company ask you to give that talk in the first place? They could have enjoyed the food without you :D
<beach>
schweers: I also tell them that there is such a huge difference in productivity between developers and that this difference is so hard to measure, that nobody will notice that they work on their own stuff 4 hours per week.
<beach>
schweers: Usually because their is a company-wide policy to organize talks, and someone knew me.
<beach>
That part is somewhat sane.
<beach>
External speakers usually say interesting things.
<schweers>
So the people who decide to ask you for a talk, and the people who should follow your advice are different people. This kind of makes sence, in a sad way.
Blukunfando has joined #lisp
<beach>
Yes, very different people.
<beach>
Often the people organizing the talks are admin or management people with no training in software.
<beach>
They do ask the participants for feedback, which is why I get invited back regularly.
<Oladon_work>
Also, we like to convince ourselves we're "doing stuff" by listening to people tell us to do stuff.
<Oladon_work>
(we = humans)
<beach>
Indeed.
<beach>
As a professor, I have gotten used to that a talk or a lecture is understood by around 10% of the participants. But that's better than 0.
<Oladon_work>
Quite so
<schweers>
Is is actually a normal thing that professors give talks at private companies? My employer is quite small, so I guess we won’t enjoy this luxury (also I’ve only been working in industry for 2 years).
<beach>
I don't know how common it is. I am close to retirement, so I do it for fun. And I only require that I not lose money, so I just ask for the travel and the hotel room to be reimbursed or paid for.
<schweers>
So booking you isn’t all that expensive for the company, depending on where they are.
<schweers>
sorry, booking sounds a bit wrong in this context.
<beach>
Right, it depends on how far I have to travel.
<beach>
One company said their "budget is 1000€" which was plenty to cover travel from Bordeaux to Gothenburg and a few nights of hotel.
<schweers>
Plus, you get to see Gothenburg :)
<beach>
I did my military service there, and I spent one summer working as an intern there. :)
<schweers>
I hope the memories you have are fond ones.
<beach>
Fantastic!
voidlily has quit [Ping timeout: 276 seconds]
refpga has quit [Ping timeout: 246 seconds]
refpga has joined #lisp
Lycurgus has joined #lisp
<schweers>
Cool. Well, I’m off home. Have a good evening everyone!
<beach>
You too.
<schweers>
thanks
nanozz has joined #lisp
schweers has quit [Ping timeout: 264 seconds]
nanoz has quit [Ping timeout: 248 seconds]
voidlily has joined #lisp
Necktwi has joined #lisp
faheem_ has joined #lisp
faheem has quit [Ping timeout: 258 seconds]
EvW has quit [Ping timeout: 250 seconds]
<jonatack>
beach: Bordeaux? Biarritz here, sometimes in Paris
<beach>
jonatack: Great! Nice place!
<jonatack>
beach: true, though too many tourists here ATM and then in nine days there's the g7 summit that locks down the whole city/region
<beach>
Ah, yes. Get out!
<jonatack>
hehe. Stocking up on food and supplies in advance.
<beach>
Mhm!
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
Lycurgus has quit [Quit: Exeunt]
Mandus has quit [Ping timeout: 272 seconds]
FreeBirdLjj has quit [Ping timeout: 248 seconds]
<Xach>
What would you say are the defining characteristics of a thunk?
<beach>
A closure with no parameters.
<Xach>
beach: is "no parameters" a key requirement?
<beach>
Yes.
<Xach>
Thanks. I have been using the term wrong for a while now.
<beach>
Oh! I see.
<Xach>
I think the term I want is "callback" - I mean a function passed to another function that may be called with some arguments if that is the agreed-upon protocol
<Xach>
I don't like that name much either, though.
<beach>
That is a reasonable name for such a function.
<beach>
I don't like the word callback very much either.
<beach>
Because it is often used in languages that don't support closures.
<Xach>
I'm not sure plain "function" is clear enough
<beach>
Right, "function" is more general.
<beach>
It doesn't explain the purpose.
<Xach>
I do often write docstrings that say something like "FUN must be a function of two arguments that blah blah ..."
<beach>
Sure, I do too. The context explains how it is being called.
Mandus has joined #lisp
aoeu256 has quit [Ping timeout: 272 seconds]
Mandus has quit [Ping timeout: 268 seconds]
Mandus has joined #lisp
m00natic has quit [Remote host closed the connection]
khisanth_ has joined #lisp
<scymtym>
Xach: in the context of CALL-WITH-* functions accompanying a WITH-* macros, McCLIM uses the term "continuation" which is kind of accurate but also has suboptimal connotations
faheem has joined #lisp
<Xach>
scymtym: i see, thanks.
Lycurgus has joined #lisp
ravenous_ has joined #lisp
Lycurgus has quit [Remote host closed the connection]
Lycurgus has joined #lisp
faheem_ has quit [Ping timeout: 272 seconds]
parab has joined #lisp
<Josh_2>
describe in clos is no longer a thing right? am looking at page 40 of OO pogramming in CL 1989 by Sonya Keene
<Josh_2>
no longer a generic function provided by CLOS, what is the alternative?
<scymtym>
DESCRIBE is an ordinary function whose behavior can be customized by defining methods on DESCRIBE-OBJECT
<Josh_2>
ah
<Josh_2>
so describe-object
Necktwi has quit [Ping timeout: 272 seconds]
xkapastel has joined #lisp
refpga has quit [Read error: Connection reset by peer]
refpga has joined #lisp
refpga has quit [Read error: Connection reset by peer]
refpga has joined #lisp
iarebatm` has quit [Ping timeout: 245 seconds]
refpga has quit [Read error: Connection reset by peer]
refpga has joined #lisp
parab has quit [Quit: parab]
parab has joined #lisp
random-nick has quit [Ping timeout: 244 seconds]
manualcrank has joined #lisp
Lycurgus has quit [Quit: Exeunt]
lalitmee has quit [Quit: Leaving]
EvW1 has joined #lisp
Jesin has quit [Quit: Leaving]
Jesin has joined #lisp
smazga has quit [Ping timeout: 258 seconds]
cosimone has quit [Quit: WeeChat 2.5]
Harag has joined #lisp
CEnnis91__ is now known as CEnnis91
matzy_ has joined #lisp
papachan has joined #lisp
random-nick has joined #lisp
FreeBirdLjj has joined #lisp
nullman has quit [Ping timeout: 245 seconds]
papachan has quit [Quit: Leaving]
cosimone has joined #lisp
FreeBirdLjj has quit [Ping timeout: 246 seconds]
sauvin has quit [Read error: Connection reset by peer]
cosimone has quit [Quit: WeeChat 2.5]
Mandus has quit [Ping timeout: 272 seconds]
Mandus has joined #lisp
random-nick has quit [Ping timeout: 248 seconds]
smazga has joined #lisp
zulu-inuoe has joined #lisp
zulu-inuoe_ has quit [Ping timeout: 248 seconds]
notzmv has joined #lisp
Necktwi has joined #lisp
krwq has joined #lisp
nanozz has quit [Ping timeout: 272 seconds]
smazga has quit [Ping timeout: 245 seconds]
vms14 has joined #lisp
vms14 has quit [Changing host]
vms14 has joined #lisp
<vms14>
what image libraries do you use?
<vms14>
I'm tempted to use the imagemagick wrapper
EvW1 has quit [Ping timeout: 264 seconds]
<vms14>
did you play with images and lisp? I'm looking at cliki, there are a lot of libraries to choose
arduo has joined #lisp
<vms14>
I just want to edit and create some images, but for a server
<aeth>
PNG is well-supported natively. I'm not sure about the rest.
<vms14>
stuff like add text to an image, reescale and so on
<vms14>
aeth: you mean common lisp supports png natively?
<aeth>
vms14: as in no need to FFI
<vms14>
ah
<aeth>
although technically speaking since that's true any implementation is free to build it in :-p
<vms14>
xD
<vms14>
aeth: do you mean cl-png?
<vms14>
CL-PNG depends on libpng (your operating system distribution may have a separate package, called libpng-dev or
<vms14>
something similar, that contains the required png.h header file) and CFFI
<aeth>
pngload
<aeth>
I'm not sure about writing, but I remember doing that, too
<aeth>
ImageMagick is nice on Unix in general. I use import all of the time as my main screenshot program for stumpwm since stumpwm afaik doesn't come with one. Using all-in-CL libraries reduces headaches, though.
<pjb>
If you keep using FFI, you're not putting pressure on the lisp ecosystem (implementations, libraries) to improve!
<pjb>
Don't use FFI!
<pjb>
(or libraries using FFI)
<vms14>
hmm
<vms14>
then opticl?
<vms14>
does not use ffi?
<Xach>
vms14: when i was running a server that did a lot of image stuff, i wound up using sb-ext:run-program with imagemagick tools. i wrapped it up with functions so it looked like lisp code rather than shell code. i processed tens of thousands of files per day, worked fine for me.
<jackdaniel>
(or implementations which operate in FFI land! - that leaves movitz and mezzano)
<aeth>
pjb: You generally have to eventually use FFI somewhere for input/output unless it's built into the particular implementation. clx is quite possibly the only exception there due to how X works.
_jrjsmrtn has joined #lisp
<vms14>
Xach: xD I was thinking on doing that, but I thought meh, better if I just use a library from lisp
<Xach>
I did that with a mix of other things that drew into their own file
<pjb>
aeth: I/O is built into all CL implementations!
__jrjsmrtn__ has quit [Ping timeout: 244 seconds]
<pjb>
OPEN READ-BYTE WRITE-BYTE CLOSE !
<Xach>
e.g. i would do something like (combine (make-caption-file "Hello!" "caption.png") (scale-base-image "original.jpg" "scaled.jpg")) or some nonsense like that!
<aeth>
pjb: hence "unless it's built in". You don't need to use FFI to be part of a Unix pipe, for instance.
q9929t has joined #lisp
smazga has joined #lisp
cosimone has joined #lisp
<aeth>
although a full unix-philosophy OS where everything's a file wouldn't need FFI either, I guess, if that's what you meant
<vms14>
you broke my mind just saying that, plus what Xach told about using "commands"
<vms14>
because I was considering doing that
<aeth>
That's what a scripting language is. bash without the landmines.
<vms14>
but meh, I'll look for a way to do it directly in lisp
<vms14>
the fact is unix philosophy has some rules I like to consider
<vms14>
and one of them is "make one thing and make it well"
<aeth>
I prefer function-level/module-level composition to program-level composition like Unix or, more recently, microservices
<aeth>
CL has quite a few things you could consider a "module", though
<vms14>
so having imagemagick which handles image stuff I have yet something that does "one" thing, not one really,
<jackdaniel>
certainly passing argument by reference is cheaper
<vms14>
but at the end is the same if you just use a library
papachan has joined #lisp
<White_Flame>
it's generally impossible to "make one thing well", because different usage cases want different access styles & prioritization of its feature sets
<vms14>
well not, because the unix philosophy relies on connect programs
<vms14>
but meh
<aeth>
White_Flame: There's only a finite amount, though. So what if different people need 10 PNG libraries with different use cases? There's room for them as long as their names are unique.
<vms14>
White_Flame: in a program yes, but not in a function
q9929t has quit [Quit: q9929t]
<vms14>
and in unix programs work like they were functions
<White_Flame>
vms14: push vs pull semantics are an example of function-level impedance mismatches
<aeth>
beach: I wonder what your thoughts on that are, and if something similar could work for Lisp, since you're the OS expert here
zooey has quit [Remote host closed the connection]
kushal has quit [Write error: Connection reset by peer]
gxt has quit [Write error: Connection reset by peer]
kushal has joined #lisp
<aeth>
Essentially, it made programs forwards compatible so proprietary Amiga programs that haven't been touched in decades can handle things like PNG, apparently.
<vms14>
btw did someone dreamed with a browser which uses lisp instead of js css and html?
<vms14>
I do xD
<White_Flame>
aeth: well, it also introduced a lowest common denominator that you access stuff through as well
<vms14>
dream*
<jackdaniel>
vms14: how that would be a browser then?
amerlyq has quit [Quit: amerlyq]
<vms14>
I saw also some browsers written in lisp, but not sure if they're alive
<White_Flame>
afaik, datatypes were more about generic display than actual data processing, but I'm not sure
<aeth>
White_Flame: If you're saying that as a disadvantage, I don't see how. Nothing stops an application from also supporting other things.
<White_Flame>
you don't fully "support" something, you only have minimal interaction with it
<jackdaniel>
vms14: you need to differentiate html/js/css (which is input for a browser) from a language it is written in
<vms14>
jackdaniel: (title "hi" :color red :onclick do-something)
<jackdaniel>
i.e firefox is not written in html
<Josh_2>
There is Next browser :P
<jackdaniel>
vms14: and what you talk about are html generators, check out cl-who
<vms14>
jackdaniel: xD yeah, but in a browser written in lisp we would be able to implement this stuff quicker
<aeth>
I know Firefox can't be written in HTML, but I'm not sure why Firefox isn't written in XML. You can program with XML! It definitely was a mistake to (mostly) kill XHTML.
<vms14>
firefox is written in rust
<vms14>
I'm compiling rust just because is a dependency of ff
<vms14>
partly*
<jackdaniel>
I think I'm lost and I'm sure I don't want to follow anyway ,) I can only say that we are getting into offtopic
<White_Flame>
aeth: re-googling the topic, yeah it was basically for showing pictures, playing sounds, and displaying some documents, with minimal program interaction with the data
<jackdaniel>
you can't have lisp browser, but what about lisp checkers, hmm? https://imgur.com/XvjBCp3 ;-)
<White_Flame>
so you tell the OS to opaquely present a blob file to the user
<White_Flame>
certainly handy for generic presentation use, but it's not a programmatical data access mechanism for program code to be able to process arbitrary file contents
random-nick has joined #lisp
<aeth>
White_Flame: I think you could also convert it to the standard IFF format? at least according to a reply to https://news.ycombinator.com/item?id=20690995 if I'm reading it correctly
refpga has quit [Ping timeout: 268 seconds]
<aeth>
certainly would be enough to handle every case forwards compatibly, but not optimally
<vms14>
jackdaniel: I cannot see the image until the fucking ff compiles
<aeth>
White_Flame: and no need to wait for a LispOS, it could be added to something like CLIM (if it's not already there)
<semz>
vms14: lynx can display images if you install xli (read: make a shell script of that name that calls your favorite image viewer). it's not a bad browser
random-nickname has joined #lisp
Mandus has quit [Ping timeout: 268 seconds]
<ebrasca>
aeth: What about Mezzano? ( mezzano have support for mcclim )
Mandus has joined #lisp
random-nickname has quit [Read error: Connection reset by peer]
<vms14>
semz: didn't know about, I was thinking in stuff like ansi images
<vms14>
ascii art*
<vms14>
ebrasca: isn't dead?
<vms14>
I looked at it, and there were others
random-nick has quit [Ping timeout: 272 seconds]
<vms14>
but never tried, just showed them to the people to say lisp makes you able to write stuff you couldn't write in other languages
<vms14>
like writing an entire OS alone
<vms14>
I'd like to sell lisp to people, but it's hard
random-nickname has joined #lisp
<vms14>
pjb pointed that we shouldn't use ffi in order to increase the number of lisp libraries instead of relying the existing ones
<vms14>
but I guess for improving lisp usage we should make programs that users could use
<ebrasca>
vms14: It is alive , I have add fat12/16/32 read and write , ext2/3/4 only read and more.
<vms14>
wow
<ebrasca>
vms14: It start in my PC bare metal.
<semz>
why is mass adoption a goal in itself? i'd definitely not want it if that means rotten compromises like lots of libraries that rely on C blobs
gxt has joined #lisp
<aeth>
ebrasca: I guess Mezzano could add it
<vms14>
semz: more developers make grow the ecosystem, and the ecosystem is important
<vms14>
also, I think lisp is a very powerful language and I'd like to make others realize that
<vms14>
but they won't
<aeth>
semz: even if 90% of every library is garbage, then more users => more developers => more libraries => more non-garbage options that can save you time
<aeth>
and we only have so much time
<ebrasca>
aeth: could add it ... what is it?
<aeth>
ebrasca: afaik, what was going on is that AmigaOS had a library that could handle the presentation of multimedia formats, and possibly even (not sure here) convert that to a standard format on demand, in a way where an application wouldn't need to be recompiled to support a new file format
random-nickname has quit [Read error: error:1408F10B:SSL routines:ssl3_get_record:wrong version number]
<White_Flame>
really, that just degenerates to methods in lisp-land :-P
<White_Flame>
presentations etc
<aeth>
This means that any application that used that, at least as a fallback, would be forwards compatible
random-nickname has joined #lisp
<ebrasca>
aeth: I don't know how to add it.
<White_Flame>
maybe with a little introspection to detect which functions are possible
<semz>
aeth: this did not happen in many popular languages though. PHP and JS come to mind as particularly offensive examples. polemicizing a bit here, but if the ecosystem's full of shit this fact also drowns any effort to counteract that and causes the users to expect more of the same
<dlowe>
aeth: doesn't that break when you have file formats with different features?
<ebrasca>
aeth: What if you get 3D images or 4D images?
<semz>
cl-ppcre is a great example of a library that would be FFI in other languages imo
<White_Flame>
semz: agreed
arduo has quit [Ping timeout: 258 seconds]
<White_Flame>
it's crazy seeing the C version cobble together asm instructions, compared to lisp's solution
<jackdaniel>
native lisp checkers game, that's what we need in the ecosystem if you ask me ;-) (sorry, I had to, I'll keep quiet about checkers for a few days)
<jackdaniel>
*but* I have a half-baked ansi terminal emulator written (with some extensions)
<jackdaniel>
maybe I'll polish it after finishing console backend
<aeth>
semz: JS is a unique case because (1) it's (or was) a tiny language and (2) because of the way it's distributed, microlibraries make sense because you don't want to load what you're not using because that will directly add to page load times.
<aeth>
semz: A lot of other popular languages (e.g. Java) prefer to have (or at least do have) gigantic frameworks
<aeth>
(frameworks have their own issue, mainly that you can usually only have one)
<aeth>
dlowe: I'm not actually sure if that would break (or at least wouldn't break *everything*) because I think the programs were giving control to the OS for the rendering of the image
Mandus has quit [Ping timeout: 272 seconds]
Mandus_ has joined #lisp
<vms14>
btw about images, do you know if there is a library which will let me convert images to xlib images?
<vms14>
the "old" clx does not provide xpm
<vms14>
and the new-clx does not work in sbcl
<vms14>
or I wasn't able to make it work in it
<aeth>
ebrasca: 3D is hard because there are so many ways to do it
<White_Flame>
if all you want is a "display this" GUI element, then it's not hard
<vms14>
White_Flame: how?
<White_Flame>
which is what a lot of amiga datatype usage is about
<vms14>
ah lol
<vms14>
xD
<White_Flame>
vms14: see, for instance, your web browser ;)
<White_Flame>
but then abstract that out to the OS, deferring that UI element
<vms14>
nah, nvm I thought you were talking about converting images to X.org images
<vms14>
I have no way to load an image with clx
<vms14>
with xlib I was using xpm files, and worked well
<vms14>
but in C
random-nick_ has joined #lisp
random-nickname has quit [Ping timeout: 245 seconds]
refpga has quit [Ping timeout: 272 seconds]
refpga has joined #lisp
gravicappa has quit [Ping timeout: 245 seconds]
refpga has quit [Read error: Connection reset by peer]
refpga has joined #lisp
theblacksquid has joined #lisp
Lord_of_Life_ has joined #lisp
ravenous_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
mindCrime__ has quit [Ping timeout: 272 seconds]
Lord_of_Life has quit [Ping timeout: 244 seconds]
Lord_of_Life_ is now known as Lord_of_Life
p9fn has quit [Ping timeout: 264 seconds]
refpga has quit [Read error: Connection reset by peer]
refpga has joined #lisp
mindCrime__ has joined #lisp
random-nickname has joined #lisp
random-nickname has quit [Max SendQ exceeded]
p9fn has joined #lisp
random-nick_ has quit [Ping timeout: 268 seconds]
Blukunfando has quit [Ping timeout: 246 seconds]
vms14 has quit [Quit: WeeChat 2.3]
dale has quit [Quit: My computer has gone to sleep]
<ebrasca>
What if this image use some torus projection in 4D space + 2D time space?
<pjb>
vms14: you right, the first priority is to make programs the users want to use. Given the choice between no program and a program using FFI, the later is better. But given the choice between a program using FFI and a program using pure lisp code, the later is better too!
dale has joined #lisp
nowhere_man has joined #lisp
<ebrasca>
Yea mezano can start bare metal , it can see images , videos , probably audio and it support mcclim.
spm_ has joined #lisp
* ebrasca
don't know what to write.
Insanity_ has joined #lisp
refpga has quit [Ping timeout: 248 seconds]
refpga has joined #lisp
saravia has quit [Read error: Connection reset by peer]
saravia has joined #lisp
<ebrasca>
pjb,vms14: Do you have ideas what people want to use?
dale has quit [Quit: dale]
DGASAU has quit [Ping timeout: 258 seconds]
papachan has quit [Quit: Leaving]
refpga has quit [Read error: Connection reset by peer]
iarebatm` has joined #lisp
refpga has joined #lisp
saravia has quit [Ping timeout: 245 seconds]
<whartung>
I’ve forked to imagemagick in the past. It’s great if you can handle the overhead of the fork and the copying of the data. It would work fine. Given that, you can instead of using imagemagick, just go straight to Postscript and render using that (since someone mentioned writing text on images). I honestly don’t know if there is a “postscript” server (that is, something besides a printer which IS a postscript server) that you can connect to more
<whartung>
cheaply than continually execing.
akoana has joined #lisp
<whartung>
I don’t know if there’s a standalone SVG renderer avaliable or not either, but that may be another option.
dale has joined #lisp
<whartung>
as for not using FFI, it’s all a matter of timing and whether you can wait for a native CL implementation of a functionality.
<whartung>
In java, I avoid JNI in general simply because most of my work is with app servers and an NPE in Java is an exception, but an NPE in a .so is a core dump — not a happy state for an app server.
<whartung>
That siad, I have exec’d imagemagick from Java in teh past, as I was getting better results from it than native java code. I could have JNId and use the imagemagick directly in Java, but see my previous comment about JNI
DGASAU has joined #lisp
<pjb>
ebrasca: porn, food, money. (for what remains legal).
<pjb>
ebrasca: B2B, anything that can help B to make money.
vlatkoB has quit [Remote host closed the connection]
DGASAU has quit [Ping timeout: 245 seconds]
refpga has quit [Ping timeout: 245 seconds]
refpga has joined #lisp
<whartung>
I’m casually working on an ecad board layout to in CL…pretty sure nobody wants that. Especially being it’ll be command driven vs a GUI.
saravia has joined #lisp
<whartung>
but, hey, I actaully saw someone the other day ask for a CLI based ecad program, so, who know what niche I may tap in to.
mindCrime__ has quit [Ping timeout: 272 seconds]
DGASAU has joined #lisp
mindCrime__ has joined #lisp
FennecCode has joined #lisp
saravia_ has joined #lisp
saravia has quit [Ping timeout: 246 seconds]
FennecCode has quit [Quit: ERC (IRC client for Emacs 26.2)]
FennecCode has joined #lisp
Bike has quit [Quit: Bike]
mindCrime__ has quit [Ping timeout: 268 seconds]
<aeth>
What makes people run Windows are games and random niche professional tools which are different for every profession
hvxgr has quit [Remote host closed the connection]
<aeth>
For everything else, there's the web
kiwi_49 has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
iarebatm` has quit [Ping timeout: 272 seconds]
hvxgr has joined #lisp
LiamH has quit [Quit: Leaving.]
lnostdal has quit [Quit: "Fascism, Nazism, Communism and Socialism are only superficial variations of the same monstrous theme—collectivism." -- Ayn Rand]
BugsForDays has quit [Quit: Going offline, see ya! (www.adiirc.com)]
saravia__ has joined #lisp
saravia_ has quit [Ping timeout: 258 seconds]
kiwi_49 has quit [Remote host closed the connection]
Ricchi has joined #lisp
Bike has joined #lisp
EvW has joined #lisp
vms14 has joined #lisp
<vms14>
the Let over Lamba is a great book
<vms14>
just reading the introduction makes me cum
<vms14>
Lambda*
Oladon_work has quit [Ping timeout: 260 seconds]
Necktwi has quit [Quit: leaving]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
matzy_ has quit [Remote host closed the connection]
cosimone has quit [Ping timeout: 250 seconds]
cosimone has joined #lisp
refpga has quit [Remote host closed the connection]
<vms14>
it's also nice to have it online since you could download it with wget -R and I can read it with lynx, like the author took care of text browsers
Ricchi has quit [Remote host closed the connection]
Tristam has quit [Ping timeout: 244 seconds]
smazga has quit [Quit: leaving]
iarebatm` has joined #lisp
saravia__ has quit [Remote host closed the connection]