<elliottcable>
Nuck ⑊ wanna split the winnings? :)
<elliottcable>
Against all the odds, I just got a Google Authenticator code of 123456
<elliottcable>
O_O
<Nuck>
That's crazy
<elliottcable>
Hm. Time to buy unreasonably large quantities of bitcoins.
<elliottcable>
sub-$100 prices? yesplz.
<Nuck>
Not buying yet.
<elliottcable>
God, Blockchain is just such an excellent piece of software.
<Nuck>
I think it can still go lower. The descent has barely slowed down (at least compared with the hourly patterns from the previous day)
<Nuck>
I think if you buy know you'll lose
<elliottcable>
I think it *probably* can, and will, go lower.
<elliottcable>
I'm not sure you understand the basics of trading ...
<Nuck>
Oh no, I understand
<elliottcable>
I'm calculating risk based on previous experience. I'm taking a safer bet, with a larger amount of money, for the same return.
<Nuck>
But I do't think this is a guy price right now
<elliottcable>
Less risk, more return, but requires more capital.
<elliottcable>
Make sense?
<elliottcable>
I'm convinced it'll break 100$ in the upward direction, again.
<Nuck>
I'm waiting to see it level out in midday trading
<Nuck>
THEN I'll believe it's bottomed out, and then buy in, for long-haul
<elliottcable>
Thus, investing now, instead of risking it turning around on me, means I *could* lose some return: let's say it drops down to 50$ or lower.
<Nuck>
Then sell next spike or whenever it increases
* elliottcable
waits for transfer
<elliottcable>
Ugh, this is terribly slow
<elliottcable>
Everything has such low limits.
<elliottcable>
Or at least, everything *quick* does.
<Nuck>
One guy managed to cash out $18 mil in BTC before the crash supposedly
* elliottcable
laughs
<elliottcable>
60k bitcoins? I believe it.
<Nuck>
Well it was 10k at the time or something
<Nuck>
That's what the article said, I didn't check their math honestly
<Nuck>
Or was it 20k?
<Nuck>
It was 10 or 20k
<elliottcable>
limit 2000 a day
<elliottcable>
so I'd need to make four pay-orders and take 2k in cash to Walmart at four AM
<elliottcable>
sounds like an *excellent* idea. ಠ_ಠ
<elliottcable>
I fucking hate how complex it is to buy bitcoin.
<whitequark>
a city where I've a talk at a conference
<elliottcable>
Oh, yes, I forgot.
<whitequark>
elliottcable: actually. it's not about influence. I just have no idea if I can apply the ideas anywhere else except at #elliottcable... and if the owner of the channel disagrees [that it is useful], it's not worth the time spent. sure, exploring ideas is fun, but it's 10% exploring ideas and 90% fucking with the LL(k) machine to make it work, and boring JSON crap, and whatever.
<elliottcable>
mmmm yah, I get that
<whitequark>
I'm not fond of the "let's make a half-done thingy and leave it so" paradigm, which is so loved by academics (did we talk about starkiller here?). I like how authors of VMKit treat their work. to quote them:
<elliottcable>
starkiller?
<whitequark>
"sure, writing a cool VM is neat, but if it cannot compete with HotSpot and CLR, then it's not worth writing, and publishing for other people to experiment with."
<whitequark>
(a neat-y python-to-C++ compiler which could be at least somewhat useful if the author did not abandon it after writing his thesis)
<Nuck>
Read that as "meaty"
<Nuck>
Started salivating at the thought of eating your compiler.
<elliottcable>
... edible programming
<elliottcable>
NEW IDEA GUYS
<Nuck>
burger-to-hotdog transpilers
<elliottcable>
somebody get me a frosting-3D-printer
<Nuck>
Let's make 'em
<Nuck>
YESSSS
<Nuck>
THIS NEEDS TO EXIST
<elliottcable>
we need a frosting substrate which is conductive
<Nuck>
elliottcable: Set up a kickstarter for this
<elliottcable>
huge meringue FPGAs?
<Nuck>
frosting 3D printers
<elliottcable>
that already exists
<Nuck>
IT DOES?
<elliottcable>
that's how one of the big-name ones started, IIRC
<Nuck>
ZASFJASFASFA OMG
* Nuck
drools
<elliottcable>
I forget which one, MakerBot or something, originally in version 1.0a, only printed frosting. or something.
<elliottcable>
marshmallow circuits.
<Nuck>
elliottcable: This sounds fucking tasty.
<Nuck>
Let's program it.
<Nuck>
We'll run the Cinnamon DE on it just for good measure in deliciousness
<whitequark>
hrm
<whitequark>
so
<whitequark>
elliottcable: if it *is* cool (if it isn't I'll be the first one to throw it in a garbage van), r u going to replace purr with it?
<Nuck>
purr is eboy's old shit code
<Nuck>
We have no feelings for it
<elliottcable>
that's a question I can't answer the way you expect me to.
<elliottcable>
purr is *terrible*.
<Nuck>
As long as she stays kawaii
<elliottcable>
As long as it's relatively clean Ruby code, not something too ugly and hate-ful,
<elliottcable>
so that I can add my random hacks and inside jokes to it,
<elliottcable>
then I'll replace the old bot in a heartbeat.
<Nuck>
And I'll hack on it too
<Nuck>
I'd like to request open API of the wats too
<elliottcable>
caveat: “heartbeat” could be as long as several months, because that sounds like a boring, effort-intensive task
<elliottcable>
so far more likely, we'll just have both, and move functions over whenever we get bored or need to modify them.
<Nuck>
I'll happily port things
<whitequark>
... well, I guess it's resolved then.
<elliottcable>
also, I'll run it on my server
<elliottcable>
whitequark ⑊ drop me your pubkey so I can make you an account
<Nuck>
Anything to get rid of fucking eboy's shit code
<whitequark>
elliottcable: on github
<elliottcable>
nah, I'm not going to bother installing it and shit
<whitequark>
installing what? lemme show you a trick
<elliottcable>
I'll just give you an account, access to /srv/irc, and a shared tmux socket you can keep a vim and instance open in
<whitequark>
elliottcable: ... I use screen, nano and mcedit
<whitequark>
do you hate me yet?
<whitequark>
:p
<whitequark>
grrrr, cool trick doesn't want to find itself
<elliottcable>
mceedit?
<elliottcable>
and you code in nano? poor thing.
<Nuck>
>nano
<Nuck>
>screen
<elliottcable>
but don't care what you use for editing
<Nuck>
brb killing self
<whitequark>
elliottcable: normally, in sublimetext2
<whitequark>
but on servers, nano, yeah.
<elliottcable>
tmux isn't arguable though, because it's how we share editing instances ;)
<elliottcable>
you on Mac or Linux?
<whitequark>
lin
<Nuck>
Set up a deployment system using capistrano?
<whitequark>
said that (about screen/nano) not to impose my workflow on you, just for lulz
<Nuck>
(it's quite fun to set up actually, when it doesn't involve tearing your hair out)
<Nuck>
nano makes me suicidal
<whitequark>
github has some neat way to get a list of user's pubkeys. like github.com/whitequark.pub
<elliottcable>
I'll go through the drudgery to make a shared tmux instance in there, later on
<elliottcable>
Ruby should be up-to-date, etceteras
<elliottcable>
use rvm plz
<whitequark>
elliottcable: I'm developing it, at least for a while, on my notebook, anyway
<Nuck>
2.0.0p0
<elliottcable>
don't install gems on the system if you can avoid it
<elliottcable>
yah, that's fine
<elliottcable>
just sayin' it's there
<whitequark>
not always on internets, etc
<whitequark>
I'm using bundler
<elliottcable>
I heard bundler is crap
<elliottcable>
but that
<whitequark>
rvm is shit but ok if you are managing it and not me
<elliottcable>
is after my time.
<whitequark>
bundler is awesome. you know how software is distributed on os x so you don't get version conflicts? bundler does exactly that
<Nuck>
Personally I still rank rvm, bundler, and rubygems below nvm and npm
<whitequark>
gives your app a predictable environment to run in
<Nuck>
I hate most of Node looking back
<whitequark>
Nuck: funny, considering how nvm/npm are modelled after rvm and *gems
<Nuck>
whitequark: To an extent
<whitequark>
and most of node stuff, generally
<whitequark>
expressjs, etc
<Nuck>
They were modelled after Ruby, but they improved upon the failings of each
<Nuck>
The whole "learn from your predecessor's mistakes" thing
<whitequark>
it's a sad thing that rubygems couldnt be signficantly improved
<whitequark>
I talked to drbrain
<whitequark>
backwards compat is a bitch
<Nuck>
See, I wish programmers would care less about backwards compat
<whitequark>
Nuck: fuck you royally
<whitequark>
fuck you a thousand times.
<Nuck>
There's better ways to do it
<Nuck>
whitequark: Don't get me wrong, I support it
<Nuck>
But not in any way which holds back the future
<whitequark>
i.e. you don't.
<Nuck>
I'm sorry but the future is more important than the past, and old versions shoulds tick with their old versions (with support)
<whitequark>
backwards compat is when your hardware from 2013 emulates your hardware and software from 1965. that's compatibility.
<Nuck>
And that's fucking dumb
<whitequark>
if you need to reinvent everything every 1.5 years that means that you suck at design.
<Nuck>
99% of users won't need it
<whitequark>
nothing more
<whitequark>
how much times was TCP/IP redesigned?
<Nuck>
If it's holding you back, FUCK IT ALL
<whitequark>
TCP? 0. IP? 1.
<Nuck>
whitequark: Well, right now they're working on some upgrades to TCP IIRC
<Nuck>
At Google's behest
<whitequark>
that's because people thought *BEFORE* writing fucking code
<elliottcable>
oooo interesting argument
<elliottcable>
I think I'll weigh in:
<Nuck>
But what I'm saying is that most software can be shimmed into new environments in a way which does not involve that environment being aware of it
<whitequark>
Nuck: to HTTP, I think? SPDY. and that's completely compatible with legacy stuff.
<Nuck>
whitequark: Not just that
<whitequark>
with TCP, even more so
<whitequark>
we had some incremental improvements like better congestion control, which did not involve breaking anything at all!
<Nuck>
HTTP to SPDY, yes. But no it's not "quite" compatible
<whitequark>
Nuck: backwards-compatible, yeah? it's an opt-in upgrade upon agreement of both parties
<Nuck>
But what I'm saying is that sometimes you have to ignore the 1% of old applications to help the 99% of modern stuff. And in that case, fuck the old shit
<Nuck>
And that's how it should be, whitequark
<Nuck>
opt-in from both parties
<Nuck>
Support the old system until it dies out completely
<Nuck>
That's fine
<Nuck>
BUT
<elliottcable>
I'm with Nuck on that, by the way
<elliottcable>
maybe not the rest, but specifically that, definitely.
<Nuck>
There are ways to version in systems such that you can just completely scrap 99% of the old stuff
<elliottcable>
Supporting legacy systems and the wisdom thereof aside ...
<elliottcable>
not to mention design-quality considerations ...
<whitequark>
Nuck: that is called "thinking before designing", yeah.
<Nuck>
I am in favor of not breaking things (that'd be stupid to be against that)
<elliottcable>
the *best* way to do so, is supporting both at once, but seperately.
<Nuck>
whitequark: Sometimes that doesn't help at all
<whitequark>
not just "let's bang code until it kinda works"
<whitequark>
Nuck: again: that means you suck at design. srsly.
<Nuck>
whitequark: The problem is, times change
<Nuck>
Requirements change
<Nuck>
We CANNOT PREDICT THOSE
<Nuck>
Quite simply
<whitequark>
should I remind you of TCP/IP?
<whitequark>
it was invented when networks were SIX ORDERS OF MAGNITUDE SLOWER
<whitequark>
at least
<whitequark>
maybe it's eight already
* Nuck
points to the constant revision of HTTP, adding things like WebSockets which BROKE COMPATIBILITY WITH OLD ROUTERS
<Nuck>
Funny how that works
<Nuck>
We needed a thing nobody had expected (realtime in the browser)
<whitequark>
ah. the web. the web was done by amateurs.
<elliottcable>
wow.
<elliottcable>
calm the butts down.
<Nuck>
Not even the best designs will last forever.
<Nuck>
If you think that you're horribly wrong.
<Nuck>
Just flat out, 100%, unbelievably WRONG
<whitequark>
heh
<whitequark>
the best definitely won't
<whitequark>
the worst, just as definitely, will
<whitequark>
I'm completely sure we will still have to deal with COBOL in 2100.
* elliottcable
nods at Wave
<whitequark>
I wish I could live long enough to look at your face.
<Nuck>
Eventually the best technologies will die
<Nuck>
It's just a matter of *when*
<Nuck>
Better will last longer, yes
<whitequark>
eventually the universe dies. *shrug*
<purr>
¯\(º_o)/¯
<Nuck>
But everything, without exception, will eventually be broken
<Nuck>
And this is why we shouldn't worry so much about backwards compatibility to systems we deem poor
<whitequark>
Nuck: eventually I'm going to die. therefore, I'm not going to do $X.
<Nuck>
If the system is broken, we fix it.
<whitequark>
this is a fallacy.
<Nuck>
whitequark: No, what I'm saying is that everything dies eventually so we should not fear death.
<Nuck>
Face death with a proud face
<whitequark>
worrying about compat is not related, at all, to the subjective quality of the software
<Nuck>
Deal with the effects.
<Nuck>
You said that if it's a good piece of software then it should last forever
<Nuck>
Now you're going against that?
<elliottcable>
None of this matters.
<elliottcable>
None of this matters *at all*.
<elliottcable>
This is exactly the thing I hate the most about software development.
<Nuck>
elliottcable: This is #elliottcable, we like bikeshedding
<whitequark>
worrying about compat is related to, and only to, the cost of keeping the system alive versus replacing it with something else
<Nuck>
We're just less skilled at bikeshedding than #oftn
<elliottcable>
Newsflash†: All that matters is the interface, and the experience it purveys.
<Nuck>
elliottcable: What if the interface needs modification?
<elliottcable>
(† hopefully, you already know this. If it's actually a newsflash, stop developing software *now*, please.)
<Nuck>
I agree 100% that the interface is all that matters
<elliottcable>
This is an extremely dynamic subject; just like any other software-development subject, there's no fucking right answer *until* it impacts a particular interface with the user.
<Nuck>
hahahaha oh god
<Nuck>
"For the second time so far this year, Microsoft has released a patch, MS13-036/KB 2823324, that causes widespread blue screens of death (BSODs) on Windows 7 systems when the computers reboot."
<whitequark>
if you're talking about user interfaces... yeah, sure
<elliottcable>
And when that moment comes, there's a subjective and *contextual* decision as to whether the improvements in user-interface of the change, outweigh the impacts on user-interface of the loss of compatibility.
* Nuck
applauds
<Nuck>
whitequark: Not just user interfaces
<whitequark>
but please never touch any systems software in your life, ever, thanks.
<Nuck>
APIs are interfaces too
<elliottcable>
systems software are interfaces, too.
<Nuck>
elliottcable: Well said.
<elliottcable>
*Everything* is an interface.
<Nuck>
I think that's the one thing both elliottcable and I agree on — APIs are interfaces and require careful crafting of UX
<elliottcable>
If it's *not* an interface, or it doesn't ‘have’ an interface, then it *does not matter* and *should not exist*.
<elliottcable>
I hate “UX.”
<elliottcable>
It's a terrible concept.
<elliottcable>
UX is subjective and specific to individual users.
<Nuck>
Well as an idea it makes sense
<elliottcable>
Interfaces themselves are universal and can be theorized about and discussed reasonably.
<Nuck>
elliottcable: Exactly, which is why UX is based on targetting
<elliottcable>
Designing for interface is purposeful; whereas designing for UX is mystic.
<Nuck>
You find your target audience (in programming, I find the answer is almost always "me") and I design for that audience
<Nuck>
What would they require?
<Nuck>
Well, I want X, so I make X
<whitequark>
elliottcable: I see your point. However, I think it's an overgeneralization. You don't go far by discussing just the interfaces as a general concept.
<whitequark>
elliottcable: it's like lambda calculus. it is expressive, but it's too expressive for any useful work. however, you can prove cool theorems and that gives you something.
<whitequark>
I prefer to work on lower/higher levels.
<Nuck>
whitequark: Shush, Haskell is God's gift to programmerkind and we should all be worshipping the Great God Lambda
<whitequark>
Nuck: unrelated
<Nuck>
(that's hte point, absurdism)
<Nuck>
Eventually you'll learn that I fulfill both sides of Poe's Law
* whitequark
slaps Nuck around a bit with a large trout
<elliottcable>
-trout @ whitequark
<Nuck>
I can be both a huge dumbass and a genius troll pretending to be a huge dumbass :D
<Nuck>
And you will *never know the difference*
<whitequark>
I don't care about both
<whitequark>
saves time.
* elliottcable
pats Nuck
<elliottcable>
anyway. Code!
<Nuck>
I am!
<Nuck>
SHUT UP
* elliottcable
rebases a half-dozen times
<Nuck>
LET ME WORK
<Nuck>
>:C
<locks>
I figured you guys weren't smart enough to solve my problem
<locks>
I can't get that ovary-grabbing image from my brain
<whitequark>
B5000 is an arch from 1961. it had hardware support for call/cc, lambdas, multiprocessing, virtual memory, and was programmed entirely in HLL, without assembly
<locks>
who cares
<whitequark>
me
<locks>
congrats on inventing the lisp machine
<whitequark>
... it predates lisp machines?
<whitequark>
and has more useful features?
<locks>
you have a problem in your keyboard
<Nuck>
Lisp has every feature, remember?
<locks>
it keeps appending bullshit passive-aggressive ? to the end of your sentence
<locks>
s
<whitequark>
gtfo, lisp fanboys
<Nuck>
Because Lisp is god and omnicient and shit
<locks>
thought I'd let you know
<Nuck>
whitequark: I'm not a lisp fanboi
<Nuck>
I'm a smalltalk fanboy
<whitequark>
it's not even a particularly interesting language. OMeta is far better.
<FireFly>
Are there specs for the B5000 available?
<FireFly>
OMeta's pretty awesome
<FireFly>
though I've only used the JS flavour of it
<Nuck>
So I got this guy on deviantART actually calling me "The JavaScript Dentist" now
<whitequark>
this is my brainfuck harvard softcore with 5-stage pipeline, instruction prefetch, hardware stack and branch prediction
<whitequark>
modelled after the canonical MIPS architecture
<whitequark>
I'm fairly sure this is the fastest brainfuck softcore in existence
<whitequark>
I'd measure its DMIPS/MHz ratio if only someone'd port the Dhrystone benchmark to brainfuck, lol
<purr>
lol
<FireFly>
Well, brainfuck isn't functional :P
<whitequark>
also need to make it superscalar maybe, and add dynamic translation
<FireFly>
I've done some level of hardware stuff
<whitequark>
FireFly: what's the problem with functional langs?
<FireFly>
The problem isn't with the language, but with me not seeing how hardware supporting functional concepts works
<FireFly>
since I haven't read up on the topic yet..
<whitequark>
do you understand how it works on modern cpus, like intel ones?
<FireFly>
Sure, at least I think I do
<whitequark>
pick lowest level of that (e.g. resolving closure environments), move it to RTL, boom, it's ready
<whitequark>
rinse and repeat
<whitequark>
after several steps, and pruning unnecessary abstractions like stupid x86 instructions (most of them), you'll get a lisp machine
<FireFly>
heh
<whitequark>
elliottcable: last bit re: bot design.
<whitequark>
every now and then I'm working on something supposedly hard. so, people ask me: how are you going to solve the (hard problem name)?
<whitequark>
and the answer is, always, I fucking don't. if you are trying to solve a hard problem, one at which a generation of two of people more clever than you have failed, you're fucking doing it wrong.
<whitequark>
this has served me very well, so far.
<whitequark>
(eg applied to Foundry: how are you going to eliminate bounds checking, like Java VMs try to? the answer: just use #each{}, it doesn't need to perform them. and so on.)
<whitequark>
most often (always?) if something's hard to develop, it will be even harder to use. avoid this.
<whitequark>
I've said something similar to your statement about predictability, in the past. But it was applied specifically to PLs and I called it "control". Simple, intuitive things must be possible and just work by default. But when, not if, you need to develop something complex, the language must offer you enough control for it to be possible for you to do this.
<whitequark>
in unrelated news, I probably shouldn't trust elliottcable. (For some value of "trust".) He is not my friend, and will hardly ever be one. (For some value of "friend".) Which is a bit sad, but you have what you have.
* elliottcable
reads
<elliottcable>
-clouds
<purr>
elliottcable: is stuck up in the clouds; hilight 'em if you want 'em.
<elliottcable>
whitequark ⑊ why are you needing to trust me, again? Or did I miss something up here?
<elliottcable>
were you about to give me money and then decided not to? o_O
<elliottcable>
bbs, battery dying.
<whitequark>
elliottcable: just random thoughts
<whitequark>
no, not for that value of "trust" :3
<elliottcable>
-go away locks
<purr>
elliottcable: FUCK YOU
<elliottcable>
oh my god, that's a thing
<elliottcable>
-factoid go away locks
<purr>
elliottcable: Popularity: 3, last changed by: <unknown>, <unknown time> ago
* elliottcable
laughs
<elliottcable>
it's ancient, too
<elliottcable>
-turning
<purr>
elliottcable: <+elliottcable> I turned around to walk away \n and kept turning … \n and kept turning … \n and fell flat on my face on the floor
<elliottcable>
ovoids <3
<elliottcable>
-hawaiian orthography
<purr>
elliottcable: alohabet
* elliottcable
laughs
<elliottcable>
okay. bbl.
<whitequark>
bbsl. "sooner or later"
<Nuck>
hahaha that's beautiful
<whitequark>
elliottcable: meh, forget that, it has nothing to do with trust and/or friendship, really
<whitequark>
simpler
<whitequark>
you're older than me. ofc, not by physical age, or not that it matters anyhow.
<whitequark>
this has profound implications. also, it has been a long time since someone made me feel it that deeply
<whitequark>
and I'm off.
<purr>
<othiym23> why does JS hate Vietnamese?
yorick has joined #elliottcable
PragCypher has quit [Quit: Leaving]
alexgordon has joined #elliottcable
yorick has quit [Remote host closed the connection]
<whitequark>
elliottcable: scratch all that. especially the ML/AI part.
<whitequark>
I've drafted a few parse trees/rules and it isn't going to involve ML for anything that matters.
<whitequark>
also, forget everything you know about NL input :)
<whitequark>
I know what specifically I'm doing, how I'm doing it, why it's applicable here and why everyone can fuck off... well, except the last part. Maybe.
audy has joined #elliottcable
<purr>
<jeannicolas> * pictures elliottcable writing javascript while bathing in V8 juice...
<incomprehensibly>
whitequark: haha that brainfuck machine sounds awesome
<incomprehensibly>
elliottcable: seems like you'd be a fan of this guy prog21.dadgum.com
<incomprehensibly>
whitequark: I've kind of already mentioned this but I want to see an architecture for *pure* functional programming, or FRP or something
<incomprehensibly>
whitequark: not just an imperative language with closures and continuations and stuff
<incomprehensibly>
because if it's pure, it could be genuinely fundamentally different
alexgordon has joined #elliottcable
<purr>
<elliottcable> and, like, epic fighter battles with laser-harpoons
<alexgordon>
if I show myself english words at random, it takes me a while to work out what they actually mean
<alexgordon>
you'd think that because I've been speaking english for quite a while ( ;) ) I would be able to do it easily
<alexgordon>
but it's not
<alexgordon>
and when I do it either comes in the form of a sentence "I WILL go shopping" or a mental image
<alexgordon>
so that really confirms what I thought already, which is we don't actually learn words, we merely associate them with other words and memories
<alexgordon>
not even sure what learning a word would be if not those
<alexgordon>
but it's interesting that even as a native speaker I put things in terms of sentences
yorick has quit [Read error: Connection reset by peer]