<alexgordon>
being taught the same as everybody else can only reduce variance
<prophile>
I'd think of it as being introduced to the same things rather than being shepherded into the same programming styles
<alexgordon>
heh
<prophile>
if I teach a bunch of kids what FRP is, or the liskov substitution principle, or what 'with' does in python
<prophile>
I'm not doing that to the detriment of whatever else they've learned
<yorick>
the liskov substitution principle is rather useless
<yorick>
does it really need a name?
<prophile>
giving a name to something just makes it easy to refer to
<yorick>
does it ever need to be referred to?
<alexgordon>
nope
<yorick>
just makes it sound more important and maybe overrepresents it in actual code
<prophile>
you're against naming things in case people think they're important?
<alexgordon>
teaching the liskov substitution principle is like telling your children "don't kill people". Either they *already* understand it, or there's no hope for them
<prophile>
they probably already understand it at some level, but formalising it can clarify what they already know
<yorick>
alexgordon: I think it's more like "to be less thirsty, you can drink water instead of soda" and calling it the Waterimov Substitution Principle
<alexgordon>
to the extend that it's applicable to the real world, it contains no useful insights
<yorick>
of course poisonous water is a violation of it
<yorick>
and seawater :P
<alexgordon>
prophile: actually I think LSP underlies a bigger problem: overuse of inheritance in academia
<alexgordon>
the only people who use more inheritance than java programmers, are java programmers in academia
<yorick>
oh god the UML diagrams are all coming back
<alexgordon>
xD
<alexgordon>
at least in the real world you quickly learn Not To Do That Shit
<yorick>
all of the InternalFrameInternalFrameTitlePaneInternalFrameTitlePaneMaximizeButtonWindowNotFocusedState
<alexgordon>
universities seem to teach a bastardized version of programming where if a feature exists, It Must Be Used
<alexgordon>
not only do they teach it, they mandate it
<alexgordon>
gotta teach the whole language
<yorick>
I can see the inheritance diagram up to InternalFrameInternalFrameTitlePaneInternalFrameTitlePaneMaximizeButtonWindowNotFocusedState until all the InternalFrames are gone :P
<yorick>
why not teach people about org.springframework.aop.framework.AbstractSingletonProxyFactoryBean
<whitequark>
either you're using some other kind of type signatures than me
<prophile>
q is basically ignored
<prophile>
callCC takes ((p -> q) -> p) as an argument
<whitequark>
yes, I understand the part where intutionistic logic turns to propositional logic
<prophile>
(p -> q) is the continuation passed in
<whitequark>
but how the fuck is this related to call/cc
<prophile>
and you call it to call the current continuation
<whitequark>
still don't get it
<whitequark>
hrm
<prophile>
look up the continuation monad if you like
<prophile>
it gimps the types by putting monads on them
<prophile>
but it does make it possible to actually implement
<prophile>
that is, you put callCC in the kleisli category and make it ((a -> Continuation b) -> Continuation a) -> Continuation a
<whitequark>
brb drugs
<whitequark>
no
<whitequark>
really
<whitequark>
fuck that
<whitequark>
I'm too fucking dumb
<whitequark>
and it is not like this knowledge is particularly rewarding or what
<ec>
hi
<purr>
ec: hi!
<whitequark>
hi
<purr>
whitequark: hi!
<ec>
I don't want to be dumb
<ec>
prophile: you need to help me find an appropriate CS program for me, some time.
<ec>
I'm completely willing to put in 4 years to learn to understand that shit. I truly believe it'll make me a better programmer, and I crave that. /=
<prophile>
whitequark: well, it's actually relevant to my current project
<prophile>
ec: I'm sure you could find a much better use for 4 years
<prophile>
I could teach you all the relevant theory you need to know in maybe 6 weeks
<whitequark>
ec: it looks way cooler than it is.
<ec>
… but you do you have 6 weeks to dedicate to teaching me?
<ec>
whitequark: not about the cool.
<ec>
whitequark: I'm more interested in the *mental framework*.
<ec>
Look at Paws. Or at least what you know of it. I'm a talented programmer, but I work *entirely* off of intuition.
<whitequark>
ec: the corresponding mental framework does not make you a better programmer
<whitequark>
in fact, both in mathematics and programming, intuition is extremely important. more than formal proofs.
<ec>
I can make great things like that … sure, I may not necessarily believe that I'll *truly gain anything*, i.e. make objectively better products, with that knowledge
<ec>
but I'm a fucking developer!
<whitequark>
ec: it has incredibly little relevance to developing software.
<whitequark>
and that relevance is mostly coincidental.
<ec>
given the option between using proprietary, black-box tooling (intuition.) to produce greatness, and open-source, dissectible, introspectible tooling (logic.), I'm going to put in the effort to learn the latter tool.
<ec>
even if I'm already proficient in the former.
<whitequark>
how do you think people create new mathematical proofs?
<whitequark>
logic allows you to validate them.
<whitequark>
and again
<whitequark>
it's like, well, monads
<ec>
don't forget, there's also the communication aspect.
<whitequark>
category theory has absolutely zero relevance to programming in haskell.
<whitequark>
it won't make you a better programmer; it won't let you understand the language any better, in fact.
<ec>
I'm exhausted of spending my life having people smarter than me try ti tell me that my <something> is <some other thing>, and not having the words to argue with them *without* dragging them into a six-hour-long exposition wherein I describe <something> in detail until they *finally* understand why I think it's different
<whitequark>
right
<whitequark>
I didn't say you don't need *any* CS
<whitequark>
just not the insane mind-bending pure mathematics parts
<whitequark>
in fact
<ec>
prophile: opinion?
<whitequark>
you need surprisingly small logical framework even in order to make a practical formalization of a programming language
<whitequark>
e.g. look at Typed Scheme
<whitequark>
it draws about one A4 page of notation and semantics from math, which you can understand in a day
<ec>
Typed scheme? unfamiliar
<prophile>
my experience has been that learning the formalities, like learning many other things, hasn't itself flipped a magical "you are now a good programmer" switch
<whitequark>
^ that, a million times
<prophile>
what it does do is gives you new ways of thinking about things
<ec>
yes, that's exactly what I want.
<prophile>
and experience to draw on, if you like
<ec>
thinking about programming is currently boring.
<ec>
or, to put it another way, I'm *too good* at thinking about programming the way I currently think about programming.
<ec>
I know I'm going to improve very little, or no further at all, even, in my current vector. I want to change it up, find new ways of approaching the same things.
<ec>
Not *necessarily* better, just different; and *if* better, more “better through variety” than anything else.
* prophile
thinks
<ec>
It's like natural selection. Homogeneity is death; as much so in the mind as elsewhere.
<whitequark>
ec: from what I understand from our discussions
<whitequark>
start from regular CS.
<whitequark>
you'll see immediate and huge benefit.
* ec
nods
<ec>
as soon as I can find a program that doesn't try and teach anything important using *fucking Java*, I'm hoping to do so.
<whitequark>
SICP?
<ec>
although I *do* intend to take mathematics courses in parallel. It's just something that interests me, that logical and precise and proven way of thinking.
<whitequark>
EOPL3?
<ec>
SICP's been on my mind quite a while. Thanks to inimino, mostly.
<prophile>
sounds like you might be interested in the oxford CS course then
<ec>
But I'd like to do it *with* somebody, *with* people.
<whitequark>
as in?
<ec>
And most importantly, *with* a skilled teacher/professor. I need somebody smarter than me to talk to, and to answer questions.
<whitequark>
mmm
<ec>
A lot of learning is figuring things out for yourself, yes … but there's a difference between an hours' hard thought on a topic,
<whitequark>
you can ask me for about anything in SICP :)
<ec>
and banging your head against it for *fucking days*, getting discouraged, and giving up.
<whitequark>
and prophile for, likely, just anything you can think of
<prophile>
haha
<ec>
Still not the same as a school setting.
<ec>
hmmmmmmmm.
<ec>
Maybe i'll start some sort of mutual-learning group in Chicago.
<ec>
There's *got* to be at least a few programmers there interested in improving themselves.
<ec>
are SICP-clubs a thing? or a more abstracted, non-SICP-specific version of the same?
<whitequark>
dunno
<whitequark>
not interested in meatspace.
<whitequark>
well, learning groups in meatspace.
<ec>
lol
<purr>
lol
<ec>
really?
* ec
pats whitequark
<ec>
Life's worth more than programming, imo.
<whitequark>
ec: so? didn't say otherwise
<whitequark>
lemme repeat that the way I meant it
<whitequark>
not interested in programming learning groups (or, learning groups for about anything I can figure out on my own) in meatspace.
* ec
nods
<ec>
I tend to understand things better when I *explain* them,
<whitequark>
it's just... so slow
<ec>
and to boot, I sometimes get mentally stuck and need a random input to reset me
<ec>
between the two, a group of people whom I can mutually explain things to, and have things explained to me by, is really productive
<whitequark>
ten minutes with a good mentor is usually worth a thousand hours with peers.
<whitequark>
however, it doesn't really have to be a learning group
<whitequark>
find a guy on the internet with related interests, pester him until he replies :p
<ec>
lol.
<purr>
lol
<whitequark>
it helps if you have something sensible to say, too. but works even without it rather well.
<ec>
well, at the moment, there's other shit too. I need socialization excuses in my life right now. This messy move, and problems with the girl, and blahblahblah are making me *really* lonely.
<ec>
Need excuses to meet people in Chicago when I'm there. And can't imagine doing better than the kind of person who'd want to read the SICP with me.
<whitequark>
reading about highly technical stuff with geeks sounds just about right kind of socialization for me
<whitequark>
</sarcasm>
<prophile>
ec: have you ever read GEB?
<ec>
whitequark: I know you're kinda new here; but I'm really burnt out on the other kinds.
<prophile>
renaissance man that you are, I suspect it'd be exactly up your street
<ec>
Had a reallllllly crazy year last year.
<ec>
Lots of sex, alcohol, parties, drugs (not by me, but still)
<whitequark>
prophile: Godel, Escher, Bach?
<ec>
a lot of traveling, hundreds of people in my life on a daily basis.
<prophile>
whitequark: aye
<ec>
prophile: is that the shit with the “strange loops?”
<whitequark>
yep
<prophile>
damn right
<ec>
got the solid impression that it was all bullshit.
<whitequark>
ec: it isn't
* ec
eyebrows
<prophile>
it's a hell of a book
<whitequark>
well, if the parts I know about represent the book as a whole
<ec>
hm, I've got it on my shelf
<whitequark>
then it's fucking awesome
<prophile>
highly recommend it
<whitequark>
^
<ec>
hmmm
<ec>
'k
<prophile>
it also makes - in many ways - a very good introduction to the formal stuff you were talking about earlier
<ec>
what was the other thing you mentioned, than SICP?
* alexgordon
imagines "pawsing up" as some kind of grease application
<whitequark>
I hate them, but use them.
<prophile>
and they ended up with indecipherable error messages
<ec>
alexgordon: -> #Paws.Nucleus
<whitequark>
yeah yeah
<whitequark>
PEGs are shit, though.
<prophile>
most sensible programs can be rotated into basically LL(1) with the few exceptions easily handlable via custom code in a recursive descent parser
<prophile>
they really aren't
<whitequark>
well, in part implementations are to blame
<alexgordon>
-spec
<purr>
alexgordon: Paws' half-arsed Version 10 specification <http://ell.io/ihQzs>
<whitequark>
NO LEXER? YES THIS IS A GREAT IDEA
<whitequark>
LET'S ALLOCATE A NODE PER CHARACTER YEAH
<prophile>
you don't actually have to allocate a node per character, you know
<whitequark>
right.
<whitequark>
but for example every. single. ruby peg parser does that
<whitequark>
they all suck
<prophile>
obviously the ruby community is the one famous for its care about efficiency
<whitequark>
then, we have this exponential behavior
<prophile>
let me find you a paper
<whitequark>
which can kinda be alleviated into linear space by memoization
<prophile>
that you may find intriguing
<whitequark>
but this feels like a horrible hack for it
<prophile>
it's a completely different approach to using a PEG
<prophile>
"Remember that NFAs are endowed with the ability to guess perfectly when faced with a choice of next state: to run the NFA using an ordinary computer, we must find a way to simulate this guessing."
<prophile>
well that's clearly not true
<prophile>
you just keep track of the set of active states
<whitequark>
read along
<prophile>
ah, lovely
<alexgordon>
lol
<purr>
lol
<whitequark>
prophile: "The SNOBOL-like modus operandi"
<whitequark>
god why
<whitequark>
oooooh
<whitequark>
section 4
<whitequark>
neatness
<whitequark>
prophile: ok. I'm still wary of PEGs.
<whitequark>
they are probably fine for source code parsers
<whitequark>
but for a built-in finite automata / parser facilities, I'd really choose something better.
<alexgordon>
still don't see why a PEG would be faster to write than a ragel/lemon parser
<alexgordon>
alternatively, still don't see why a PEG would have better error handling than a hand written recursive descent
<prophile>
a PEG is a formalism, not an implementation
<alexgordon>
any implementation of it
<prophile>
I tend to write grammars and PEGs then write a recursive-descent parser from that
<prophile>
s/and/as/
<alexgordon>
I guess? but you can do that with lemon and it'll take less time
<prophile>
lemon is just another LALR parser
<prophile>
it may be nicer than bison but imo that just means it's a turd polished to a mirror shine
<alexgordon>
yeah, just another LALR parser
<whitequark>
every single L*R* parser generator I've seen sucks compared to menhir
<alexgordon>
works great though
<alexgordon>
for prototypes
<whitequark>
still shit though
<alexgordon>
if you want a production compiler, recursive descent is still the only way
<alexgordon>
though tell that to ruby or php
<whitequark>
php
<whitequark>
there are also LL(k) generators.
<prophile>
alexgordon: well, gcc up until one of the 4.* series was still mostly autogenerated
<whitequark>
wow
<prophile>
hence its famously terrible error messages
<alexgordon>
point is, there are three things people evaluate parser libraries/generators on: 1) prototyping suitability (how long it takes to write a parser), 2) parser speed (how fast the parser goes), 3) error recovery in the parsers
yorick has quit [Remote host closed the connection]
<alexgordon>
lemon has 1 owned, recursive descent has 3 owned, and it's pretty even on number 2 (lemon gets you most of the way there, with minimal effort, but recursive descent can be optimized by hand to squeeze everything out of it)
<whitequark>
you can do RDP fast with pattern matching
<whitequark>
ie not C++
<whitequark>
well, generally fuck clangs
yrashk has joined #elliottcable
<ec>
what's wrong with clang? D:
<alexgordon>
ec: GCC 4, man. can't get better than that
* ec
eyebrow
<alexgordon>
except maybe gcc 3
<ec>
really?
<ec>
but, but, but, pretty errors!
<joelteon>
gcc 13.2 is pretty good
<prophile>
clang's got code of mine in there
<prophile>
which clearly makes it superior to gcc in every way
<prophile>
and when you hit that one edge case with integer overflow and get one fewer instruction