<ELLIOTTCABLE>
things are okay now, some of it got resolved shortly after I finished ranting, but I'm still stressed as fuck :P
<whitequark>
mm let me see
<whitequark>
ELLIOTTCABLE: jesus christ that was a clusterfuck
<whitequark>
interestingly: literally /none/ of your experience with US academia translates into /any/ experience I had with RU academia
<whitequark>
like, neither the way it should've worked nor the way it was broken
<ELLIOTTCABLE>
whitequark: hm. To the point of ‘My entire monologue is inpenetratable to you’, or just ‘it's very foreign, but I understand functionally what is going on’?
<whitequark>
ELLIOTTCABLE: latter
<ELLIOTTCABLE>
basically it all just boils down to “I am extremely insecure and extremely stressed over it.” ¯\_(ツ)_/¯
<ELLIOTTCABLE>
whitequark: curious what RU is like. I know a lot of UK school-people, but *nothing* outside of that
<whitequark>
actually, that part I can understand very well
<ELLIOTTCABLE>
well, that and some things from Rurik.
<alexgordon>
lol whitequark
<purr>
lol
<ELLIOTTCABLE>
so like, 100 data-points for US, 10 for UK, 1 for Indian.
<ELLIOTTCABLE>
India*.
<ELLIOTTCABLE>
lol.
<whitequark>
ELLIOTTCABLE: ah so in short
<ELLIOTTCABLE>
brb btw, won't be replying interactively
<ELLIOTTCABLE>
whitequark: also, give me a todo list to convince you to lurk here reliably again :P
<whitequark>
we don't really have elective classes for the first few years
<alexgordon>
indeed
<whitequark>
you don't have or need an advisor to, again, go through the first few years, or basically any of your regular classes at all
<whitequark>
you *will* have an advisor for your bachelor's thesis starting with second year or something like that, but they wouldn't even know if you fail everything unless they specifically look for it
<whitequark>
you don't have to sit through lectures at all (though most 18-year-olds who think they'll be OK will fail if they don't) and in the rare case that school actually cares about lecture attendance, it is not hard to organize that, especially if you're older
<whitequark>
uh, it's also mostly free :p
<whitequark>
and even if not, tuition at the top university would be pocket change in comparison
<whitequark>
that being said, it seems that much of that isn't your core problem
<alexgordon>
in russia university pays for you!
<ELLIOTTCABLE>
actually most of that isn't far off
<whitequark>
I look forward to be scared to death the next time I have to take diffequations somewhere else and possibly dropping out again
<ELLIOTTCABLE>
- amongst my orientation group, almost all students were either full-ride, or close to it, amongst all the various aid programmes and scholarships and whatnot
<whitequark>
calculus is actually OK. I mean I still nearly failed it, but at least I like it
<ELLIOTTCABLE>
(that's just at this school though: it's a very need-based / multicultural school.)
<ELLIOTTCABLE>
(like, southside Chicago, what do you expect.)
<alexgordon>
whitequark: is university 4 years in russia or 3?
<ELLIOTTCABLE>
- this school is definitely unusual in requiring advisor sign-off before you can even register for your first-year classes;
<whitequark>
alexgordon: 5 or 6
<alexgordon>
!
<whitequark>
or 5.5
<whitequark>
6 for medical students, 5.5 for physics, 5 for everyone else
<ELLIOTTCABLE>
- and yeah, for most students, although the *arrangement* of the classes is variable a little bit; most students take the same sets of GenEds for the first few semesters.
<alexgordon>
for a bachelor's degree?
<whitequark>
for a degree.
<whitequark>
which translates to MSc.
<ELLIOTTCABLE>
which is exactly what I was stressing about, because I've done that *several times* in my life, and really could not stand to do any of them again
<alexgordon>
whitequark: there is no lower level?
<whitequark>
I think you can get an equivalent of BSc after three years but basically no one does that
<ELLIOTTCABLE>
so most of my stress and all is due to “special circumstances”, basically.
<whitequark>
I'm not even sure what the process is
<alexgordon>
I see
<whitequark>
we didn't use to have BSc/MSc distinction, it's importe
<whitequark>
d
<alexgordon>
that is rather hard core
<whitequark>
to interoperate with the rest of the world
<whitequark>
mm, not really
<ELLIOTTCABLE>
alexgordon: it makes sense to me
<whitequark>
the worst years are the first ones anyway
<ELLIOTTCABLE>
don't schools in the UK include the first year of ‘US College’ *in* high-school
<whitequark>
the people who live through first two years nearly always finish
<ELLIOTTCABLE>
like, we do, 2y middle-school, 4y high-school, 4y college (Bachelor's)
<whitequark>
ELLIOTTCABLE: I see
<ELLIOTTCABLE>
isn't England like, 3y middle, 4y high-school, 3y college?
<whitequark>
hm
<alexgordon>
ELLIOTTCABLE: yes we do our "minor" over 2 years from age 16
<ELLIOTTCABLE>
I heard that once somewhere, and it seems SO MUCH MORE SENSIBLE to me
<alexgordon>
whitequark: in uk BSc is 3 years and MSc is 4 years
<whitequark>
we have 4y primary, 3y middle, 4y high-school
<ELLIOTTCABLE>
all of the colleges here do the same, boring, barely-more-advanced-than-high-school shit for the first 2, 2.5 semesters
<whitequark>
alexgordon: 4 years on top of that?
<alexgordon>
I mean, you can do foundation year and shit, you could probably make it 6 years if you tried
<ELLIOTTCABLE>
like, why don't we just eject all that shit from “college” and make highsc-hoolers stay longer and do it
<alexgordon>
whitequark: no, just 4 total
<whitequark>
alexgordon: why doesn't everyone go for MSc then
<alexgordon>
whitequark: haha because they can't be bothered
<whitequark>
alexgordon: lazy asses
<alexgordon>
whitequark: depends on the job really
<alexgordon>
if you are doing art history, BSc, MSc doesn't make a difference
<ELLIOTTCABLE>
“Over the decade from 2010 to 2020, the continuation of the Bush-era tax cuts for only the super-wealthy (who make more then $250,000 per year) ...”
<whitequark>
alexgordon: well i guess
<alexgordon>
if you are doing a science, you probably need PhD
<ELLIOTTCABLE>
“... only the super-wealthy (who make more then $250,000 per year) ...”
<whitequark>
what?
<ELLIOTTCABLE>
“... the super-wealthy (... $250,000 per year) ...”
<whitequark>
it's like five more than median
<ELLIOTTCABLE>
ಠ_ಠ
<whitequark>
five fimes
<ELLIOTTCABLE>
wealthy, sure. I mean, around here, we reserve the term ‘wealth’ for the most part, to something on the order of 1m+, or so.
<whitequark>
ah
<ELLIOTTCABLE>
(That's what we call “upper-middle class.”)
<ELLIOTTCABLE>
but ... “super” wealthy
<alexgordon>
whitequark: and even then, it's hard to get a job in science even _with_ a PhD, maybe art history is the better choice
<ELLIOTTCABLE>
not even defensible.
<whitequark>
depends on your perspective I guess
<ELLIOTTCABLE>
(this is an article about/by/in the U.S., so I get how it might seem a little more accurate from an international perspective)
<ELLIOTTCABLE>
usually when speaking of the ‘super-wealthy’ here, you're talking about the 10m+ or even 100m+/yr
<ELLIOTTCABLE>
Like, I don't think *anybody I know* would call my family super-wealthy; but by that standard ...
<whitequark>
i recall how my "you're a rich fucker" programmer job in RU put me, like, way below poverty level in US
<whitequark>
even in better times for RUR
<alexgordon>
yes but I would rather live in russia than us
<whitequark>
alexgordon: that is very easy to organize
<alexgordon>
haha
<whitequark>
I think you need one or two years to naturalize?
<alexgordon>
is that all?
<whitequark>
basically
<ELLIOTTCABLE>
jesus, really?
<ELLIOTTCABLE>
yeah coming to the U.S. is a “lolno”
<purr>
lolno
<ELLIOTTCABLE>
Even though I hate it here, I'm very glad I was *born* here. Because that gives me the option of being here. >,>
<whitequark>
ah no
<whitequark>
five years
<whitequark>
but there was some simplified thing
<whitequark>
>Russian citizens can declare any ethnicity on a voluntary basis (real ethnicity as well as not real, including "Jedi", or "hobbits" according to the 2002 Russian Census official statistics.
<whitequark>
ELLIOTTCABLE: because it gives you the option for being nearly anywhere else, dummy
<alexgordon>
whitequark: I mean, if uk doesn't leave the eu I have a good choice of fucked up post soviet states
<whitequark>
alexgordon: many of those fare better than RU
<whitequark>
just don't go to Belarus
<ELLIOTTCABLE>
Fucked Up Post-Soviet States, or FUPSSes.
<whitequark>
like... not even once
<alexgordon>
haha indeed
<ELLIOTTCABLE>
7:22 PM <+whitequark> just don't go to Belarus
<ELLIOTTCABLE>
7:22 PM <+whitequark> like... not even once
<ELLIOTTCABLE>
-what
<purr>
<whitequark> terminal emulator as a profession
<ELLIOTTCABLE>
*reads ANSI codes verbally as colours irl*
<whitequark>
slash e left bracket zero semicolon thirty five emmm
<whitequark>
or in other words "purple"
<ELLIOTTCABLE>
lolololololol
<purr>
lolololololol
<ELLIOTTCABLE>
-learn purple = 7:23 PM <+whitequark> slash e left bracket zero semicolon thirty five emmm
<purr>
ELLIOTTCABLE: Learned `purple`.
<ELLIOTTCABLE>
-learn purple =~ s/.*</</
<purr>
ELLIOTTCABLE: Changed `purple` to: <+whitequark> slash e left bracket zero semicolon thirty five emmm
<ELLIOTTCABLE>
bbiab.
<Rurik>
whitequark, I am travelling to Belarus after collecting enough money
<ELLIOTTCABLE>
sounds like my code, alexgordon o_O
<LucIenn>
I was......makin things
<ELLIOTTCABLE>
makin things
<LucIenn>
Yes
<LucIenn>
Mario Makin things
<alexgordon>
ELLIOTTCABLE: anyone can write bad code, but it is quite a skill to write bad code that has no bugs
<ELLIOTTCABLE>
I don't think so.
<ELLIOTTCABLE>
This obviously applies to him, and not so much to me, but,
<whitequark>
alexgordon: you're simultaneously overgeneralizing and missing the point
<ELLIOTTCABLE>
“If everybody is saying you are wrong, but their solution doesn't work, and yours does ... then it's likely that *they* are all wrong.”
<whitequark>
djb does not write bad code. djb writes unreadable code that meticulously observes invariants that no one else cared about, including people writing readable code
<alexgordon>
"can djb write code so bad that he himself cannot find bugs in it?"
<ELLIOTTCABLE>
point being that ‘bad code’ is determined en masse, and has no actual experimental / derivative basis. So, obviously, if we consider his ‘bad code’, and yet his works better than most, then our definition of ‘bad code’ is inherently flawed.
<alexgordon>
whitequark: I know
<whitequark>
djb's code has few bugs not because someone FOUND it
<whitequark>
djb's code has few bugs BY CONSTRUCTION
<whitequark>
which is the point of it
<whitequark>
which is why he can afford to write 'bad' code at all
<whitequark>
ELLIOTTCABLE: there's much more than one aspect of badness of code
<whitequark>
some of them are objective, some of them are subjective
<whitequark>
if you can formally prove that the code is correct, then almost none of your subjective concerns matter
<whitequark>
basically
<whitequark>
'bad code' is not a thing, it's a meaningless moniker
<ELLIOTTCABLE>
*also* disagree, lol
<ELLIOTTCABLE>
for obvious reasons that don't need bikeshedding
<ELLIOTTCABLE>
can't decide which classes to sign up for this semester halp
<whitequark>
I don't even know what you're disagreeing with
<alexgordon>
whitequark: but the joke is that when the rest of us want to write good code, we _annotate_ the code with those invariants
<whitequark>
much less what is 'obvious' about it
<alexgordon>
djb is so brilliant that he can write what looks like any old mess, and it comes out perfect
<ELLIOTTCABLE>
whitequark: I think nearly anybody, anywhere, with an ounce of sense would disagree with you that ‘if the code is provably correct in every technical way, then it is good code.’
<ELLIOTTCABLE>
Like, to the point that I think it's completely unimportant to argue it with you? You and I can agree on all sorts of other important things and/or I can still learn from you on other topics and/or you can still contribute to others in this room, without agreeing on that topic; and so I decided it wasn't worth more than a passing note that I disagreed?
<ELLIOTTCABLE>
¯\_(ツ)_/¯
<ELLIOTTCABLE>
Like, “the readability and visual sense of a section of code is far more important than literally any other property of it” is a precept held near and dear to my heart.
<ELLIOTTCABLE>
Code isn't for computers. Code is for people. Rule #1 of programming.
<ELLIOTTCABLE>
(as far as I'm concerned. I'm very aware you don't agree, no need to refute, heh)
<whitequark>
ELLIOTTCABLE: *why* is code for people?
<whitequark>
no, really, it's not as simple
<whitequark>
in fact there are multiple levels of "not as simple here", and I am going to go through these one by one
* ELLIOTTCABLE
nods
<whitequark>
the obvious one is that if the code implements a fixed specification and never has to change, then it doesn't matter if anyone can read it or not. I'll trust my life to crypto proven correct over crypto that looks neat any day
<whitequark>
but that's not interesting to discuss.
<whitequark>
the one interesting to discuss is what happens when you take, let's say
<ELLIOTTCABLE>
I'm nearly religiously invested in this topic, so don't go in expecting to *change my mind*; but I'm happy to read
<whitequark>
a complex, evolving system, like an OS
<whitequark>
and try to formally prove it correct.
<whitequark>
do you know what happens?
<ELLIOTTCABLE>
Go ahead
<whitequark>
you have to invest a dozen people-years into making it motherfucking beautiful, in the architectural sense foremost, although the nutjobs who actually go through with it usually are into formatting as well,
<whitequark>
or else you fail.
<whitequark>
seL4 has the absolute best architecture of every OS I have ever read or heard of, because otherwise there would be /no way/ they could prove /one tenth/ of it correct
<ELLIOTTCABLE>
holy shit, there's a Homeworld *prequel* coming out?
<ELLIOTTCABLE>
I am so 100% into that on every level, including sexual
<ELLIOTTCABLE>
Holy. Shit. This looks amazing.
<alexgordon>
ELLIOTTCABLE: it depends on the problem the code is solving, does it not? when I write UI code, that is most definitely for people
<alexgordon>
really there is no notion of correctness for a UI, it's just what works best in user testing
<alexgordon>
ELLIOTTCABLE: but if you are optimising, then you are writing for the computer
<ELLIOTTCABLE>
alexgordon: not at *all* what I mean.
<alexgordon>
actually in both cases the code tends to be bad
<whitequark>
yeah alexgordon, even i disagree with that
<ELLIOTTCABLE>
Yes, but out of ‘write for people, not computers’ flows all sorts of good patterns; like, in that very example, it precludes premature optimisation.
<alexgordon>
UI code ends up being a rat's nest, because it goes through many iterations of testing and adjustment
<alexgordon>
and optimized code similarly tends to be harder to read
<ELLIOTTCABLE>
whitequark: So, I guess the first retort here is ‘This is a rule, not a law.’ As in, it's meant to be broken once you understand and adhere to it naturally, intuitively.
<ELLIOTTCABLE>
It's how you *should* write code, not how you *will always* write code, not how all code will always *be written*;
<alexgordon>
ELLIOTTCABLE: I'm not talking about premature optimisation, but actual optimisation. e.g. the syntax highlighting code in chocolat is the worst code I've ever written, because it's a hot loop and has to be FAST
<whitequark>
ELLIOTTCABLE: I phrase it as "/why/ should people read the code?"
<whitequark>
but yeah, probably the same thing
<ELLIOTTCABLE>
for example, of *course* tight-loop optimized stuff in systems-programming ... crypto *anything* ... a lot of mathematical-anything ...
<ELLIOTTCABLE>
those are the sorts of areas where it stops being as *useful* of a rule; the sorts of places where people-who-write-software-for-people will themselves still end up making decisions that lead to unreadable code
<ELLIOTTCABLE>
whitequark: exactly :P
<whitequark>
all code is mathematical something!
<ELLIOTTCABLE>
Like, you've literally found the crux of my taste in programming: I have zero interest in working on the things where readability doesn't come first.
<ELLIOTTCABLE>
I *deeply believe* those areas are, few and far between; but of course the things I listed are the things I don't work on, because I have almost no interest in them.
<whitequark>
I actually wonder what would happen if I trained an RNN on elliott's code
<ELLIOTTCABLE>
R?
<whitequark>
like, if visual appeal is the most important part, we can just deprecate elliott
<whitequark>
recurrent neural network
<ELLIOTTCABLE>
visual appeal ≠ readability, or written-for-humanity.
<ELLIOTTCABLE>
Like, you're strawmanning me here.
<ELLIOTTCABLE>
Of *course* ‘ooo he wants to write *pretty* code’ is an easy argument to attack, but that's not remotely my argument.
<whitequark>
I was going off 'visual sense'
<alexgordon>
ELLIOTTCABLE: actually I guess the problem is that it depends on how many ways of writing it there are
<ELLIOTTCABLE>
I'm saying a lot of very old, very well-respected programming advice boils down to ‘write it for the next person, write it for the people whom you're sharing it with, don't write it for the computer it's going to run on.’
<ELLIOTTCABLE>
alexgordon: *eyebrow*
<alexgordon>
when you optimize code, you are reducing the number of ways that the code can be written
<whitequark>
ELLIOTTCABLE: I... don't disagree with you then?
<alexgordon>
if that makes sense?
<whitequark>
like, I literally said that in the past
<ELLIOTTCABLE>
alexgordon: I *think* I read you?
<ELLIOTTCABLE>
whitequark: yeah, I'm not convinced we disagree, except, I suppose, in how you preach?
<ELLIOTTCABLE>
like ... how to even phrase this
<ELLIOTTCABLE>
I guess I don't believe we should be *talking about* crypto code, or tight-loop systems-level code, or,
<whitequark>
ELLIOTTCABLE: I'm not emotionally invested in readable code
<ELLIOTTCABLE>
because those don't apply to 90% of the people in this room. 99% of the people on Twitter. 99.9999% of the people beginning programming every day.
<whitequark>
which is not necessarily good, or bad
* ELLIOTTCABLE
tries to phrase
<whitequark>
but it seems the main difference here
<ELLIOTTCABLE>
Ahhah, here's a way to put it:
<ELLIOTTCABLE>
this statement is going to drive you up a wall. lol. but give me a moment to elaborate.
* whitequark
gives elliott side-eye
<whitequark>
alexgordon: lol how the hell did that code ever work
<alexgordon>
ELLIOTTCABLE: if you imagine all the ways of writing the code placed upon the number line (by their run time), each time you do an optimisation you have fewer and fewer ways of writing it
<whitequark>
alexgordon: ಠ
<alexgordon>
lol
<ELLIOTTCABLE>
A := “the kinds of code that *do* benefit from processes that reduce readability” (or, in general, just put readability second, third, Nth place importance, but not first)
<whitequark>
no seriously come on, your overgeneralizations are horrible
<alexgordon>
ELLIOTTCABLE: good code has the property that there are _many_ ways of writing it, so you have more choice to optimise for "readability" or whatever you want
<ELLIOTTCABLE>
(all the things we talked about above: crypto, particular kinds of systems programming, etc.)
<alexgordon>
whitequark: this is ##paws! or was
<ELLIOTTCABLE>
B := “all other code”
<ELLIOTTCABLE>
I believe that collaborative effort spent on improving A is *hugely* less valuable than effort spent on improving B.
<whitequark>
ELLIOTTCABLE: your statement that "crypto, systems code, etc" "benefits from processes that reduce readability" is bullshit
<alexgordon>
whitequark: there was that time this channel was _just_ about metaphysics
<ELLIOTTCABLE>
Ugh, that wasn't *nearly* as clear as I'd hoped.
<whitequark>
like, completely
<alexgordon>
ever time I tuned in it was metaphysical mumbo jumbo
<alexgordon>
*every
<ELLIOTTCABLE>
whitequark: that, as far as I can tell, is kind of your point: “Readability, and discussions surrounding readability, shouldn't take center stage for <types of code.>”
<ELLIOTTCABLE>
alexgordon: I blame glowcoil! :D
<whitequark>
ELLIOTTCABLE: er, no, not really
<whitequark>
let me try to put it properly
<ELLIOTTCABLE>
whitequark: yah? I mean, I completely accept I could be missing your point :P
<whitequark>
ELLIOTTCABLE: so let's take linux
<whitequark>
linux is systems code
<ELLIOTTCABLE>
I'm *definitely* not making mine, and am about to go back to school stuff. Not sure how I let myself get side-tracked by this in the first place O_O
<whitequark>
let's assume for a moment that linux is written like obscure crap because why not
<ELLIOTTCABLE>
(Systems, yes. *Way* too big, and broad, of a codebase, though, for me to buy that 99% of it shouldn't be readability-first.)
<whitequark>
the point I am *not* making is that this is good or this somehow benefits the systems-y aspects of Linux
<ELLIOTTCABLE>
whitequark: “let's assume for a moment that linux is written like obscure crap because why not” wat.
<ELLIOTTCABLE>
<3 <3 <3
<whitequark>
in fact, Linux specifically, would *hugely* benefit from the kind of readability you propose
<whitequark>
it would have less security holes than swiss cheese! improvement!
<whitequark>
crypto, same.
<whitequark>
openssl.
<whitequark>
nuff said
<whitequark>
it's awful BECAUSE it's unreadable
<whitequark>
it's hard to formally verify also BECAUSE it's unreadable, in your sense of readability, among other things
<ELLIOTTCABLE>
ah, yes, I see where you're going with this
<ELLIOTTCABLE>
can I try and summarize?
<ELLIOTTCABLE>
save you a lot of typing?
<whitequark>
I'm nearly done
<ELLIOTTCABLE>
common denominator of (elliott's readable) and (whitequark's analyzable) == some unique property, that is provable.
<ELLIOTTCABLE>
yes?
<ELLIOTTCABLE>
s/analyzable/safe/
<whitequark>
if the end purpose of the code you're writing is to give certain humans a certain power, and you can quantify it, and you can write a formal specification to it, (which is pretty rare), then it doesn't matter if it's readable
<whitequark>
because you are otherwise caring about tools, not the people whom these tools must be helping.
<whitequark>
if the complexity and scale of your tools means that to make them good you have no other option but to figure out an efficient way to collaborate with huge numbers of other humans, which is a good bet for the majority of our tools
<whitequark>
then, yes, readability is above all.
* ELLIOTTCABLE
nods
<ELLIOTTCABLE>
I *did* think that was your point, originally, but some of the things you'd said changed my mind. So a lot of my responses, yeah, off-point.
<whitequark>
still, the goal is to make them good, not collaborate per se.
<ELLIOTTCABLE>
I *still* don't agree, but for reasons I suspect you won't actually disagree with, either:
<whitequark>
if you *can* write a formal spec, then it is your obligation to, because it will make your tools better than any other thing you can do to them.
<ELLIOTTCABLE>
so let's replace my A/B with your two definitions: A := (small enough) AND (the need is specific enough) to formally specify, and B := everything else,
<ELLIOTTCABLE>
my issue with your point of view is basically that the set A doesn't exist in a vaccuum, and the set A is *remarkably small*.
<whitequark>
oh, yeah, absolutely
<alexgordon>
you should watch this video I was watching
<ELLIOTTCABLE>
and every tip, rule, thought, habit, that is learned; every tool, process or practice that is developed, *for A*,
<ELLIOTTCABLE>
*hurts all other software*, B.
<ELLIOTTCABLE>
That is my assertion.
<whitequark>
... what?
<ELLIOTTCABLE>
That people talking about and promulgating things specific to {A}, are damaging {B} in the process, and that That Is Bad and so we should all Focus On Readability.
<whitequark>
you haven't actually tried any of the tools created for A. you have never read any code created for A. you have never talked to any people that solve problems in A.
<whitequark>
fix that or gtfo
<ELLIOTTCABLE>
part of my point *being* that ‘readability’, as you sort of touched on, *often helps both A and B*. Yes?
<ELLIOTTCABLE>
uh, since when
<ELLIOTTCABLE>
Just because I don't write systems code, doesn't mean I don't hang out with systems people constantly, slash read systems code, slash ...
<ELLIOTTCABLE>
o_O
<whitequark>
what was the last large formally verified project you've studied?
<ELLIOTTCABLE>
alexgordon: ell, oh my lord, this is going to be full of gold
<ELLIOTTCABLE>
whitequark: I haven't *studied* anything. I'm not claiming that. Again: o_O
<whitequark>
and yet you have the audacity to insist that
<ELLIOTTCABLE>
Like, you're resorting to ad hominem instead of responding to my argument. Why? You're smart, and I know you have a more useful response than that? o_O
<ELLIOTTCABLE>
audacity. lol.
<whitequark>
"every tip, rule, thought, habit, that is learned; every tool, process or practice that is developed, *for A*, *hurts all other software*, B."
<ELLIOTTCABLE>
let me step aside for a second.
<ELLIOTTCABLE>
whitequark: I hope you're on the same page with me that there's buckets of optimization, or worse, ‘scaling’, advice out there ... and most of it is entirely hurtful to the industry?
<ELLIOTTCABLE>
Like, ... am I horribly off-base to assume you and I (and everybody else in this room) is on the same page for that?
<ELLIOTTCABLE>
(Not talking about verification, or systems, right now: I mean the reams of horrible ‘how to build your app RIGHT NOW so it's scalable AS BIG AS TWITTER OMG!’ stuff out there.)
<whitequark>
um, yes, sure, for many reasons, probably including yours
<whitequark>
though I don't really hear a lot of those.
<ELLIOTTCABLE>
I hang out in more horribly toxic web-dev circles than you
<ELLIOTTCABLE>
comes from using Node, Ruby a lot; comes from having less-hardcore programmer friends who work in PHP, comes from having irl friends who are more ‘entrepreneur’ / startup-y than they are programmer-y ... etc.
<whitequark>
let me try to rephrase what I'm trying to say and why it has no intersection with the point of view you're attacking
<ELLIOTTCABLE>
So, basically, the solid point amongst those *in the know*, those actually building those production systems (and yes, I *do* have the knowledge-base here), is pretty simple: “we don't really talk about how we scale, because if you *need to scale*, then *you already know who to ask to find out how*.”
<ELLIOTTCABLE>
Like, to rephrase that, I'd guess a parallel is that a lot of the useful things you're talking about are spread through academic journals; they're not the kind of thing you tweet, or that can be mis-interpreted by beginners.
<whitequark>
in practice, nearly always, restating code so that it can be formally verified does not make it less readable, i.e. harder to understand for humans
<alexgordon>
ELLIOTTCABLE: ^ that video is really good, but what I liked was the bit about "separation of concerns" being the driver behind technological progress. The idea is that the more interconnected a system is, the harder it is to evolve it [whitequark is going to get me for overgeneralisations again]
<whitequark>
it makes it massively EASIER to understand for humans
<whitequark>
that is the first half of my point
<ELLIOTTCABLE>
whitequark: I'd totally believe that, 100%. If only because that's likely to require a massive simplification of the design, first.
<ELLIOTTCABLE>
(like that's nearly, a given.)
<whitequark>
exactly.
<whitequark>
the goals aren't incompatible, they go hand in hand
<ELLIOTTCABLE>
and I still agree with that, for the most part
<whitequark>
the second half is that, if your system satisfies certain requirements, and is formally verified, and is not in need of evolution
<whitequark>
then it does not matter if it is readable
<whitequark>
because your goal is not to masturbate at your pretty tools, your goal is to solve someone's problem
* ELLIOTTCABLE
sighs
<ELLIOTTCABLE>
I don't want to start over, but I promise you you're missing my point.
<whitequark>
ok so what is it
<ELLIOTTCABLE>
The first half you mentioned, definitely not what I'm arguing against; the second half, definitely is
<ELLIOTTCABLE>
whitequark: do you really *want* me to re-state it, try to convey it? Do you care much?
<ELLIOTTCABLE>
like, I don't. I'd rather get back to school prep work stuff, y'know?
<whitequark>
I put the humans whose problem you are solving with software over those who collaborate with you on software, if you don't need to collaborate on that software anymore
<whitequark>
I don't understand what are you disagreeing with in that statement?
* ELLIOTTCABLE
nods
<whitequark>
like, it's a simple statement
<ELLIOTTCABLE>
Yes, that's your point as I understand it, and what I disagree with.
<whitequark>
why?
<ELLIOTTCABLE>
Maybe here's a simple retort that you'll understand?
<ELLIOTTCABLE>
“The benefit of <all people who use your particular software in isolation> as a group, is secondary to the benefit to <all people who use any piece of software, ever.> as a group.”
<ELLIOTTCABLE>
And arguing for readable code *without caveat*, just like arguing against ‘making decisions based on scalability’ *without caveat*, contributes to the latter.
<whitequark>
ah, I think I see
<ELLIOTTCABLE>
The point is that, yes, *the people who genuinely need to design for scalability*, already know that they need to do that? And you don't need to say, for their sake, “write maintainable code, except when it hurts scalability!” ...
<whitequark>
it's kind of
<ELLIOTTCABLE>
... they already know that ...
<whitequark>
"is software fungible?"
<whitequark>
is there everlasting value from writing any given piece of code in a good way?
<ELLIOTTCABLE>
my point here being that the same applies here. You don't *need* to tell the kinds of people working on crypto, systems, or formally-verifiable-systems in general, that, “yes, you can skimp on readability when you're going for verifiability: you get enough of that for free.”,
<whitequark>
or will it be thrown out and forgotten?
<whitequark>
oh, no, not that
<ELLIOTTCABLE>
so talking about that … doesn't help those people, which leaves me asking, “who are you helping by claiming that?”
<whitequark>
yeah, then I don't think you are disagreeing with me
<alexgordon>
this conversation is a clusterfuck
<ELLIOTTCABLE>
the answer is: nobody. That argument is *helping* nobody, but is definitely *hurting* beginners who are looking for reasons not to undertake the hard work of writing readable code, even when it seems unintuitive.
<whitequark>
like, I am talking about a philosophical point
<whitequark>
I would never give that as an advice
<ELLIOTTCABLE>
whitequark: and I, a concrete one?
* ELLIOTTCABLE
nods
<ELLIOTTCABLE>
maybe we're on the same page, then, after all. I'm not sure anymore. /=
<ELLIOTTCABLE>
like, 99% of what I do, or say, is couched in “What makes us all better programmers?”
<whitequark>
I think so? like, I wouldn't have this argument about any specific software project
<whitequark>
or even any specific intent in software
<ELLIOTTCABLE>
99% of the time, I'm thinking primarily of the beginner: what helps them to advance? what makes them feel welcome, and what improves their skills; what gets them hired and happy; what makes them *stick around* and write more code in the future to help all of mankind
<alexgordon>
it is impossible to say anything about programming without giving a context. Like I can say that I am most productive when I use X, but if I work with people who don't know X, maybe it's not such a good idea
<ELLIOTTCABLE>
Of *course* there's real, actual situations, where scalability is a Real Thing and not a joke that we all laugh about. But they're so few and far between by comparison to startups that are probably going to fail, or operate on the margins of a small number of customers ... that any advice relating to scalability is by definition just going to exclusively do
<ELLIOTTCABLE>
harm.
<ELLIOTTCABLE>
But that opinion doesn't preclude the aforementioned existence of those situations, at all?
<ELLIOTTCABLE>
¯\_(ツ)_/¯
<whitequark>
ELLIOTTCABLE: yeah sure I guess I agree?
<whitequark>
it's just
<whitequark>
you should've stated that upfront
<whitequark>
and saved us the time lol
* ELLIOTTCABLE
goes to read the original argument
<alexgordon>
lol.
<ELLIOTTCABLE>
8:47 PM <+whitequark> if you can formally prove that the code is correct, then almost none of your subjective concerns matter
<ELLIOTTCABLE>
I think that originated it
<whitequark>
you stated it without caveat right away AND said that you know I disagree
<ELLIOTTCABLE>
basically I read that in a universal context, and you meant it in a philosophical context?
<whitequark>
yes
<ELLIOTTCABLE>
or rather, I read it in the context of Software Engineering as an industry; and you meant it in the context of one isolated project?
<whitequark>
we don't have formal methods that work *not* on isolated projects
<whitequark>
like, when we will do, the industry will look absolutely nothing it looks like right now
<ELLIOTTCABLE>
my argument was basically against my own reading of that as you saying “A programmer should work towards formal verification, because it supercedes readability.”
<whitequark>
none of the shit we discusswill matter anyway
<whitequark>
oh
<whitequark>
lol no
<ELLIOTTCABLE>
oh lord isn't that true as fuck
<whitequark>
lol
<ELLIOTTCABLE>
I've thought about this before:
<ELLIOTTCABLE>
I want static analysis tools for programmers, not for programs.
<whitequark>
... well, obviously?
<whitequark>
there's a reason it's called a fucking proof assistant
<ELLIOTTCABLE>
Not saying it's inobvious :P
<whitequark>
no one is making analysis tools for programs that work
<whitequark>
it's basically impossible
<whitequark>
it's a black hole for funding which produces no real results
<whitequark>
you are almost unable to meaningfully analyze programs that were not constructed to be analyzed!
<ELLIOTTCABLE>
9:32 PM <+whitequark> it's a black hole for funding which produces no real results
<ELLIOTTCABLE>
I think my favourite micah thing: qft'ing
<ELLIOTTCABLE>
thx glowcoil thx thx
<whitequark>
what?
<ELLIOTTCABLE>
lol nothing
<ELLIOTTCABLE>
glowcoil had an old habit of not actually *participating* in a conversation in terms of new input
<ELLIOTTCABLE>
he'd sit by and observe, and then sort of ‘fav’ a line somebody else said simply by copy-pasting it
<ELLIOTTCABLE>
like a hacky ‘upvote’ mechanic for IRC
<whitequark>
yes but why qft
<alexgordon>
quoted for truth
<ELLIOTTCABLE>
and for a short while a few others picked it up, so we had a neat dynamic in here where two or three people would be actually arguing, and then like four or five others would be contributing by upvoting lines
<ELLIOTTCABLE>
oh
<ELLIOTTCABLE>
ahhah >,<
<ELLIOTTCABLE>
whitequark: because I'm broadly against static analysis.
<ELLIOTTCABLE>
Again, since I fucked it up last time: in the context of the wider industry, and in specific in terms of advice to not-already-super-ninja-master-programmers.
<ELLIOTTCABLE>
It's hand-in-hand with my views on FP. <.<
<whitequark>
ELLIOTTCABLE: let's make a deal
<whitequark>
I will not have an argument about those with you right now, and you'll spend that time figuring out solvespace
* whitequark
grins
* ELLIOTTCABLE
laughs
<ELLIOTTCABLE>
whitequark: I like you more and more.
<ELLIOTTCABLE>
whitequark: I'd wager that you're more open to talking to me, now that you know I'm in school for CS.
<ELLIOTTCABLE>
y/n/agender?
<whitequark>
no
<whitequark>
I just wasn't in channel for quite a while
<ELLIOTTCABLE>
Like, basically, saying ‘you should dump whatever language you use, and write it in Haskell!’ or ‘you should formally specify your system and write it to be analyzed!’ ... is, great, and sure. and yeah and fun and you'll learn a lot and yay.
<ELLIOTTCABLE>
... except that that's a red-herring for Joe Blow writing a Rails app.
<whitequark>
so I am less tired of your stupid opinions
<ELLIOTTCABLE>
like, that's not going to Improve The World as much as teaching them to write better, more readable, Ruby code. ¯\_(ツ)_/¯
<whitequark>
seriously though
<whitequark>
I hate Haskell
* ELLIOTTCABLE
eyebrows
<whitequark>
I would never suggest anyone use Haskell, much less over Rails, where it makes /absolutely zero sense/
<ELLIOTTCABLE>
Would *not* have called that. Would be curious to hear more ... another time.
<alexgordon>
haskell is godawful
<alexgordon>
me and whitequark agree on something, hooray
<whitequark>
ELLIOTTCABLE: I can't stand pure FP either
<ELLIOTTCABLE>
yeah, very much on the same page, on several levels, lol.
<whitequark>
it's a super domain specific technique
<ELLIOTTCABLE>
9:37 PM <+whitequark> it's a super domain specific technique
<whitequark>
that's not only overblown but also there's so many assholes arguing for it
<ELLIOTTCABLE>
need qft support in purr plz
<whitequark>
that it's almost time to rename it into something useful
<ELLIOTTCABLE>
I have come to love what I know of functional programming and static analysis ... for *small chunks* of a system
<whitequark>
like... broadly speaking, reducing the amount of mutation often can make code more readable!
<whitequark>
but absolutely not all the time
<ELLIOTTCABLE>
Haskell is exactly as bad as Java
<alexgordon>
whitequark: I can't remember where I read it, but some old timer was complaining that "we moved to OOP to get away from functional programming, why do the kids want to bring it back?"
<whitequark>
there's shittons of useful code that are vastly more readable WITH rampant putation
<ELLIOTTCABLE>
and for no reason having *anything* to do with OO or FP,
<whitequark>
ELLIOTTCABLE: kinda
<ELLIOTTCABLE>
and *every* reason to do with ‘purity’ and believing there's One True Paradigm,
<whitequark>
there's benefits to using One True Paradigm! in both Java and Haskell! and they are unconvincing for most things I do.
<whitequark>
saying a language is "FP" is so much less useful than discussing the elements of FP in it that actually help
<whitequark>
same with "OO"
<whitequark>
see: OCaml
<alexgordon>
well it's clear (to me) that the good parts of FP are the combinators
<whitequark>
it's not "hybrid". "hybrid" is meaningless. it has elements of FP and OO that serve specific purpose in its design
<whitequark>
alexgordon: jesus christ you are one of THOSE people
<ELLIOTTCABLE>
‘"hybrid" is meaningless.’
<ELLIOTTCABLE>
whitequark: alexgordon is one of THOSE people, for any possible definition of ‘THOSE.’
<alexgordon>
whitequark: I mean like map, filter, groupBy, sortBy, etc
<whitequark>
"hybrid" is akin to admitting that your classification sucks, except while trying to save face
<whitequark>
alexgordon: oh you aren't. phew
<alexgordon>
lol
<ELLIOTTCABLE>
I'm very very tentatively convinced he's been long-trolling this entire channel, this entire time :P
<whitequark>
ELLIOTTCABLE: he is
<whitequark>
you, too
<alexgordon>
I dunno what you want to call them... function functions?
<whitequark>
alexgordon: higher-order functions is the usual name
<ELLIOTTCABLE>
functors?
<LucIenn>
(What is even going on right now I'm gone for a few hours and there's a small novel of programmer talk waiting for me)
<alexgordon>
that is _three_ words
<alexgordon>
:P
<ELLIOTTCABLE>
LucIenn: welcome to this channel
<whitequark>
"function functions" isn't a very bad name either tbh
<ELLIOTTCABLE>
LucIenn: you don't have to read everything you miss. that will quickly drive you mad.
<alexgordon>
ELLIOTTCABLE: nah a functor is a map between categories
* whitequark
slaps alexgordon around a bit with a large trout
<ELLIOTTCABLE>
seriously though something told me ‘functor’ was a term for a higher-level function
<LucIenn>
ELLIOTTCABLE: trust me I'm not
<alexgordon>
well you have real functions, complex functions, function functions
<whitequark>
yeah
<whitequark>
it's just... not really used
<whitequark>
but it't not a bad name
<whitequark>
so, I tried to fix solvespace about 2.5 hours ago
<alexgordon>
^ anyway pretty much all the good stuff of FP is embodied in a library like underscore/lodash
<whitequark>
ELLIOTTCABLE: told you he is trolling
<alexgordon>
moi?
<whitequark>
no
<whitequark>
I'm not going to respect that statement by replying
<ELLIOTTCABLE>
whitequark: were you speaking to me?
<alexgordon>
lodash's site is hella broken
<alexgordon>
in safari
<ELLIOTTCABLE>
whitequark: I mean, precisely the good stuff he previously claimed, *is* embodied by lodash and frens
<ELLIOTTCABLE>
unfortunately javascript+lodash *isn't* really The Good Parts of FP, for at least one big reason, to me: laziness
<alexgordon>
laziness?!
<ELLIOTTCABLE>
like, I suspect you need first-class linguistic support (yes, I know recent lodashes have *some* lazystuff)
<whitequark>
ELLIOTTCABLE: does it have pattern matching?
<ELLIOTTCABLE>
to really get the *value* out of writing parts of your program in a purist FP sense
<ELLIOTTCABLE>
whitequark: hell no lol.
<alexgordon>
pattern matching is a language feature
<whitequark>
like... that's basically THE readability improvement of FP
<ELLIOTTCABLE>
whitequark: do you really think pattern matching is a part of FP?
<whitequark>
yes.
<whitequark>
it's the most important part of FP
<ELLIOTTCABLE>
I consider them completely separate; but showing up together often.
<ELLIOTTCABLE>
whaaaaat.
<ELLIOTTCABLE>
tell me more.
<whitequark>
if you ask me, FP is all about inductive reasoning over immutable data
<alexgordon>
whitequark: but various compile-to-js languages do have pattern matching (es6 iirc?)
<whitequark>
you *have* to use pattern matching for inductive reasoning, if you want it to be readable, for varying definitions of.
<ELLIOTTCABLE>
I mean, lisp is functional, and doesn't have linguistic pattern-matching?
<ELLIOTTCABLE>
or wait, there's, like, syntax-rules, but … hm
<ELLIOTTCABLE>
does that qualify in the same way o_O
<alexgordon>
hell you can use elm which is haskell-like
<whitequark>
I don't really consider common lisp a functional language
<ELLIOTTCABLE>
actually, don't. we both have better things to do.
<ELLIOTTCABLE>
UGH
<whitequark>
like, it has elements of FP
<ELLIOTTCABLE>
I WANT TO SUCK IN ALL OF UR NOLLIJ EVERY TIME YOU COME IN HERE
<ELLIOTTCABLE>
whitequark: go become teacher, I'd go to ur skool
<whitequark>
ELLIOTTCABLE: so you know how you traverse a list in lisp?
<whitequark>
ELLIOTTCABLE: go through all the cons cells
<whitequark>
and call urself recursively
<whitequark>
tail-call etc
<ELLIOTTCABLE>
wow, whitequark just used ‘ur’
<ELLIOTTCABLE>
go on
<whitequark>
this is a good example
<ELLIOTTCABLE>
I'm rubbing off :D
<whitequark>
...
<whitequark>
alright
<whitequark>
I can work with that
<whitequark>
so you have that in common lisp, for some things, a little bit of the time
<alexgordon>
I hate recursion
<whitequark>
but if you don't have pattern matching, then you can't express operations over your domain models using inductive reasoning every time you have a choice of 'one of'
<alexgordon>
for functions that don't require it
<whitequark>
you can still dissect your lists manually and ask them (nil?) and such
<ELLIOTTCABLE>
I don't use CL, er, is it substantially different from scheme?
<whitequark>
very.
<ELLIOTTCABLE>
I mean, my lisp experience is 1. r5rs, and 2. a tiny tiny bit of clojure
<whitequark>
common lisp doesn't even have tail recursion
<ELLIOTTCABLE>
9:49 PM <+whitequark> but if you don't have pattern matching, then you can't express operations over your domain models using inductive reasoning every time you have a choice of 'one of'
<ELLIOTTCABLE>
*reads twice*
<whitequark>
you can't iterate a list in CL using a recursive function! not in real-world
<whitequark>
ELLIOTTCABLE: that was fairly badly phrased
<whitequark>
let me try again
<ELLIOTTCABLE>
k rephrase
<ELLIOTTCABLE>
inductive reasoning is your point here, so srsly, define
<ELLIOTTCABLE>
I've seen the phrase before and have a sketchy idea, but, what do you mean by it here, what are you saying About Programming
<alexgordon>
[03:48:12] <+ELLIOTTCABLE>I'm rubbing off :D
<ELLIOTTCABLE>
alexgordon: true in every sense
<alexgordon>
TMI
<whitequark>
ELLIOTTCABLE: rephrasing
<ELLIOTTCABLE>
alexgordon: ಠ‿↼
<alexgordon>
HARPOON
<whitequark>
let's say you have a recursive data structure
<whitequark>
(e.g. a lisp list)
<whitequark>
if you want to perform an operation over the entire data structure, you can define a 'step', a function that does something with the non-recursive part (like the element of the list) and then calls itself again for the rest (like the tail of the list)
<whitequark>
the advantage of this over, like, a for loop, is that for every step, you only look at a tiny chunk of the entire state (one element) instead of the entire huge list
<whitequark>
so, it's an improvement in locality. you have less things to think about.
* ELLIOTTCABLE
nods
<whitequark>
now, let's look at the ways that data structures can be defined
<whitequark>
how can we look at the domain knowledge and describe it in our programming language?
<ELLIOTTCABLE>
I fucking love this comic so much, omfg
<whitequark>
you can imagine that you could do all other useful stuff with things in other parts of the language, with which it's trivially extensible.
<whitequark>
let's say we have numbers. 1, 2, 3. strings, too. "a", "b"
<whitequark>
no, in an abstract sense of "interrogate"
<ELLIOTTCABLE>
k
<whitequark>
"do anything differently depending on the content of the object".
<whitequark>
again, abstract sense of "object".
<whitequark>
just some thing that exists in the language.
<whitequark>
k?
<whitequark>
let's call it "thing".
<ELLIOTTCABLE>
k
<whitequark>
1 is a thing. "a" is a thing.
<whitequark>
number, string.
<whitequark>
now, I introduce the syntax for products: (1, "a") is a thing. it is a product. of a number and a string.
<whitequark>
this is how we /construct/ (I introduce this term) a product, when we already have the parts of a product.
<whitequark>
now, what can we do with a product, once it is constructed?
<whitequark>
we can now /deconstruct/ the product, using an inverse operation. let's say variable x contains (1, "a").
<whitequark>
this is how we deconstruct it: match x with (a, b) -> ...
<whitequark>
within ..., which is some code, variable a contains 1, and variable b contains "a".
<ELLIOTTCABLE>
yah, got it
<ELLIOTTCABLE>
deconstructing and a let binding, basically?
<ELLIOTTCABLE>
sorry, re-using deconstructing in a, idk, CoffeeScript / Ruby sense
<whitequark>
deconstructing in Ruby sense is a special case of this.
<whitequark>
let's go a bit further.
<ELLIOTTCABLE>
k go
<whitequark>
let's write some code like this:
<whitequark>
match x with (1, b) -> ...u | (a, b) -> ...v
<ELLIOTTCABLE>
u? v?
<ELLIOTTCABLE>
oh
<whitequark>
now, if the number in the product is 1, the code ...u will be executed, with b containing the string
<ELLIOTTCABLE>
yeah
<whitequark>
great
<whitequark>
what I want to put emphasis on, now,
<ELLIOTTCABLE>
(assuming you've got a reason for re-explaining pattern matching itself from base principles :P)
<whitequark>
is that the syntax for deconstruction is the mirror image of the syntax for construction
<ELLIOTTCABLE>
(still listening)
<ELLIOTTCABLE>
as in, the (,) part?
<whitequark>
yes.
<ELLIOTTCABLE>
k
<whitequark>
you can nest it arbitrarily deep: match x with (1, (a, b), 2) -> ...
<whitequark>
etc.
<whitequark>
and you construct it in exact same way.
<whitequark>
now this was the boring part. Ruby can do some of this! (with one match case)
<whitequark>
now for the exciting part.
<whitequark>
I introduce the synax for sums. A(1) is a thing. it is a /variant/, which is a component of a sum. it has a number inside.
<whitequark>
B("a") has a string inside.
<ELLIOTTCABLE>
ick wait
<ELLIOTTCABLE>
reading
<ELLIOTTCABLE>
k go on, hopefully to define ‘A’/‘B’ and what they mean syntactically
<ELLIOTTCABLE>
i.e. why those aren't both A()
<whitequark>
so in this toy language, any uppercase word defines a variant
<whitequark>
and the name of the variant, that uppercase word, it's essentially a marker.
<ELLIOTTCABLE>
defines, in the a = ... versus A(...) sense?
<ELLIOTTCABLE>
sorry go on
<whitequark>
you say that you grab all the stuff in the parens and give it a marker A.
<whitequark>
or B. or whatever else.
<whitequark>
you can even put a product there, like A(1, "x")
<whitequark>
makes sense?
* whitequark
coughs
<alexgordon>
lol
* ELLIOTTCABLE
reading again
<ELLIOTTCABLE>
nope, absolutely does not.
<ELLIOTTCABLE>
where is the ‘set of things’ that makes a sum, well, a sum
<whitequark>
mhm
<ELLIOTTCABLE>
oh, wait, all of the above is termed as ‘variants’
<ELLIOTTCABLE>
gotchoo, that's coming presumably.
<whitequark>
yes.
<ELLIOTTCABLE>
so then there's a syntax for ‘A *OR* B’?
<ELLIOTTCABLE>
and I'm confused by what a variant *is*. or maybe, uh, ‘what a variant is over?’ is this a typing thing?
<ELLIOTTCABLE>
is ‘B’ basically “string”, or is it specifically, “this instance of this string with this content?”
<ELLIOTTCABLE>
what does B *mean*?
<whitequark>
I'm intentionally avoid saying anything about type systems because you don't *need* a type system to be an FP lang or to get benefits of pattern matching
<whitequark>
e.g. Erlang doesn't have one!
<whitequark>
and also because speaking about type theory tends to turn brains off, ahem
<whitequark>
anyway, let me elaborate
<whitequark>
"B" on its own is nothing, it's just a part of syntax
<whitequark>
"B(1)" is a value, a variant, that has "1" inside and is marked "B"
<ELLIOTTCABLE>
k
<ELLIOTTCABLE>
double-checking
<ELLIOTTCABLE>
‘a value’, but not ‘a thing’, in the above sense of thing.
<ELLIOTTCABLE>
I cannot then b = B.
<ELLIOTTCABLE>
yiss?
<whitequark>
"B" is not a value or a thing. you can't assign "B" anywhere.
<ELLIOTTCABLE>
but while not first-class, it is nonetheless concrete? that is your point, if I'm reading correctly?
<alexgordon>
ELLIOTTCABLE: imagine you had two JS objects: { "kind": "string", "val": "Hello" } and { "kind": "number", "val": 42 }. Now you have a union over String and Number.
<whitequark>
"B(1)" is a value, and a thing
<ELLIOTTCABLE>
sorry, <the variant referred to as B>?
<ELLIOTTCABLE>
alexgordon: shh too many cooks go 'way
<alexgordon>
:(
<whitequark>
(sorry, I screwed up, value and thing are synonyms here)
<ELLIOTTCABLE>
okay, wasn't sure, now I am
<whitequark>
ELLIOTTCABLE: "B" itself is not first-class.
<whitequark>
you can't do anything with "B".
<ELLIOTTCABLE>
so how is B(1) different from just plain 1?
<ELLIOTTCABLE>
and more importantly, how is it different from A(1)
<ELLIOTTCABLE>
... it *is* different, yes? presumably?
<alexgordon>
ELLIOTTCABLE: A is like "kind": "string", and B is like "kind": "number", ya?
<whitequark>
yes, absolutely
<whitequark>
ELLIOTTCABLE: this is a very good question
<whitequark>
remember that in our toy language, there are two operations: construction and deconstruction.
<whitequark>
I've explained how to construct variants.
<alexgordon>
A(1) reads as "a thing of kind A, with value 1"
<ELLIOTTCABLE>
okay, so a variant is just *what you get when you construct this way*. No other semantic associated yet.
<ELLIOTTCABLE>
?
<whitequark>
correct.
<ELLIOTTCABLE>
testing:
<ELLIOTTCABLE>
can I meaningfully A(1) or B("a")?
<whitequark>
yes.
<ELLIOTTCABLE>
again, I'm clearly caught up in types, but, go ahead
<whitequark>
you get a value/thing.
<whitequark>
alright.
<whitequark>
now, I say that you can also deconstruct them: if x contains A(1), match x with A(a) -> ... will have a containing 1 inside the code denoted ...
<ELLIOTTCABLE>
and the value/thing, identity-wise,
<ELLIOTTCABLE>
A(1) ≠ B(1), A(1) ≠ A("a")?
<whitequark>
yes.
<ELLIOTTCABLE>
oh lord A() is just a symbol associated with it
<whitequark>
yes.
<ELLIOTTCABLE>
alexgordon confused me with his types
<ELLIOTTCABLE>
see, alexgordon, like I sai,d too many cooks
<alexgordon>
you mean the kinds? I said kind instead of type
<ELLIOTTCABLE>
would have made a lot more sense to me
<ELLIOTTCABLE>
if I have this right, right?
<whitequark>
ELLIOTTCABLE: I'm also intentionally avoiding any parallels with existing languages, because it carries lots of baggage
<ELLIOTTCABLE>
now I murkily see the connection to enums.
<ELLIOTTCABLE>
okay go on
<whitequark>
introspection, mutability, etc
<ELLIOTTCABLE>
yeah ignore my pseudo-JS
<whitequark>
ok so the point of all this crap is
<ELLIOTTCABLE>
was just idk correcting alexgordon, but I think I get it in terms of your language.
<ELLIOTTCABLE>
10:28 PM <+whitequark> now, I say that you can also deconstruct them: if x contains A(1), match x with A(a) -> ... will have a containing 1 inside the code denoted ...
<ELLIOTTCABLE>
lemme re-read that
<alexgordon>
ELLIOTTCABLE: ok. I was giving an example from my actual code
<ELLIOTTCABLE>
that isn't all code, right? the code is `match x with A(foo) -> ...`
<ELLIOTTCABLE>
yeah okay
<ELLIOTTCABLE>
go on
<whitequark>
yep
<whitequark>
let's say you know that variable x can contain `A(n)` where n is some number, or `B(s)` where is some string.
<whitequark>
it doesn't matter HOW you know that.
<whitequark>
you just do.
<ELLIOTTCABLE>
alexgordon: I don't hate you! There's just a special tutor/learner relationship that you stepped in the middle of, and you got my dirty tutorial-juices all over you, and it's not my fault. ;)
<ELLIOTTCABLE>
whitequark: mmhmm?
<ELLIOTTCABLE>
alexgordon: that was supposed to be a sex joke.
<alexgordon>
uh oh
<whitequark>
now you can do: `match x with A(n) -> ...u, B(s) -> ...v`. inside ...u, n will contain the number, inside ...v, s will contain the string.
<whitequark>
you can also do things like
<whitequark>
`match x with A(1) -> ...u, A(n) -> ...v, B(s) -> ...w`
<whitequark>
basically, any way you can construct a value/thing, you can also use to deconstruct it.
<ELLIOTTCABLE>
slow, slow
<whitequark>
and the corresponding branch will execute if it matches.
<ELLIOTTCABLE>
reading
<whitequark>
ok
<ELLIOTTCABLE>
like, yes
<ELLIOTTCABLE>
(just to be clear the purpose of all this is to show me how FP is useless w/o pattern-matching, I think?)
<whitequark>
you could put it that way.
<whitequark>
so I've explained products and sums and pattern matching
<ELLIOTTCABLE>
mmhmm, I believe I've got it
<whitequark>
the point I am trying to make is that, when you have sums and pattern matching (which almost always go hand in hand), you have two specific advantages over any kind of language where you don't
<whitequark>
1. construction resembles deconstruction, *no matter how complex your data structure is*
<ELLIOTTCABLE>
and haskell has sums by dint of types, exclusively, yes?
<whitequark>
2. when a match that mentions a sum executes, you *only* get the data that you know was inside the corresponding variant
<whitequark>
there is no way you will get anything that is not relevant to the variant.
<whitequark>
1. applies to common lisp and js/ruby/etc, 2. applies only to javascript/ruby/etc
<whitequark>
since on OO-is-central languages, you only really have products.
<whitequark>
ELLIOTTCABLE: I don't quite get your statement about haskell?
<ELLIOTTCABLE>
I mean, like, hurm,
<ELLIOTTCABLE>
this all seems like a very obvious explanation of what I understand of pattern-matching,
<ELLIOTTCABLE>
trying to see how it links back, in my head, to the utility of ‘writing pure functions for tasks which benefit from that’
<ELLIOTTCABLE>
or even, more relevantly, ‘allowing pure functions in your lanuage’ as opposed to being Java-esque OO.
<alexgordon>
it's nothing to do with pure functions
<alexgordon>
rust has all this stuff
<whitequark>
rust is a real corner case here
<alexgordon>
and it is not a pure language
<whitequark>
because most FP patterns don't work in rust
<alexgordon>
ok but it's orthogonal
<whitequark>
and while it does have pattern matching, you often wrap it in imperative-looking wrappers because reasons
<alexgordon>
you can write pure functions in a langauge without pattern matching+sum types
<alexgordon>
and vice versa
<whitequark>
(mostly to do with borrow checking and interior mutability)
<whitequark>
alexgordon: yes.
<whitequark>
ELLIOTTCABLE: ok so let me tie that back
<ELLIOTTCABLE>
10:39 PM <alexgordon> you can write pure functions in a langauge without pattern matching+sum types
<ELLIOTTCABLE>
10:39 PM <alexgordon> and vice versa
<ELLIOTTCABLE>
so hold on a sec
<ELLIOTTCABLE>
just to verify that we're not wasting hours here:
<alexgordon>
ELLIOTTCABLE: also you should probably define what you mean by "pure", so we are on the same page
<ELLIOTTCABLE>
you still are asserting that a language that *allows pure functions*, still cannot be utilized to a substantial extent of the ways that Haskell (say), can be utilized?
<ELLIOTTCABLE>
ugh that phrasing was HORRIBLE.
<alexgordon>
ELLIOTTCABLE: errr, I don't think so?
<ELLIOTTCABLE>
alexgordon: Java basically doesn't allow you to have a function that has no side-inputs or side-outputs.
<whitequark>
literally every language allows pure functions for a mostly meaningful value of "pure". even C.
<ELLIOTTCABLE>
in a language like JavaScript, (using, as you mentioned, things like lodash or similar libraries), you can *write usefully pure code* for a subset of your project.
<alexgordon>
ELLIOTTCABLE: what do you mean by pure
<whitequark>
never set variables except inside constructors. done, you made Java pure
<ELLIOTTCABLE>
I assert that you can get 95% of the benefit of a fully pure language, with simple discipline and choosing your battles wisely, in a non-*purely* FP language
<ELLIOTTCABLE>
(which it sounds like whitequark agrees with),
<whitequark>
yes
<ELLIOTTCABLE>
but he added a point about pattern matching that I don't get.
<ELLIOTTCABLE>
as in, I don't see how not-having-pattern-matching makes those benefits inaccessible in, say, JavaScript?
<ELLIOTTCABLE>
:x
<whitequark>
ELLIOTTCABLE: can I finish? I think the last part is a very simple implication
<ELLIOTTCABLE>
go on go on
<alexgordon>
yes go on whitequark I will stfu :P
<ELLIOTTCABLE>
am listen am listen
<ELLIOTTCABLE>
need pee need pee D:
<ELLIOTTCABLE>
am cookie am cookie am cookie am cookieam cookie am cookie
<ELLIOTTCABLE>
am pee am cookie
<ELLIOTTCABLE>
not at sae time
<whitequark>
let's say you are writing code using FP patterns. it doesn't matter what your language is, you can write puree-ish code in any language
<whitequark>
when you try to do that, you see that, when you are using FP patterns--specifically, avoiding mutation, you are constructing and deconstructing values most of the time.
<whitequark>
in fact, since you don't mutate values, there is literally nothing else you can do to them except construct and deconstruct--in the sense of the toy language we've just defined
<whitequark>
therefore, it is sensible to build your language with the understanding that people writing it will mostly construct and deconstruct values.
<whitequark>
moreover, we can observe that some of the domain concepts are naturally resembled by products, and other domain concepts are naturally represented by sums
<whitequark>
therefore, while you can emulate a sum using a product, it is better to introduce sums directly. why?
<whitequark>
well, how would you cope if you only had products?
<whitequark>
you could do something like
<whitequark>
represent A(1) as ("A", 1, "")
<whitequark>
represent B("s") as ("B", 0, "s")
<whitequark>
then, say, pattern-match, or ifelse, or whatever, on the first part of the product.
<whitequark>
however, this requires you to be able to successfully construct some kind of a dummy value ("nil"?) for the parts you don't want, and then it leaves you to somehow handle those parts every time you deconstruct it
<whitequark>
my chain of reasoning goes like this:
<ELLIOTTCABLE>
“All old coins dating from the first dollar were reintroduced at face value to the third dollar in Aug 2008, effectively increasing their value 10 trillion-fold, and new $10 and $25 coins were introduced. These coins were minted in 2003 but only issued with the redenomination.” jesus christ
<alexgordon>
whitequark: this isn't a concern in OO languages though, because the class Object acts like a universal set. You can indeed do ("A", 1) and ("B", "s") using only products. The trade-off is that you only get runtime type checking
<whitequark>
you want to write code using FP patterns → it leads to lots of construction and deconstruction → construction and deconstruction are most readable when you have pattern matching, which resembles construction → pattern matching allows you to manipulate variants very efficiently
<whitequark>
therefore, the full benefit of introducing FP concepts into your language is most apparent when it is done together with variants and pattern matching,
<whitequark>
and the difference in readability, in practice, is so drastic, that I am arguing that introducing FP concepts *without* those is nearly useless.
<ELLIOTTCABLE>
I'm right there with you all the way.
<ELLIOTTCABLE>
but you've definitely convinced me that I'd write a lot more pure-functional chunks of my libraries if JS had pattern-matching, because you've definitely hit a pain-point.
<alexgordon>
whitequark: well yes I was thinking more ruby...
<whitequark>
ELLIOTTCABLE: job done.
<ELLIOTTCABLE>
I also stand by my original claims about laziness re: iteration
<ELLIOTTCABLE>
lodash does a *lot*, but it's ... a pittance compared to what a blessed implementation could allow
<whitequark>
laziness doesn't really work without purity
<ELLIOTTCABLE>
okay now I seriously need to Student™
<whitequark>
and you know what I think about purit
<whitequark>
y
<ELLIOTTCABLE>
yes exactly.
<whitequark>
see?
<ELLIOTTCABLE>
wait, are you anti-purity-forever?
<whitequark>
forever?
<ELLIOTTCABLE>
because my point is that impure language should include pure *tools*, for the parts of systems that can benefit from purity
<whitequark>
oh, I'm saying that pure languages aren't general-purpose
<ELLIOTTCABLE>
i.e. imagine if JavaScript had a ‘this is a pure function’ feature, and then enabled lazy evaluation of that function ... and lazy iterators got used *inside* that function.
<whitequark>
for almost any definition of general-purpose
<whitequark>
ELLIOTTCABLE: I get the sentiment but that wouldn't work
<alexgordon>
ELLIOTTCABLE: purity is stupid. why do you want purity?
<whitequark>
Rust used to have pure functions
<whitequark>
basically
<ELLIOTTCABLE>
but you can definitely mark off a subset of a program in an impure language, and say ‘this is pure’, and then get lots of the same benefits.
<ELLIOTTCABLE>
whitequark: did I miss that? really?
<whitequark>
you have a fairly arbitrary subset of your language that you can use in pure functions
<whitequark>
and you can use *nothing* from outside of that subset, so every time you aren't quite sure if something will be pure or not, you make it inaccessible
<whitequark>
it's especially painful with generic code
<whitequark>
basically, it just withered and died
<whitequark>
because the restrictions necessary to make using the pure subset possibly useful, made it impossible to actually use it for anything in practice.
<whitequark>
i.e. if you actually enforce the invariants that provide *benefit* from pure functions, you become unable to plug them into places where you want to see them.
<whitequark>
Rust is going to reintroduce pure functions, actually, but as a crutch for initializing compile-time constants
<whitequark>
that isn't really a major part of the language.
<alexgordon>
ELLIOTTCABLE: purity (I assume you mean by this the lack of mutable state) is not a binary on/off but a spectrum of how accessible the state is
<whitequark>
disagree.
<alexgordon>
lol whitequark some day we will agree on something
<alexgordon>
you can have state that is hidden inside a function, or inside a class, or inside a file...
<whitequark>
many statements in languages are only useful if you state them globally
<ELLIOTTCABLE>
alexgordon: hold off on that
<ELLIOTTCABLE>
lemme read hold on omg ugh
<whitequark>
like 'can i execute this lazily?'
<ELLIOTTCABLE>
need to eventually stop talking in here ;_;
<alexgordon>
you can write mutable state _in haskell_. it is ugly as sin
<alexgordon>
but it works
<ELLIOTTCABLE>
10:56 PM <+whitequark> and you can use *nothing* from outside of that subset, so every time you aren't quite sure if something will be pure or not, you make it inaccessible
<ELLIOTTCABLE>
10:56 PM <+whitequark> it's especially painful with generic code
<ELLIOTTCABLE>
v. confused, rephras
<whitequark>
alexgordon: you can't HIDE mutable state in haskell
<whitequark>
(not without unsafe code which will just break everything)
<alexgordon>
whitequark: it is hidden behind all the line noise :P
<whitequark>
lol
<ELLIOTTCABLE>
NOPE
<ELLIOTTCABLE>
IT IS 11PM AND I HAVE NOT BUILD MY CLASS PLAN YET
<whitequark>
ELLIOTTCABLE: so like, in Rust, if you write a generic type, say, Foo<T>
<ELLIOTTCABLE>
AM V. FUCKED, AM GONE NOW
<ELLIOTTCABLE>
LOVE YOU ALL
<whitequark>
sigh
<alexgordon>
ELLIOTTCABLE: bye
<alexgordon>
whitequark: anyway you can "hide" it so that it does not leak outside the function
<whitequark>
how do you get rid of the ST monad in the signature?
<alexgordon>
I don't mean a function _on_ state
<alexgordon>
but a function that uses state as an implementation detail
<alexgordon>
to elliott that would not be "pure", but it is allowed in haskell
<whitequark>
oh you're saying like, using runST
<alexgordon>
yes
<whitequark>
I see
<alexgordon>
but if you take that a step further, you can have a (OO) class, with instance variables and methods that mutate them, but nonetheless has a "pure" interface
<whitequark>
wait, how so?
<alexgordon>
I do this a lot. I will make a class that just has a run() method, then some private methods that go about mutating the state and run() returns a value
<alexgordon>
so it acts like a function
<whitequark>
oh in that sense
<alexgordon>
but it's really a group of functions, with state
<whitequark>
I wouldn't call it a class then
<whitequark>
since it doesn't export its methods in the interface
<whitequark>
like... it's just a function
<whitequark>
it's a function that uses mutual recursion inside, which makes it contain an object
<whitequark>
but you can't inherit from it, therefore it's not a class
<whitequark>
also lol haskell formatting is broken on haskell's wiki
<whitequark>
that's the dumbest thing I've seen this week
<alexgordon>
whitequark: well you say that but when it reaches 1000s of lines and dozens of ivars you'll be glad you don't have to formalize every transition...
<whitequark>
alexgordon: no, I'm not saying it's not useful, I'm saying it's not a *class*
<alexgordon>
no it's not a glass
<whitequark>
you can totally use objects without classes
<alexgordon>
*class
<alexgordon>
I don't much care for using features as intended :P
<whitequark>
objects are just mutual and sometimes open recursion
<alexgordon>
my point is that mutable state is bad at the point when you can no longer understand everything that's going on
<whitequark>
well, yes?
<alexgordon>
so what you want to do is split it into small pieces
<whitequark>
... let me fix motherfucking solvespace
<alexgordon>
but they don't have to be tiny pieces, like a pure language requires
<alexgordon>
whitequark: you know, if it makes you feel better, everybody thinks I'm a terrible programmer, so you are not alone :P
<whitequark>
wait, was that about solvespace?
<alexgordon>
no
<whitequark>
ah
<alexgordon>
> that's the dumbest thing I've seen this week
<whitequark>
er
<whitequark>
that was about the Haskell wiki
<whitequark>
not anything you said
<alexgordon>
oh ok
<whitequark>
I mean
<whitequark>
it's a wiki for your motherfucking language
<whitequark>
it's a decade old
<whitequark>
and you CANNOT HIGHLIGHT SYNTAX?!
<whitequark>
like just how little fucks do you give about your docs
<whitequark>
few. few fucks.
<alexgordon>
this is a really cool program
<whitequark>
it is.
<alexgordon>
I have used autocad, which is really terrible (but better than the other ones I tried)
<whitequark>
like, you need to understand what place i was coming from
<whitequark>
freecad
<whitequark>
right?
<whitequark>
it crashes.
<whitequark>
it sometimes crashes when you try to undo.
<whitequark>
also, when you try to save.
<whitequark>
sometimes it just corrupts your files and crashes when you open them.
<alexgordon>
yes and you can't import autocad files, because literally stallman
<whitequark>
sometimes undo doesn't work, and sometimes it undoes something else
<whitequark>
ehhh, opencascade is at as much fault
<whitequark>
anyway that isn't even the worst
<whitequark>
once, freecad had an assembly module. it was ridiculously broken
<whitequark>
now freecad has TWO broken assembly modules, one of which reimplements half of freecad's geometric core in fucking Python
<whitequark>
poorly
<whitequark>
solvespace has WORKING UNDO
<whitequark>
it LITERALLY NEVER CRASHED on me
<whitequark>
it can SAVE FILES
<whitequark>
and LOAD THEM AFTERWARDS
<whitequark>
i have... very low standards after freecad
<alexgordon>
this is like cocoa autolayout in a cad
<alexgordon>
I never knew I wanted this!
<whitequark>
oh yeah
<whitequark>
I found cocoa autolayout nearly unusable though
<whitequark>
like... I like the idea, I just can't do anything useful with it
<whitequark>
but yes, same idea of parametricity
<whitequark>
alexgordon: it has tons of hidden little gems in it
<whitequark>
try constraining the length of a line segment while selecting a vector
<whitequark>
try constraining the length of a line segment while locked into workplane to another line segment outside of the workplane
<alexgordon>
whitequark: all I am missing really is a keyboard ui
<whitequark>
alexgordon: can you be more specific? I have some vague plans for that
<alexgordon>
nothing complicated, but just being able to insert line segments by length
<whitequark>
mhm
<whitequark>
anything else
<whitequark>
?
<whitequark>
the problem is we've run out of keybindings
<alexgordon>
nope :P
<whitequark>
I have no idea how to do that without going full-emacs
<alexgordon>
well all I need is a little text field
<alexgordon>
north 10cm
<alexgordon>
or whatever
<whitequark>
like... Ctrl-d s
<whitequark>
would work
<whitequark>
that would be fairly idiomatic for linux
<whitequark>
is it idiomatic for os x?
<whitequark>
chords?
<alexgordon>
haha noooooo
<alexgordon>
but OS X has more modifiers
<alexgordon>
cmd, alt, ctrl, shift
<whitequark>
can't use alt
<whitequark>
because of the menu things
<whitequark>
er
<whitequark>
menu shortcuts?
<whitequark>
basically, on windows you don't get to intercept alt+<key> if this is also a valid menu shortcut
<whitequark>
so we can't use those anywhere.
<whitequark>
and of course on windows, you can't really use super.
<alexgordon>
shift-space?
<whitequark>
huh?
<alexgordon>
what does Regenerate All do?
<whitequark>
oh
<whitequark>
it, well, regenerates all groups
<whitequark>
I'm not sure when is it useful.
<whitequark>
ahhhh yes I know.
<whitequark>
because chord tolerance depends on the zoom level.
<whitequark>
lemme show
<whitequark>
wait, SHFIT+space?
<alexgordon>
no no
<alexgordon>
I was thinking space would be good to show the command line
<alexgordon>
but that is already for Regenerate All
<whitequark>
ohhh
<whitequark>
oh yeah, sure
<alexgordon>
so I was wondering what Regenerate All did to warrant such an important shortcut :P
<whitequark>
space or enter
<whitequark>
regenerate all...
<whitequark>
enable display of triangle mesh
<whitequark>
extrude a cylinder
<whitequark>
zoom in, look, regenerate all, look again
<whitequark>
it's not only completely unimportant, but also chord tolerance must not depend on the zoom level anyway
<whitequark>
because it affects the way booleans work
<alexgordon>
is there a way to adjust the grid settings?
<whitequark>
configuration
<alexgordon>
oh yeah now I see
<whitequark>
anyway there will be a SWIG interface to the geometric core
<whitequark>
so you could use like... python
<alexgordon>
yeah that would be useful
<whitequark>
it requires absolutely massive changes though
<whitequark>
due to how code is structured now
<alexgordon>
hm
<alexgordon>
whitequark: I can't get Measure Area to work
<alexgordon>
even with a rectangle
<whitequark>
hm, works for me?
<whitequark>
what is the error?
<alexgordon>
how do you use it?
<alexgordon>
I must be doing it wrong
<whitequark>
draw a closed polygon
<alexgordon>
oh now it works. hm, must have fucked something up
<alexgordon>
whitequark: It was telling me that it was open, self-intersecting or co-planar
<whitequark>
because it was!
<whitequark>
not co-planar.
<whitequark>
or something else.
<whitequark>
show me the savefile?
<alexgordon>
didn't save. I can't reproduce it anyway, must have been user error
<alexgordon>
oh I get it, it is measuring the area of the whole thing, rather than the selection
<whitequark>
oh yeah
<ELLIOTTCABLE>
alexgordon: lol
<ELLIOTTCABLE>
alexgordon: your ‘intense’ quote comes to mind
<alexgordon>
ELLIOTTCABLE: ?
<alexgordon>
-intense
<ELLIOTTCABLE>
I found a private API endpoint on my *technical* uni's (come on guys) student portal, and mined out a bunch of instructor/course ratings by students
<ELLIOTTCABLE>
and I'm piping all that data into a spreadsheet on possible classes
<alexgordon>
ELLIOTTCABLE: ah that is just normal programmer superpowers
<alexgordon>
I do _so much_ scraping
<whitequark>
hey ec
<alexgordon>
being a programmer means having access to information sources normal people don't ;)
<whitequark>
I'm not sure if this is very generally useful
<whitequark>
what's this for?
<ELLIOTTCABLE>
ugh data-entry is the worst
<ELLIOTTCABLE>
I'm → ← this close to fucking yak-shaving myself a script to scrape and format and spreadsheet-ify this shit.
<alexgordon>
whitequark: rsi relief :P
<alexgordon>
I don't like using the mouse
<whitequark>
alexgordon: no i mean, where do you get the data?
<alexgordon>
??
<whitequark>
well you are presumably modeling something that already exists
<whitequark>
since you aren't taking almost any advantage of parametricity like that
<alexgordon>
whitequark: oh by making a sketch first :P
<whitequark>
when designing a part from scratch you probably want to take advantage of symmetries
<whitequark>
to constrain segments to same length, etc
<whitequark>
and I don't think you can do that with that interface?
<alexgordon>
whitequark: these don't have to be constraints, they don't even have to be exact
<alexgordon>
just a way to insert lines without clicking
<whitequark>
ohh hm
<alexgordon>
but I always sketch everything so I know approximately what I'm doing first. maybe I'm weird
<whitequark>
sketch on paper?
<alexgordon>
anyway, I gotta sleep, it's almost 7am
<alexgordon>
whitequark: yeah
<ELLIOTTCABLE>
alexgordon: have you used Google SketchUp?
<whitequark>
I think you'd be able to define those shortcuts yourself when Python arrives
<ELLIOTTCABLE>
it's super-non-discoverable, but you can infact use nearly the entire interface without clicking
<ELLIOTTCABLE>
at all
<whitequark>
ELLIOTTCABLE: how so?
<ELLIOTTCABLE>
like, you can just keep hitting keys and buttons and typing numbers and hitting return, and construct entire models
<whitequark>
maybe I should clone that
<ELLIOTTCABLE>
whitequark: I ... couldn't even describe it? because I didn't learn from a document or anything, just accidental trial-and-error while working with it profusely?
<whitequark>
no i mean how do you like
<whitequark>
select edges?
<ELLIOTTCABLE>
the single key feature though: if anything is selected, or if the mouse has something ‘picked up’ ... basically, any time you could *possibly* derive any meaning whatsoever for a number,
<ELLIOTTCABLE>
if you *type* a number, it replaces the currently graphically/manually entered value, even if you keep moving the mouse or click other buttons or whatever.
<whitequark>
hrm
<ELLIOTTCABLE>
(so like in any interactive activity you're preforming, the numerical value associated with it is <interactively derived value> until such a time as you start hitting number keys, and then it's overridden with that typed value permanently until you finish the operation.)
<alexgordon>
ELLIOTTCABLE, whitequark: I don't know if you have used autocad, but what I described is approximately how you insert lines in it. it is all very keyboard driven
<ELLIOTTCABLE>
that, plus a few other undocumented hotkeys(?) basically let me spit out entire models without having to worry about the mouse
<whitequark>
I've used librecad, which is supposedly a clone
<whitequark>
I never used any command entry though
<whitequark>
I'm not even sure how to
<ELLIOTTCABLE>
iiiiiiiiiiiiiiiiiiiiffffff I recall correctly, the one big thing I always went to the mouse for, was selecting an axis to snap to for linear operations? or something? :x
<ELLIOTTCABLE>
alexgordon: yeah, that's probably what SketchUp copied then
<ELLIOTTCABLE>
explains why it's undocumented.
<ELLIOTTCABLE>
‘hey, let's support users' existing vim muscle memory’ ≠ ‘hey, lets document ALL OF VIM’
<ELLIOTTCABLE>
hence weird things like ⌃E in OS X, 'cuz emacs muscle memory
<ELLIOTTCABLE>
and yeah the SketchUp stuff is probably AutoCAD muscle-memory support?
<whitequark>
likely
<whitequark>
ELLIOTTCABLE: you've looked at screenshots?
<ELLIOTTCABLE>
saw no screnshots of chrome, just product, though
<ELLIOTTCABLE>
whitequark: sure! I haven't done any 3d/printing stuff in a hot minute, though. I'll probably take a look next time I do.
<ELLIOTTCABLE>
school. )=
<whitequark>
ELLIOTTCABLE: yeah it's ideal for 3d printing
<whitequark>
2.5d milling too
<ELLIOTTCABLE>
2.5d?
<whitequark>
a mill moving its table in 3d cannot reproduce arbitrary 3d shapes
<whitequark>
but only 3d shapes that can be cut by dropping and moving a mill over a surface
<whitequark>
this is called 2.5d
<whitequark>
reproducing (most) 3d shapes requires a mill with at least five degrees of freedom
<ELLIOTTCABLE>
“current North Korean leader Kim Jong-un was seen with an iMac on his desk in a 2013 photo, indicating a possible connection to the redesign.”
<ELLIOTTCABLE>
I, what
<ELLIOTTCABLE>
North Korea is so far outside my ability to fathom
<whitequark>
redesign of what?
<ELLIOTTCABLE>
idk wikipedia page on north korea os
<whitequark>
ah
<ELLIOTTCABLE>
fuck
<whitequark>
what
eligrey has quit [Quit: Leaving]
<whitequark>
ELLIOTTCABLE: I just wrote a memory allocator in 100 lines of C exactly
<whitequark>
and every single non-system identifier in it is four characters long
<ELLIOTTCABLE>
show show show
<ELLIOTTCABLE>
bed bed bed
<whitequark>
sec, let me test it
<ELLIOTTCABLE>
I just wrote a bunch of spreadsheet bullshit that I'm pretty sure netted me precisely nothing.
<whitequark>
mmm.
<ELLIOTTCABLE>
four and 3/4s hours work
<ELLIOTTCABLE>
lol fuck dis
<whitequark>
that's almost as long as i argued with you and alexgo
<whitequark>
rdon
<ELLIOTTCABLE>
yeah
<whitequark>
that
<whitequark>
's a
<ELLIOTTCABLE>
look how much earlier I'd have been in bed ;_;
<whitequark>
lmos
<ELLIOTTCABLE>
no
<whitequark>
t as
<ELLIOTTCABLE>
don't do this
<whitequark>
long
<ELLIOTTCABLE>
stop it
<whitequark>
why?
<ELLIOTTCABLE>
before you go too far
<ELLIOTTCABLE>
you don't understand
<whitequark>
hey.
<ELLIOTTCABLE>
some kinds of jokes, they're,
<ELLIOTTCABLE>
unsafe
<ELLIOTTCABLE>
there are things out there that hear you
<ELLIOTTCABLE>
things other than me, purr, and the loggerbots
<whitequark>
oic.
<ELLIOTTCABLE>
things you really don't want to mess with
<whitequark>
if you see an article talking about how to write c
<ELLIOTTCABLE>
say many thoughts but I am gon
<whitequark>
and it doesn't include any words about undefined behavior
<whitequark>
you can safely ignore it because nothing it says matters
<whitequark>
otherwise, it says some correct things, some FUD, and some obviously incorrect things
<whitequark>
like "There is no performance penalty for getting zero'd memory"
<pikajude>
that article says #import
<audy>
ELLIOTTCABLE did you mention me? My buffer got overloaded
Hrorek has joined #elliottcable
Rurik has quit [Ping timeout: 264 seconds]
eligrey has joined #elliottcable
<ELLIOTTCABLE>
watching Theory of Everything, kinda
irclogger_com has quit [Quit: irclogger_com]
alexgordon has joined #elliottcable
* alexgordon
yawns
<pikajude>
i'm using ghcjs right now
<pikajude>
what a bizarre world
<pikajude>
that we live in
meowrobot has quit [Ping timeout: 276 seconds]
<ELLIOTTCABLE>
what is that
<pikajude>
it compiles Haskell code to Javascript
<pikajude>
i just compiled jude.bio using it
<pikajude>
it produced 650,000 lines of javascript
<pikajude>
impressive stuff
<whitequark>
impressive, adj.: can spew truly astounding amount of garbage in minimal amount of time
<pikajude>
it's actually not garbage, it's just the RTS and the javascript translation of all the libs i depend on
<pikajude>
well, depends on your definition of garbage i guess
<whitequark>
i seriously can't believe the hype around compiling whatever to javascript. i wrote a ruby implementation that translated mri bytecode to javascript, it passed 70% of tests. it's not hard. it's absolutely trivial. any bored halfskill can do it
<pikajude>
it's true
<pikajude>
i don't know what their objective is
<whitequark>
there are valid reasons to do it
<whitequark>
good reasons, bad reasons too, all kinds of reasons
<pikajude>
i guess future computers are only going to understand javascript
<whitequark>
what baffles me is people talking about it like it's some fucking kind of magic
<whitequark>
haha, no. js won't be, by far, the first universal ISA, and it won't be the last one destined to be
<whitequark>
like, even *running* those megabytes of javascript is not *that hard*
<whitequark>
sure, it required a modest amount of academic research and a hundred or two person-years of a well-paid team
<whitequark>
it's not a very large software project, compared to many
<whitequark>
it's not particularly exceptional either; there are many VMs that are comparable, some of them written by a single person even
<pikajude>
ok
meowrobot has joined #elliottcable
<alexgordon>
I think I should start reading learnxinyminutes.com as bedtime reading
<alexgordon>
lol @ "halfskill"
<pikajude>
halfskill la skill
<alexgordon>
someone called me dismissive once, that really stuck
<alexgordon>
but whitequark takes it to a whole new level
<pikajude>
yeah
<pikajude>
i've never seen anybody so dismissive
<alexgordon>
<3 whitequark
<pikajude>
here i was trying to enjoy myself
<alexgordon>
lol yeah pikajude
<whitequark>
alexgordon: i felt no existing word was appropriate. so i invented one.
<alexgordon>
elm looks ok
<alexgordon>
I wouldn't ever want to use it
<alexgordon>
but there are some nice ideas in there
<whitequark>
you can put some form of lisp on top of nearly anything. the question is, why?
<whitequark>
"why not?" is a valid answer, if you're the one writing it, of course
<alexgordon>
macros!
<alexgordon>
macros are the only reason to use lisp
<pikajude>
or excel
<whitequark>
alexgordon: hm well i guess.
<ELLIOTTCABLE>
so that's definitely the longest rant I've ever sent over texts
<ELLIOTTCABLE>
3 ‘sections,’ broken down into 10 ‘points,’ a total of 110 messages and >3,000 words
<ELLIOTTCABLE>
and yes I section my sms rants >,>
<whitequark>
sectioned texts. sexts
<ELLIOTTCABLE>
whitequark: I vaguely suspect that abbreviation may have a different meaning?
<whitequark>
ELLIOTTCABLE: lies
<ELLIOTTCABLE>
2:11 PM <+whitequark> impressive, adj.: can spew truly astounding amount of garbage in minimal amount of time
<alexgordon>
I'm impressive!
<ELLIOTTCABLE>
alexgordon: wat.
<ELLIOTTCABLE>
-dick
<purr>
ELLIOTTCABLE: I'll be a dick in 4 hours, 45 minutes, 45 seconds, 680 milliseconds (198mſ 445µſ); please wait patiently.
<ELLIOTTCABLE>
-start
<ELLIOTTCABLE>
-dick
<purr>
ELLIOTTCABLE: no. fuck you.
<ELLIOTTCABLE>
-what
<purr>
<nuck> gq: So basically you pooped on ELLIOTTCABLE?
<ELLIOTTCABLE>
I mean, only the once ...
<alexgordon>
wh..
<whitequark>
oh god I remember that conversation
<ELLIOTTCABLE>
whitequark: you do? I certainly don't O_O
<whitequark>
ELLIOTTCABLE: i've never seen you so ashamed as then, so i suggest not refreshing memory
<whitequark>
(which is the primary reason i remember it, i think)
<alexgordon>
LOL
<purr>
LOL
<alexgordon>
ELLIOTTCABLE: wait, how does gq know your fetishes?
<alexgordon>
*silence*
<ELLIOTTCABLE>
whitequark: lmao
<ELLIOTTCABLE>
whitequark: Oh, I give zero shits anymore.
<ELLIOTTCABLE>
I *will* say that it's probably not an appropriate topic of conversation in here anymore, but. ¯\_(ツ)_/¯
<ELLIOTTCABLE>
(pun intended :P)
<ELLIOTTCABLE>
in my irccloud ‘archives’, apparently
<ELLIOTTCABLE>
which I just opened for the first time ever,
<ELLIOTTCABLE>
amongst many others: #0xabad1dea, #AUTOMATIOTT, #bbbattle, #bitcoinnotevenonce, #chicago ##chocolatapp
<ELLIOTTCABLE>
ohhmaar: ... reply in here if you get that notif
<ELLIOTTCABLE>
3:10 PM <ELLIOTTCABLE> ohhmaar: you're in Chicago? O_O did I know that?
<whitequark>
ELLIOTTCABLE: did I complain about drivers in chicago already
<ELLIOTTCABLE>
whitequark: no! maybe? idk.
<whitequark>
they are the worst.
<ELLIOTTCABLE>
nah
<ELLIOTTCABLE>
they are the 3rd worst.
<ELLIOTTCABLE>
and only if you define ‘worst’ as ‘most inconsiderate.’
<whitequark>
I regret asking
<ELLIOTTCABLE>
I, personally, define it differently; and thus place it more around 6th. ;)
<ELLIOTTCABLE>
whitequark: have you been to NY? It's literally famous
<whitequark>
nope!
<ELLIOTTCABLE>
and after that, I'd say Wisconsin drivers. like, the entire state. ಠ_ಠ
<whitequark>
lol
<purr>
lol
<ELLIOTTCABLE>
and that's only if we're ranking the U.S.; I'm sure, like, Tel Aviv or something is worse
<ELLIOTTCABLE>
but yeah: I'd assert that ‘inconsiderate’ is not the worst kind of driver. Definitely ‘inattentive’-or-otherwise-unsafe is worse than ‘inconsiderate’: In my experience, the zoomy-fast-apparently-foolish drivers are often in the most control of themselves on the road, and the *most* aware of their surroundings.
<ELLIOTTCABLE>
The real dangers are the ~50-year-olds driving *literally under the speed-limit*, on a highway where everyone around them is doing 20+ over, and on their cell-phones (or god-forbid, texting)
<whitequark>
oddly specific awards. "worst driver on 48 contiguous states"
<whitequark>
right next to wiki's "This transmembrane receptor-specific article is a stub."
<ELLIOTTCABLE>
idk Alaska rly likes Hawaii, we stick together
<ELLIOTTCABLE>
didn't I already tell you about the whole airline thing?
<whitequark>
wait aren't there also like, US overseas territories?
<whitequark>
four of them?
<whitequark>
er... Guam and three others
<ELLIOTTCABLE>
not states! they don't matter irl.
<ELLIOTTCABLE>
also strangely I know literally nothing about those
<ELLIOTTCABLE>
nobody *ever* mentions or talks about them here
<whitequark>
oh huh there are fourteen, and five are inhabited
<ELLIOTTCABLE>
literally the only time you see them are 1. on weird tax/census documents that make you check a box if you're in them, and 2. on Really Big Companies' websites with shipping dropdowns
<whitequark>
american samoa, guam, US virgin islands, puerto rico and northern mariana
<ELLIOTTCABLE>
oh I forgot about mariana
<whitequark>
I haven't even heard about maraiana once
<whitequark>
it's a ... "Commonwealth"?
<ELLIOTTCABLE>
I must have heard about it in school at some point; probably saw that exact list? o-O
<whitequark>
"The Northern Mariana Islands had successfully used its position as a free trade area with the U.S., while at the same time not being subject to the same labor laws."
* ELLIOTTCABLE
eyebrows
<ELLIOTTCABLE>
that's very strange
<whitequark>
not anymore.
<whitequark>
(since 2015)
<ELLIOTTCABLE>
Science and Technology Studies — “This course focuses on the latest work in science and technology studies and the history of technology from ethics in genetic engineering to the social dimensions of computing. Other topics include the intersection of gender and sexuality with new technologies, the role of communications media in "rewiring" our brains
<ELLIOTTCABLE>
and our social connections, and the role of the world wide web in constructing national and global technocracy.”
<ELLIOTTCABLE>
Philosophy of Mind — “An examination of the conception of "mind" as opposed to body implications for psychology, artificial intelligence, and neuroscience.”
<ELLIOTTCABLE>
Engineering Ethics — “A study of the problems of moral and social responsibility for the engineering profession, including such topics as safety, confidentiality and government regulation.”
<ELLIOTTCABLE>
help me choose an elective!
<whitequark>
i would take engineering ethics
<whitequark>
hands down
<ELLIOTTCABLE>
Brain, Mind and Behavior — “The survey includes overviews of cognition, intelligence, neuroscience, aging and development, as well as controversies in experimental design and ethics.”
<ELLIOTTCABLE>
Global Chicago — “Through readings, lectures, and field trips to local neighborhoods, this course will look at the ways that Chicago has become a global city and what that means for local government, businesses, educators, and the non-profit sector. The course explores how Chicago has become a node in the global economy and a gateway to immigrants from
<ELLIOTTCABLE>
all over the world.”
<ELLIOTTCABLE>
Industrial Psychology — “Survey of practical applications of psychology to problems of business and industry: work attitudes and behavior; employee selection; morale; safety; turnover; absenteeism; and training.”
<ELLIOTTCABLE>
Social Inequality — “Evaluates the patterns and dimensions of social, economic, and political inequality in American society and how these compare with other societies, who gets ahead and why, the consequences of social stratification, and the outlooks for the future of inequality in developed countries like the United States.”
<ELLIOTTCABLE>
it's probably going to come down to ‘which one fits in my schedule’, because my calendar is Pretty Packed rn
<whitequark>
__attribute__((packed))
<ELLIOTTCABLE>
already had to juggle some very unpleasant tutors or times because the core classes I need are all conflicting with one another
<ELLIOTTCABLE>
whitequark: lolol
<purr>
lolol
<ELLIOTTCABLE>
I have a class at 8:35AM on Mondays -_-
<ELLIOTTCABLE>
I own dogs, and it's winter in Chicago; have to drive to campus and park; so like, my mondays are going to *suck*.
<ELLIOTTCABLE>
also I'm super-concerned with my appearance so my morning ablutions are probably ~45m-1hr
<whitequark>
the second most important reason for which i dropped out, except for failing diffequations eight times,
<whitequark>
is having to commute for 1.5h every morning during winter in public transport
<ELLIOTTCABLE>
yeah ew no
<whitequark>
i'm pretty sure i'd still have said fuck it, because it was unbearable
<whitequark>
no you don't understand
<ELLIOTTCABLE>
I have a car and my communte is shorter than that,
<whitequark>
there was no aircon in trains
<ELLIOTTCABLE>
but ... dogs fuck it up quite a bit
<ELLIOTTCABLE>
is it *hot* there in the winters? o_O wat
<whitequark>
oh yes, it's extremely hot
<whitequark>
and there are people in winter clothes
<whitequark>
people who do not know that deodorant exists
<ELLIOTTCABLE>
or were you taking summer courses? and, still, isn't all of Russia northerly enough to be compfortably cool
<whitequark>
underground trains.
<ELLIOTTCABLE>
that's so crazy
<ELLIOTTCABLE>
even underground here in Chicago the trains are cold
<ELLIOTTCABLE>
underground *and* heated
<ELLIOTTCABLE>
still cold.
<whitequark>
the trains are deep.
<ELLIOTTCABLE>
that is so weird
<ELLIOTTCABLE>
you have geothermally heated trains by accident? :P
<whitequark>
like, deep enough they aren't affected by seasonal variation in temperature
<whitequark>
the stations were built as nuclear shelters
<whitequark>
in anticipation of a war with US
<whitequark>
moreover, there is a lot of people. during morning you will not be able to breathe properly in a train
<whitequark>
because there are just that many people
<whitequark>
like... no space to expand into.
<whitequark>
i'm pretty sure people die sometimes
<whitequark>
oh that's not all
<whitequark>
the trains, when they slow down, they do not use regenerative braking
<whitequark>
they just dump kinetic energy into giant resistors underneath
<alexgordon>
omg!
<alexgordon>
had an epithany
<alexgordon>
how do you actually spell that word?
<alexgordon>
not like that.
<whitequark>
epiphany
<whitequark>
like the mail client
<alexgordon>
gmail
<alexgordon>
I had a gmail guys!
<whitequark>
alexgordon: wat.
<purr>
beep.
<whitequark>
purr: unwat.
<whitequark>
...no?
<alexgordon>
I have too many thoughts in my head right now. like, they're all _there_ but in a jumble