badkins has quit [Remote host closed the connection]
badkins has joined #racket
badkins has quit [Ping timeout: 252 seconds]
ArthurStrong has joined #racket
ArthurStrong has quit [Ping timeout: 265 seconds]
ArthurStrong has joined #racket
badkins has joined #racket
badkins has quit [Remote host closed the connection]
badkins has joined #racket
badkins has quit [Ping timeout: 256 seconds]
m1dnight_ has quit [Ping timeout: 256 seconds]
m1dnight_ has joined #racket
orivej has joined #racket
m1dnight_ has quit [Read error: Connection reset by peer]
m1dnight_ has joined #racket
iyzsong has joined #racket
ArneBab_ has joined #racket
pilne has quit [Quit: Call me a relic, call me what you will. Say I'm old fashioned, say I'm over the hill.]
selimcan has quit [Ping timeout: 246 seconds]
Guest36118 has quit [Remote host closed the connection]
Sgeo_ has joined #racket
YuGiOhJCJ has quit [Ping timeout: 240 seconds]
cartwright has quit [Write error: Connection reset by peer]
Sgeo has quit [Ping timeout: 265 seconds]
cartwright has joined #racket
endformationage has quit [Quit: WeeChat 2.6]
Lowl3v3l has left #racket [#racket]
ArthurStrong has quit [Quit: leaving]
iyzsong has quit [Ping timeout: 240 seconds]
narimiran has joined #racket
m1dnight_ has quit [Read error: Connection reset by peer]
m1dnight_ has joined #racket
germ13 has quit [Ping timeout: 265 seconds]
badkins has joined #racket
exit70 has quit [Remote host closed the connection]
badkins has quit [Ping timeout: 252 seconds]
orivej has quit [Ping timeout: 264 seconds]
libertyprime has joined #racket
cartwright has quit [Remote host closed the connection]
cartwright has joined #racket
selimcan has joined #racket
laduke has quit [Ping timeout: 240 seconds]
laduke has joined #racket
wingsorc has joined #racket
<setthemfree[m]>
Is there a shorthand for (if (procedure? something) (something) something)?
Naptra has joined #racket
Naptra has quit [Remote host closed the connection]
Naptra has joined #racket
lavaflow has quit [Ping timeout: 258 seconds]
lockywolf has joined #racket
lockywolf has quit [Remote host closed the connection]
lockywolf has joined #racket
true-grue has joined #racket
Naptra has quit [Remote host closed the connection]
dddddd has joined #racket
acarrico has quit [Quit: Leaving.]
<jcowan>
No, but it's a trivial macro; this is exactly why Lisps support syntax extension.
_whitelogger has joined #racket
Oxyd has joined #racket
lockywolf_ has quit [Remote host closed the connection]
lockywolf_ has joined #racket
lockywolf_ has quit [Max SendQ exceeded]
lockywolf_ has joined #racket
lockywolf_ has quit [Max SendQ exceeded]
lockywolf_ has joined #racket
lockywolf_ has quit [Max SendQ exceeded]
lockywolf_ has joined #racket
lockywolf_ has quit [Remote host closed the connection]
lockywolf_ has joined #racket
lockywolf_ has quit [Remote host closed the connection]
lockywolf_ has joined #racket
lockywolf_ has quit [Max SendQ exceeded]
lockywolf_ has joined #racket
KDr21 has quit [Remote host closed the connection]
lockywolf_ has quit [Max SendQ exceeded]
lockywolf_ has joined #racket
KDr21 has joined #racket
lockywolf_ has quit [Remote host closed the connection]
lockywolf_ has joined #racket
lockywolf_ has quit [Max SendQ exceeded]
lockywolf_ has joined #racket
evdubs has joined #racket
lockywolf_ has quit [Remote host closed the connection]
lockywolf_ has joined #racket
lockywolf_ has quit [Max SendQ exceeded]
lockywolf_ has joined #racket
Sgeo_ has quit [Read error: Connection reset by peer]
Sgeo_ has joined #racket
lockywolf_ has quit [Remote host closed the connection]
lockywolf_ has joined #racket
lockywolf_ has quit [Remote host closed the connection]
lockywolf_ has joined #racket
lockywolf_ has quit [Remote host closed the connection]
lockywolf_ has joined #racket
lockywolf_ has quit [Remote host closed the connection]
lockywolf_ has joined #racket
lockywolf_ has quit [Remote host closed the connection]
lockywolf_ has joined #racket
lockywolf_ has quit [Max SendQ exceeded]
lockywolf_ has joined #racket
lockywolf_ has quit [Max SendQ exceeded]
lockywolf_ has joined #racket
lockywolf_ has quit [Remote host closed the connection]
lockywolf_ has joined #racket
lockywolf_ has quit [Max SendQ exceeded]
lockywolf_ has joined #racket
lockywolf_ has quit [Remote host closed the connection]
orivej has joined #racket
efm has quit [Ping timeout: 250 seconds]
badkins has joined #racket
<srandon111>
can somebody help me understand a part during SICP ?
<notnotdan>
which part?
lavaflow has joined #racket
efm has joined #racket
acarrico has joined #racket
selimcan has quit [Ping timeout: 246 seconds]
eagleflo has quit [Ping timeout: 260 seconds]
`micro has quit [Ping timeout: 260 seconds]
`micro has joined #racket
eagleflo has joined #racket
juanfra_ has quit [Ping timeout: 240 seconds]
DGASAU has quit [Ping timeout: 260 seconds]
notzmv has quit [Ping timeout: 265 seconds]
juanfra_ has joined #racket
setthemfree[m] has quit [*.net *.split]
setthemfree[m] has joined #racket
BitPuffin has quit [Ping timeout: 240 seconds]
setthemfree[m] has quit [Ping timeout: 240 seconds]
juanfra_ has quit [Ping timeout: 252 seconds]
olavx200 has quit [Ping timeout: 246 seconds]
badkins has quit [Remote host closed the connection]
catonano has joined #racket
badkins has joined #racket
badkins has quit [Ping timeout: 264 seconds]
mzan has quit [Ping timeout: 240 seconds]
badkins has joined #racket
bremner has joined #racket
<bremner>
is there an idiomatic way of marking a racket identifier as a "constant"?
<bremner>
using a submodule to define it is one way, I guess
mzan has joined #racket
<srandon111>
guys is racket a toy programming language to learn other schemes?
<srandon111>
or it can produce production ready systems?
<srandon111>
does it have some limits?
NinjaTrappeur has quit [Ping timeout: 272 seconds]
setthemfree[m] has joined #racket
NinjaTrappeur has joined #racket
ArthurStrong has joined #racket
catonano has quit [Quit: catonano]
catonano has joined #racket
badkins has quit [Remote host closed the connection]
badkins has joined #racket
efm has quit [Ping timeout: 264 seconds]
badkins has quit [Ping timeout: 240 seconds]
badkins has joined #racket
olavx200 has joined #racket
BitPuffin has joined #racket
juanfra_ has joined #racket
efm has joined #racket
libertyprime has quit [Read error: Connection reset by peer]
notzmv has joined #racket
<notnotdan>
srandon111: what do you mean by "production ready systems"?
<notnotdan>
it's not a toy programming langauge, it is a serious one
<notnotdan>
but of course it has some limits, like any other programming language
selimcan has joined #racket
samlamamma has joined #racket
nullman has quit [Remote host closed the connection]
badkins has quit [Remote host closed the connection]
badkins has joined #racket
badkins has quit [Ping timeout: 256 seconds]
<srandon111>
notnotdan, what limits?
<srandon111>
othr than drracket
<notnotdan>
drracket is not a limiting factor.. it's just an IDE for Racket
<notnotdan>
limits, for example, platforms: Racket wouldn't run on a microcontroller for example
<true-grue>
For now Racket is based on Chez Scheme. Which is production ready, I suppose :)
<true-grue>
notnotdan, Why? :) Even MicroPython can be used on microcontrollers :)
badkins has joined #racket
<true-grue>
You just need to realize strong points of Racket. It promotes language oriented programming. So all you need is to develop your embedded DSL compiler in Racket and then start writing your app with something like "#stm32lang" :)
ArthurStrong has quit [Quit: leaving]
ArthurStrong has joined #racket
ArthurStrong has quit [Client Quit]
yurichev has joined #racket
<aeth>
iirc Racket as a language platform is used in production in https://news.ycombinator.com/news which is built on Arc... (note that Arc doesn't really follow the idiomatic best practices for creating a language within Racket, though)
<aeth>
That might be the most visited website built on Racket (if they ever did port it from PLT Scheme), and probably the only one using Arc.
selimcan has quit [Ping timeout: 265 seconds]
nullman has joined #racket
jmiven has quit [Quit: reboot]
<samth>
srandon111: racket isn't the right language if you need an extremely small memory footprint, or if you need total control over memory layout, or if you need C-level performance. it also doesn't have as big collections of libraries as more popular languages such as Python or JavaScript or Go.
jmiven has joined #racket
xensky has joined #racket
badkins has quit [Remote host closed the connection]
badkins has joined #racket
badkins has quit [Ping timeout: 250 seconds]
badkins has joined #racket
selimcan has joined #racket
endformationage has joined #racket
pilne has joined #racket
narimiran has quit [Ping timeout: 265 seconds]
manualcrank has quit [Ping timeout: 268 seconds]
catonano has quit [Quit: catonano]
catonano has joined #racket
ohama has quit [Ping timeout: 260 seconds]
<aeth>
"no one" cares about memory footprint anymore
manualcrank has joined #racket
<aeth>
Racket's lower memory than bundling an entire Chromium with your application.
<aeth>
It is thus lightweight.
ohama has joined #racket
<aeth>
As for libraries... Common Lisp (Quicklisp) has 1887 libraries in its main package manager. Racket has 1411 libraries. Chicken has 764 eggs (if I grepped its HTML correctly). I don't think any other Scheme comes close to Racket or Chicken. Further removed from Racket, Clojure appears to have 25940 libraries.
catonano has quit [Quit: catonano]
catonano has joined #racket
<pilne>
i honestly think that if i wanted to teach "programming" concepts to like jr. high/high school kids, i'd be using racket, pharoh, and swi-prolog.
<aeth>
As for other languages: Python has 225314 projects, Ruby has 10591 gems (sounds low?), CPAN (Perl) has 192659 modules, npm (JavaScript) has 1346398 (but they love to have micropackages that are barely more than one function)...
<aeth>
But these are outliers as far as languages go and many are probably just noise at that point. e.g. how many microframeworks for the web do you need?
<pilne>
1google
<pilne>
at least
<pilne>
all of which basically do the same thing :D
<aeth>
Anyway, the difference betwen 100 and 1000 libraries is way more than the difference betwen 1000 and 10000 or 10000 and 100000. And if you have over a million, you probably still only have < 100000 actually useful libraries anyway.
catonano has quit [Quit: catonano]
<aeth>
Racket isn't big enough for resume-padders to have found it to fill it with noise... yet.
catonano has joined #racket
<true-grue>
aeth, The funny thing is that they already stopped to teach programming in such way a long time ago. It's something from early 80s :)
<aeth>
true-grue: well, when everyone function is its own library, you don't need to write new functions anymore ;-)
<aeth>
I think in Haskell you can even search by the type signature
<aeth>
(Haskell has 14706 entries on Hackage)
<true-grue>
aeth, I was answering on your message about Scheme, Smalltalk and Prolog :)
<aeth>
true-grue: As I mentioned the other day in I think #scheme in response to a discussion about MIT abandoning SICP a while ago... the argument is, essentially, that Lisps are good at writing software from scratch, but no one writes software from scratch anymore.
<true-grue>
From the compiler writer perspective Racket is an AST and TypedRacket is an annotated AST :)
<true-grue>
In fact there was the movement against SICP even before that, in the late 80s. Early haskellers didn't like idea of using Scheme in the teaching process.
<pilne>
i know they stopped
<pilne>
that doesn't mean it was a good idea :D
<true-grue>
SICP was good because of the idea of "constructive knowledge". An old idea of Seymour Papert and others. And to make this idea work it's really important to make your beginners' programming language as simple as possible. It works with Scheme (that's why students can implement their own compiler/interpreter in the end of introductory course). And it definitely will not work with language like Haskell.
<pilne>
i honestly think HTDP is one of the better books out there right now for learning how to "program"
<pilne>
the "think like a computer scientist using X" series are pretty swell too.
<pilne>
but i've only seen java, python, and julia in that series.
samlamamma has quit [Remote host closed the connection]
<samth>
aeth: I think a more accurate number for Racket is 1685, which includes all the packages that are distributed with the standard Racket build, which is quite large
<samth>
it includes, for example, all of DrRacket, the GUI system, Typed Racket, the macro debugger, the teaching languages for multiple different books, the documentation system, and more
efm has quit [Ping timeout: 264 seconds]
yurichev has quit [Quit: leaving]
catonano has quit [Quit: catonano]
badkins has quit [Remote host closed the connection]
wingsorc has quit [Quit: Leaving]
badkins has joined #racket
orivej has quit [Ping timeout: 240 seconds]
orivej has joined #racket
badkins has quit [Ping timeout: 256 seconds]
badkins has joined #racket
<aeth>
samth: ah
<aeth>
Hmm... I wonder... How standard of an R6RS is Chez Scheme? i.e. How much work would it take to port Racket-on-Chez to another base Scheme?
catonano has joined #racket
<samth>
aeth: much less than the original port to Chez, but it's much more that just r6
<samth>
our ICFP 2019 paper has lots of details
<aeth>
ah, okay
orivej has quit [Quit: No Ping reply in 180 seconds.]
cheers has joined #racket
orivej has joined #racket
efm has joined #racket
<aeth>
samth: In particular, I'm implementing an r7rs that should hopefully be performance-comparable to chez and gambit in these benchmarks given my transpilation strategy: https://ecraven.github.io/r7rs-benchmarks/
<aeth>
samth: The only reason I'd want to support r6rs instead of r7rs-large, though, would be for Racket, at least afaik.
<jcowan>
Racket doesn't expose Chez as such: Chez is the C of Racket CS.
orivej_ has joined #racket
orivej has quit [Ping timeout: 260 seconds]
<jcowan>
It would be interesting to see how many Racket libs begin with "#lang r6rs". Not too many, I bet.
<jcowan>
of course, many may be written in the intersection of R6RS and #lang racket.
<aeth>
jcowan: Well, yes, but if Chez is just R6RS, then it should be possible for another R6RS to fake being Chez for Racket.
<aeth>
At least, in theory.
<aeth>
Schemes fake being each other all the time, except, of course, not for something as big as Racket.
<jcowan>
Racket depends on a lot of non-R6RS Chez features, including some added to Chez and others patched into Chez for Racket use only.
<jcowan>
so providing R6RS libraries is just the beginning of porting Racket, as samth said.
<jcowan>
Here’s an incomplete list of things that are compatible between the current Racket implementation and Racket CS and that required some specific effort:
<jcowan>
ephemerons, ordered and unordered finalization, foreign-function interface (mostly), phantom byte strings, source locations, left-to-right evaluation, result-arity checking, left-associative arithmetic, eqv? on NaNs, and eq? and flonums.
<aeth>
ah
<aeth>
jcowan: is chez right-to-left evaluation?
<jcowan>
no idea
<jcowan>
the day I care about evaluation order (of arguments) ...
<jcowan>
No, wait, I may actually have it in the repo
<jcowan>
Chez reorders argument evaluation, so it has no fixed order
<jcowan>
same with Larceny; MIT, BDC, XLisp, SXM, Chibi are right-to-left, and everything else is left-to-right
<aeth>
right-to-left makes sense. saves a reverse
<aeth>
(makes sense as in, it's easier on the implementor, not the user!)
<true-grue>
I really hope that Racket will implement more powerful abstractions, (than in a generic Lisp-like langauges: macros etc), to support language-oriented programming. Nanposs in Chez is a significant step further and a good source of inspiration.
Codaraxis has joined #racket
ArthurStrong has joined #racket
<jcowan>
gcc is RTL, clang is LTR
<aeth>
Wow!
<aeth>
I guess I've never depended on visible side effects in the function calls themselves in C or C++ before.
<jcowan>
Good, because C has never allowed you to depend on it.
<jcowan>
historically, gcc worked by evaluating the args and pushing them on the stack on stack-grows-downward machines (of which the PDP-11 and Vax were the first) and then the args were laid out in memory as an array
<jcowan>
since the caller pops them, the callee can have a fixed or variable number of arguments.
<jcowan>
in those days the caller didn't even have to know
<jcowan>
that's also why printf etc. is terminated with a 0 argument.
<jcowan>
no, not printf, exec
<jcowan>
printf looks at the format string to figure out how many args there are
<jcowan>
also passing extra arguments was basically harmless, they were evaluated by the caller but the callee could ignore them
<jcowan>
it's only when C had to be made portable to machines with different conventions that the need for function prototypes was seen
<true-grue>
jcowan, "gcc is RTL, clang is LTR". I don't think it's correct in a general case. The compiler may switch operands for the commutative operation (and canonize them) and calling convention could have different order than real order of arg evaluation.