elliottcable changed the topic of #Paws.Nucleus to: http://Paws.mu — coming soon™ ... or not.
ELLIOTTCABLE is now known as ithmic
ithmic is now known as ELLIOTTCABLE
alexgordon has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
alexgordon has joined #Paws.Nucleus
whitequark has joined #Paws.Nucleus
<ELLIOTTCABLE>
whitequark: There's a fundamental disconnect here, but I don't know how to communicate about it without pissing you off *more*
<whitequark>
then you're probably wrong! *shrug*
<ELLIOTTCABLE>
lol.
<ELLIOTTCABLE>
it's not something mathematical, or provable by numbers. that's my point.
<whitequark>
exactly
<ELLIOTTCABLE>
plenty of other people can build languages backed by all sorts of theory that I don't have knowledge of, or access to.
<ELLIOTTCABLE>
Competing with them, is not my goal!
<whitequark>
well, to be specific, language design isn't an exact field
<whitequark>
and will probably never be
<ELLIOTTCABLE>
my goal is, instead, to create a language that *feels* good.
<whitequark>
by "analysis" I mean, basically, this:
<ELLIOTTCABLE>
(sure, not exact by your standards, compared to purist mathematics backed by proofs … but it's pretty damn exact from where I'm standing, compared to say, web design.)
<ELLIOTTCABLE>
(look at shit like haskell, or coq-backed software, right?)
<ELLIOTTCABLE>
anywaynywaanywayanyway, just, hold on, lemme say my piece?
<ELLIOTTCABLE>
yesnomaybe?
<whitequark>
I think you already said it
<whitequark>
but go on
<whitequark>
I'm not exactly averse to the "language that feels good" school. I mean, Foundry used to borrow from Ruby for exact that reason
<whitequark>
it's just that locking is a shitty idea *in general*, and abusing locking to do anything else makes it *worse*
<ELLIOTTCABLE>
And *that's* an argument I'm open to.
<whitequark>
you should've written C++ code for a few years. multithreading and algorithms with locking.
<ELLIOTTCABLE>
Which is the point of what I'm trying to communicate, here:
<whitequark>
it's INCREDIBLY FUCKING HARD to write a nontrivial algorithm using locking that works in almost all cases
<ELLIOTTCABLE>
It's not that I don't care about *your opinion*. You're smart, and clearly have a lot more experience than me in a lot of fields.
<whitequark>
it's practically impossible to write such an algorithm which handles all obscure edge cases as well
<whitequark>
I mean, go to cve.mitre.org and put "race condition locking" in the search field.
<whitequark>
you'll find a huge number of bugs so incredibly obscure I'm not sure it is humanely possible to find them at all
<whitequark>
(most of them are found by mechanical verifiers like thread_sanitizer.)
<ELLIOTTCABLE>
hold on phone
<whitequark>
every last bit of research I know indicates that humans are astoundingly shitty at designing and implementing locking algorithms, hence the shift to communication patterns (actors, channels) in modern languages
<ELLIOTTCABLE>
sorry back:
<ELLIOTTCABLE>
Just … I want to work with you, I want you to work *with me*, but I just *know* you won't get far, if you come to me with arguments backed in theory, or worse, pedantry
<ELLIOTTCABLE>
I don't *respond well* to that stuff. I don't know *how* to.
<ELLIOTTCABLE>
To me, it's all very abstract, and it just … doesn't make my product, a better product.
<whitequark>
pedantry can't back an argument
<ELLIOTTCABLE>
To me, theory, and proofs, belongs in the area of making a more *performant* language (which Paws is, clearly, not)
<whitequark>
lolwhat
<whitequark>
forget about performance. no one cares about performance today.
<ELLIOTTCABLE>
… to me, the entire argument about whether what I was talking about was ‘locking’ or not, was 100% pedantry
<ELLIOTTCABLE>
probably why I got so pissed off
<ELLIOTTCABLE>
but, anyway:
<ELLIOTTCABLE>
hell, it's taken me *ages* to accept that maybe, just MAYBE, Haskell and other things that try to apply theory (basically, static analysis) to usability, could be *remotely* usable / happy-making.
<ELLIOTTCABLE>
micah's done a lot of work in taking me in that direction.
<ELLIOTTCABLE>
but, anyway, just … this is me, apologizing for being who I am.
<whitequark>
yeah, I'm familiar with that
<ELLIOTTCABLE>
apologizing for *having trouble* taking theory seriously, when it's compared against what is, in my mind, hard answers like “This seems better to use!” or “This feels simpler!” or “This will look easier!”
<ELLIOTTCABLE>
all of those traditionally-soft things are so much more … real to me.
<whitequark>
"This eliminates bugs".
<whitequark>
"This eliminates cases you would need to think about".
<ELLIOTTCABLE>
so. yeah. if you can work with me, do. I want, need, and value (durrr) it.
<whitequark>
after using a language with a decent type system in a while, you begin to see complexity in dynlangs *everywhere*.
<ELLIOTTCABLE>
You'll just end up with a lot less elliott-being-a-stone-wall if you couch your arguments in usability terms, not theoretical / proof terms.
<whitequark>
like, you look at a method invocation. in a s-t lang, there's 1 thing that can happen. in a dynlang, there's an infinite amount of possibilities.
<ELLIOTTCABLE>
That scares me /=
<whitequark>
incidentally, the reason VMs for dynlangs are so fucking complex.
<ELLIOTTCABLE>
actually, really interesting conversation there, that I want to have some time.
<whitequark>
the complexity of a VM reflects inherent complexity of the language, hidden in plain sight.
<ELLIOTTCABLE>
I see a *lot* of that “these are inherently easier” / “these are inherently better” about languages like Haskell, etc.
<whitequark>
it's not that they're easier or better. that's just some icing on top
<whitequark>
see, it's like this:
<ELLIOTTCABLE>
But what I also see, is that if you try to teach a non-programmer something like that first, they have a *harder time*. And to me, that's the immutable rule: the *only thing that really matters*, is that a language that is easier to teach to a seven year old, is a fundamentally better language.
<ELLIOTTCABLE>
Fundamentally more natural, fundamentally more intuitive.
<whitequark>
a good type system allows you to *restrict* what can happen. think of it in terms of, say, your own human senses.
<ELLIOTTCABLE>
I'm terrified of static(?) languages.
<ELLIOTTCABLE>
Because if *all of the people trying so hard, thus far*, with *all of the math behind them that I don't understand*,
<ELLIOTTCABLE>
still haven't made a good one?
<ELLIOTTCABLE>
(‘good’ as in ‘not fucking confusing and unintuitive and a terrible product period’)
<ELLIOTTCABLE>
… then what chance do I have?
<ELLIOTTCABLE>
which probably explains why Paws is so dynamic. Dynamic languages look like a field I can make a dent in, static languages do *not*.
<whitequark>
you, as a human, are capable of remembering every single second of your conscious life, for 80 years. what makes you powerful is the ability to forget about all the junk you don't need.
<ELLIOTTCABLE>
(‘dent’ meaning ‘a better product.’)
<whitequark>
`confusing and unintuitive'
<whitequark>
dynlangs are confusing.
<whitequark>
you can never trust *anything* in a dynlang.
<ELLIOTTCABLE>
to you, because you understand the other kind. To most of us, it's the other way around.
<ELLIOTTCABLE>
/=
<whitequark>
what does the Array#[] do? HAHA I JUST MONKEYPATCHED IT
<whitequark>
it's basically anchoring. whatever you learned earlier seems less confusing.
<ELLIOTTCABLE>
That's just it. Static stuff is more interested in making #[] do the *same thing everywhere*, so it's easier to analyze, easier to test,
<ELLIOTTCABLE>
and that's great, and all,
<whitequark>
no.
<ELLIOTTCABLE>
but dynamic languages are focused on *the more important thing*:
<whitequark>
easier to *understand*.
<ELLIOTTCABLE>
making #[] **do the most sensible thing in context**.
<ELLIOTTCABLE>
Be the most intuitive.
<whitequark>
no.
<ELLIOTTCABLE>
If #[] does the same thing everywhere, it, by definition, can not do the most *intuitive* thing in every place it shows up
<ELLIOTTCABLE>
and thus, equally, must be less intuitive and more confusing to write.
<whitequark>
"intuitiveness" is something that points in opposite direction in me and the guy who sits by my shoulder.
<ELLIOTTCABLE>
I don't believe that. I just, can't. Don't / won't / whatever.
<ELLIOTTCABLE>
Human beings *can* be built for.
<ELLIOTTCABLE>
Designers, all over the world, build products *happily* used by hundreds of thousands of people, every day.
<ELLIOTTCABLE>
Apple products make *nearly every person who touches them*, happy.
<ELLIOTTCABLE>
A programming language **can be** a product like that. Somehow, some way.
<ELLIOTTCABLE>
And I don't believe Linux, or Haskell, are the solution. Are the ideal product.
<ELLIOTTCABLE>
There should be an Apple-y language. Something correct *enough*, more more importantly, beautiful, intuitive, simple, get-out-of-your-way-and-let-you-do-what-you-want-with-it.
<whitequark>
you do realize Linux and XNU don't really differ much?
<whitequark>
besides, you do not understand an important part, that equally applies to PL and physical products.
<ELLIOTTCABLE>
That's the point. It doesn't matter if they do, or don't; because Apple chose whatever they chose, to create an attractive, salable, beautiful product.
<ELLIOTTCABLE>
yeah?
<whitequark>
Apple products don't make everyone happy. Apple products force you to abandon everything that they do not do well.
<whitequark>
it's same with PLs; when you use a PL, you are forced to abandon everything your PL cannot represent well.
<ELLIOTTCABLE>
and I get that.
<ELLIOTTCABLE>
The key word in that message is “nearly.”
<whitequark>
then there's another thing. phones are *simple*. tools are *simple*. go out to your garage.
<ELLIOTTCABLE>
No designer has ever created a product that made *literally everybody* love it.
<whitequark>
take a look at a few power tools.
<whitequark>
they are literally built around *a single button*.
<whitequark>
a PL cannot be compared to a power tool. it's incredibly more complex, and its very task is managing complexity orders of magnitude higher than of its own.
<ELLIOTTCABLE>
you think the complexity-of-interface of a programming language, is greater than that of a smartphone / PDA? |=
<ELLIOTTCABLE>
I think, if it is, then the language is a failure.
<ELLIOTTCABLE>
I think it should be an order of magnitude *less* complex to learn and use than the goddamn center of your entire life.
<whitequark>
what? 'center of your entire life'?
<whitequark>
you're blind or something.
<ELLIOTTCABLE>
a modern phone is inherently more complex than a *desktop computer*, because it manages many more aspects of your life; and everybody knows OSes are already more complex than languages
<ELLIOTTCABLE>
to what?
<whitequark>
'everybody knows' is a shitty argument
<ELLIOTTCABLE>
sorry.
<ELLIOTTCABLE>
“that's what I've heard incessantly.”
<whitequark>
for example, I disagree that OSes are complex
<ELLIOTTCABLE>
in terms of difficult-to-build-a-successful-one,
<ELLIOTTCABLE>
it's always been conveyed as:
<whitequark>
*facepalm*
<ELLIOTTCABLE>
operating system > text editor > programming language > web framework.
<whitequark>
that makes zero sense at all.
<ELLIOTTCABLE>
how so? o_O
<ELLIOTTCABLE>
again seems like completely obvious, basic stuff to me; but, and I don't disagree, you say that's a shitty argument.
<ELLIOTTCABLE>
what, in specific, do you disagree with about it?
<whitequark>
first, "success" is a misnomer. success hinges on pure luck, first and foremost.
<ELLIOTTCABLE>
or, for that matter, is it really relevant? /=
<ELLIOTTCABLE>
DISAGREE.
<ELLIOTTCABLE>
Single MOST IMPORTANT THING. That I could EVER DISAGREE WITH.
<ELLIOTTCABLE>
The better-designed product, will win out in most cases. *ESPECIALLY* in an inherently free market like PLs.
<whitequark>
lol.
<whitequark>
clearly didn't learn your history.
<whitequark>
take a look at, say, Oberon.
<ELLIOTTCABLE>
If you believe Haskell or Linux is a *better product*, and is somehow losing because Apple or Java have luck, or money, then *you're* blind.
<whitequark>
Linux is losing?
<whitequark>
lol
<whitequark>
Linux is the most used kernel in the world, by at least an order of magnitude
<ELLIOTTCABLE>
oh gods, are you a year-of-Linux-on-the-desktop guy?
<ELLIOTTCABLE>
>:
<ELLIOTTCABLE>
goddamnit.
<ELLIOTTCABLE>
okay.
<ELLIOTTCABLE>
Well, I don't believe in that. I don't believe in *any* of that. I'll take, and I deeply believe *most people* will do the same, a better-designed end-product, over one that gives me more freedom, or more options, or more provably-correct buttons and switches and type-checking systems, any day.
<whitequark>
if you mean KDE and GNOME are losing, then yeah, both of them are shit. basically, too much of different extremes making both unusable.
<whitequark>
anyway
<whitequark>
learn your fucking history.
<whitequark>
as I said
<ELLIOTTCABLE>
I *want to believe* something like Haskell, made by somebody with any lick of design or U/X sense, could succeed.
<whitequark>
the most beautiful, best-designed products--be it text editors, kernels, GUI frameworks, whatever--have been created in the past.
<ELLIOTTCABLE>
I don't know who can make that. It's not me.
<whitequark>
in 70s, 80s. then promptly abandoned and forgotten.
<ELLIOTTCABLE>
Some day, some magical savior Jesus-programmer, who knows both the theory *and* gives a literal shit about their users, will come to exist.
<ELLIOTTCABLE>
But that day isn't today. /=
<whitequark>
take a look at fucking Linux, or WinNT, or XNU, or whatever
<whitequark>
Dijkstra's THE multiprogramming system, for which you can't even find the source today, in late 60's, had all of the basic blocks of a kernel composed in the same order.
<whitequark>
I'm honestly doubting that there was *any* progress in OS design since 1970.
<whitequark>
whatsoever.
<whitequark>
OS design probably doesn't interest you, that's fine.
<whitequark>
again, take a look at Oberon. hang on.
<ELLIOTTCABLE>
I don't know how you can believe that. I just, I don't.
<whitequark>
I believe that, because I looked at data and made a conclusion?
* ELLIOTTCABLE
shrugs
<ELLIOTTCABLE>
What data?
<ELLIOTTCABLE>
Where's the hundreds of thousands of happy users of THE?
<whitequark>
exacly
<ELLIOTTCABLE>
No other data matters.
<whitequark>
*exactly.
<ELLIOTTCABLE>
“There were not hundreds of thousands of happy users of THE” therefore “THE is the best possible O.S.”
<whitequark>
then your statement becomes a tautology.
<ELLIOTTCABLE>
Oh, wait, I got that backwards.
<whitequark>
what's a successful X? a successful X.
<whitequark>
in a way, that's how it happens, yes.
<ELLIOTTCABLE>
That would be a tautology if I had used the words *successful*. I didn't.
<ELLIOTTCABLE>
What's a *good* X? A successful X.
<ELLIOTTCABLE>
(with caveats, but very few.)
<ELLIOTTCABLE>
Nor, for that matter, do I really believe that the success is a *direct* measure of the actual quality that should go before X in that sentence.
<ELLIOTTCABLE>
But success is the *best measure we have*.
<whitequark>
yeah, there's another implication. that success depends on the quality of X in any significant way.
<ELLIOTTCABLE>
Because there *is* no true measurement of usability, of quality, of happiness-making.
<whitequark>
OS X is not successful. Windows is.
<ELLIOTTCABLE>
All you can do, the closest you can get to measuring the quality of anything in the real world, is usability testing, and then looking at the later success thereof.
<whitequark>
Java and C++ are successful. <everything else> isn't really.
<ELLIOTTCABLE>
I walk around, in the real world, and here *everyday people* talking about Ruby.
<ELLIOTTCABLE>
*Everyday people* covet, and use, Macs, and iPhones.
<whitequark>
you live in a bubble. there are orders of magnitude more people using C++ than Ruby.
<whitequark>
70% of smartphone market is Android.
<ELLIOTTCABLE>
Market awareness and penetration are more important than units-sold, if we're using these measures of ‘success’ as an indirect measurement of the immeasurable ‘quality’ of a product.
<whitequark>
ok. then give me real data on market awareness and penetration. not data from your personal bubble where you have filtered everything that doesn't suit your preferred worldview.
<ELLIOTTCABLE>
and now this has turned into an Android vs iOS argument. ಠ_ಠ
* ELLIOTTCABLE
sighs
<ELLIOTTCABLE>
okay. Fine, I suppose.
<ELLIOTTCABLE>
back to code with me /=
<whitequark>
you've essentially convinced yourself that whatever you wanted to believe is true.
<whitequark>
not exactly rare
<ELLIOTTCABLE>
I'd say the opposite is true.
<whitequark>
but not useful either.
<whitequark>
and, seriously,
<whitequark>
dedicate a *month* to learning from the programming languages of the past, if you ever want to design a good one.
<whitequark>
don't focus just on the peculiarities. learn why they happened that way, what influenced their design.
<whitequark>
read whatever their authors wrote.
<whitequark>
I'm surprised I have to *explain* this, honestly. I'm lost as to how you aim to build something great while remaining utterly ignorant to mistakes of the past.
<ELLIOTTCABLE>
I've never *heard* of half of these things (You keep mentioning Oberon; there's not even any results related to programming on the *first page* of Google results for that.)
<ELLIOTTCABLE>
how am I supposed to know that learning them are barriers-to-entry to designing a programming language, when I've never heard of them, eh?
<ELLIOTTCABLE>
not sure how you can fault me for that.
<whitequark>
if you've ever bothered to take a look at, say, timeline of programming language development, you'd know about it. *shrug*
<whitequark>
99% of what you think are great ideas was tried in past and dismissed as worthless. it's basically the precise reason of why I killed Foundry.
<whitequark>
I worked two years, one of them nonstop, just to figure out at the end that yes, the idea was tried, and yes, exactly as I see it now, it was deemed as shitty and dismissed.
<ELLIOTTCABLE>
and of *course* those people in the past knew everything.
* ELLIOTTCABLE
shrugs
<whitequark>
no, no individual was particularly knowledgeable.
<ELLIOTTCABLE>
I'm surprised how much I don't know. And believe me, I take the point of learning from past mistakes to heart.
<whitequark>
it's the combined sum of knowledge you can freely access right now which is important.
<ELLIOTTCABLE>
But I also disagree with killing the entire project just because somebody else tried it first, and didn't find a solution that makes it work.
<whitequark>
who said I didn't try to fix it?
<ELLIOTTCABLE>
In which case, you didn't kill it because of the past, you killed it (sensibly) because of the present.
<ELLIOTTCABLE>
Still seems the past unfortunately biased your decision. Knowing all that history of whatever-the-concept-is, it's easy to believe you were subconsciously convinced that there *was* no solution.
<whitequark>
no. there's several things.
<ELLIOTTCABLE>
anyway, I hope your next project finds you more successful.
<ELLIOTTCABLE>
what're you *going to* next, anyway? Other than playing with CNC stuff? Any big plans? /=
<whitequark>
first, knowing the history of *one* language, ML, would've cut me literally a year of trying to learn things blind.
<whitequark>
*two weeks* with a guy who implemented ML were more productive than all of the previous year, combined.
<whitequark>
(implemented a dialect as an exercise in school.)
<ELLIOTTCABLE>
unrelated: parsing bug with boldening on your irclog
<whitequark>
second, knowing that this particular thing was tried in the past and dismissed as a dead end (which it definitely was, in my experience), would've saved me almost entire another year and I would probably be still trying to build something interested rather abandoning the whole topic, largely.
<ELLIOTTCABLE>
All of this keeps coming back to one thing, for me.
<whitequark>
it's just... inefficient. you spend months trying and trying every possible combination, when it is likely that you could have the same result in an hour.
<ELLIOTTCABLE>
You're a logical person, you don't invest in lotteries or similar, I'm sure. That's one addiction that tends to pass the logical people over.
<ELLIOTTCABLE>
And yet, you *truly believe* that all those products which are successful; Rails and Ruby, JavaScript, Node,
<ELLIOTTCABLE>
those are luck-of-the-draw?
<whitequark>
not quite.
<ELLIOTTCABLE>
You don't think anything, of any quality, will see success because of its quality … or, alternatively, you don't see that / believe that, any of those popular things *might actually be* of a greater quality than the unpopular or obscure things you idealize?
<whitequark>
let's say there is a lower barrier for a certain product at a certain time. if it's worse than that, it won't succeed.
<ELLIOTTCABLE>
so, that comes back to one question for me:
<whitequark>
above that, it's mainly luck.
<ELLIOTTCABLE>
Why code?
<ELLIOTTCABLE>
Why create?
<whitequark>
have you ever looked at, say, science at large?
<whitequark>
it's enormously luck-based.
<ELLIOTTCABLE>
Whatever you create, of whatever quality, *doesn't fucking matter*. You could set monkeys at keyboards, and they'd have almost as good a chance as you of creating something valuable, or successful, that changes people's lives.
<ELLIOTTCABLE>
At that point, you're literally spending all of your life, all of the hours you spend writing code,
<ELLIOTTCABLE>
creating lottery tickets to drop into a box.
<ELLIOTTCABLE>
No point. Illogical. Waste of effort and time. Go paint instead.
<whitequark>
yep, that's a pretty good description of it.
<ELLIOTTCABLE>
Well, I fundamentally disagree, and always will.
<ELLIOTTCABLE>
If I create a product better than Haskell, as good as Ruby; it doesn't *matter* how incorrect, or slow, or <insert other host of errors people like to go on about> it is. It can be made a success.
<ELLIOTTCABLE>
It will take marketing, and personality, and possibly money; and most importantly, effort.
<whitequark>
that sentence simply doesn't make any sense.
<ELLIOTTCABLE>
But such a product *can be made*; it *does not need to be statically typed or provably correct or anything else magical*. It just needs to be good.
<whitequark>
at all.
<ELLIOTTCABLE>
which one?
<whitequark>
"better than Haskell"
<ELLIOTTCABLE>
My point is really simple.
<ELLIOTTCABLE>
A) correctness is not quality,
<whitequark>
"better" implies there's some kind of goal you're working towards.
<ELLIOTTCABLE>
and B) quality *does matter*.
<whitequark>
there is no single goal people use programming languages for.
<ELLIOTTCABLE>
If you create a quality product (which does not require correctness), then it will capable of changing lives
<ELLIOTTCABLE>
oh, there certainly is.
<ELLIOTTCABLE>
Ruby is better than Haskell.
<ELLIOTTCABLE>
It makes more people, happier.
<ELLIOTTCABLE>
It changes, improves, more lives.
<ELLIOTTCABLE>
Haskell is more correct, more accurately designed, more proved … but most of the people who try it, or see it, seem to dislike it. It makes them unhappy.
<whitequark>
you're dumb. you're dumb in that you can't see through your preconceived beliefs.
<ELLIOTTCABLE>
There is a *smaller set of people* made happy by Haskell, than by Ruby.
<ELLIOTTCABLE>
All I want out of life, is to create another Ruby, to make more people happy like Ruby made *me* happy.
<ELLIOTTCABLE>
If I can do that (and I very much intend to do that), then I will have succeeded by my standards, by my desires.
<whitequark>
you don't even *know* Haskell, your sampling of people for their language of preference is fundamentally flawed because of selection bias, and yet you go and postulate that "Ruby is better than Haskell" like some kind of philosophical absolute.
<ELLIOTTCABLE>
I understand selection bias. I'm not as dumb as you think I am; I've *accounted* for that, by all that I can see.
<ELLIOTTCABLE>
There's still a *small subset* of the programming population that can handle/stand/desire Haskell.
<ELLIOTTCABLE>
There's still a *small subset* of the computer-poweruser-population that can handle/stand/desire Linux.
<whitequark>
what?
<ELLIOTTCABLE>
From where I'm standing, it's *you* that's working off of some philosophical absolute:
<whitequark>
I probably should write it on a nail and drive it into your head:
<ELLIOTTCABLE>
that something like Linux or Haskell is ‘better’ simply because it's more correct.
<whitequark>
Linux is the most successful OS on the planet.
<whitequark>
what the fuck are you blabbering about?
<ELLIOTTCABLE>
That somehow, someday, Linux will win out, simply because it's more open. It hasn't, and won't.
<whitequark>
where exactly did I argue about "more correct" ?
<ELLIOTTCABLE>
Linux is the most successful **headless** operating system.
<ELLIOTTCABLE>
And that doesn't matter.
<ELLIOTTCABLE>
That's like saying it's the most successful operating system on rocket ships.
<ELLIOTTCABLE>
Yeah, cool, it is a useful tool that powers an industry. It didn't **make people happier**.
<whitequark>
it absolutely did.
<whitequark>
people *love* their GPS receivers.
<ELLIOTTCABLE>
indirectly, of course.
<whitequark>
if something doesn't directly shove its interface into my face, that doesn't mean it doesn't make me happier.
<ELLIOTTCABLE>
It's the companies that launched those satellites, and the companies making the pretty GPS receivers, that made people happier.
<whitequark>
anyway.
<ELLIOTTCABLE>
There's a relatively tiny subset of relatively insane people with too much time on their hand to debug issues and mess with settings (we'll call them “neckbeards.”), who are actually made happy by Linux *as a product*.
<whitequark>
the point is, I never ever ever argued about "correctness"
<ELLIOTTCABLE>
Linux is a failure, *as a product*.
<ELLIOTTCABLE>
sorry.
<ELLIOTTCABLE>
that's my own fault, because I don't know the terminology.
<ELLIOTTCABLE>
in the above, replace my uses of ‘correctness’ with
<ELLIOTTCABLE>
<whatever qualities make Haskell arguably better than Ruby, despite the fact that less people are made happy by it.>
<whitequark>
again, Linux is not a product, neither it is an OS, neither it is an OS with a GUI or something.
<ELLIOTTCABLE>
or <whatever qualities make THE the ideal operating system, despite the fact it was unsuccessful.>
<whitequark>
who said "ideal" ?
<ELLIOTTCABLE>
i.e. ‘correctness’ being herein defined as ‘the combination of provableness, accuracy, bug-freeness, performance … etcetcetc.’
<ELLIOTTCABLE>
pedantry.
<whitequark>
you just constructed some strawman of myself and are arguing with it.
<ELLIOTTCABLE>
to 99.999% percent of the population, ‘Linux’ is an OS.
<whitequark>
99.999% of population isn't aware of what 'Linux' is.
<ELLIOTTCABLE>
okay. Then, clearly, arguing with that strawman is a waste of time. /=
<whitequark>
they isn't aware of what 'ObjC' is.
<whitequark>
exactly
<ELLIOTTCABLE>
yes, but a solid 1% is aware what Ruby is.
<ELLIOTTCABLE>
and Java.
<ELLIOTTCABLE>
not Haskell, no, but Ruby, or JavaScript? Even if they don't know what they are? ‘Coders do that.’
<whitequark>
anyway
<whitequark>
how do I put it?
<ELLIOTTCABLE>
because their ‘coder’ friends were made happy enough by those products, to talk about them outside of work.
<whitequark>
fuck off, you are annoying, dumb, and close-minded. I'm not interested in making your language, because I don't believe you will succeed while being a zealot.
<whitequark>
/thread
whitequark has left #Paws.Nucleus [#Paws.Nucleus]
<ELLIOTTCABLE>
I just want to make beautiful things that make somebody happy when that person sees, or uses, that thing.
<ELLIOTTCABLE>
Is it goddamned too much to ask that I meet, or find, *one goddamn person* to talk to, who A) understands what I do, and B) has even *remotely* similar worldview / goals to myself?
<ELLIOTTCABLE>
Everybody who agrees with me, doesn't understand what I do. “Oh, you write the code? That's cool, I wish I understood that stuff!” <giggle giggle>
<ELLIOTTCABLE>
Everybody who understands what I do, disagrees with me. “You can't write something beautiful! It has to follow <these> <strict> <rules> or else it's incorrect and thus doesn't matter!”
<ELLIOTTCABLE>
(worst of all? the former group doesn't even understand that there's *subsets* of people who write code, and I don't even do even remotely what they *think* I do … while the latter group, EACH SUBGROUP HAS A DIFFERENT SET OF THEIR OWN LITTLE PEDANTIC RULES. And they all disagree with each other, and basically *none* of them care about making a good
<ELLIOTTCABLE>
product.)
<ELLIOTTCABLE>
I should just go study to be a manager.
<ELLIOTTCABLE>
I can speak programmey-words at the programmers until they make the *actually good thing* that the designers designed,
<ELLIOTTCABLE>
and I can speak product-making words at the designers to explain what the illiterate programmers are saying about what's impossible.