devyn changed the topic of #elliottcable to: #alexgordon-ranting
<cuttle> NSFL is not necessarily a subset of NSFW
<cuttle> alexgordon:
<cuttle> let's design
<cuttle> :::::
<alexgordon> ::::::
<cuttle> ::::::::::
<whitequark> ffuuuu
yorick has quit [Remote host closed the connection]
<devyn> whitequark: what the fuck
<whitequark> wait until you see this: http://linux.die.net/man/3/memfrob
<devyn> lolgnu
<purr> lolgnu
<devyn> secret jokes in everything
<devyn> not-so-secret, but yeah
<devyn> whitequark: kinda like strfry though. stir-fry. it's somewhat clever.
<joelteon> i wonder if there are any "life hack" ways to get an earlier appointment
<joelteon> i could bribe someone for their ticket
<devyn> still waiting? jesus
<joelteon> nah, didn't go
<joelteon> i could just get it over with tomorrow morning, bike there, wait three hours, bike home
<joelteon> yeah, i think i'll do that
<devyn> lol
<purr> lol
<joelteon> fuckin
<joelteon> might as well
<joelteon> this is stupid
jvulc|znc has quit [Ping timeout: 240 seconds]
jvulc|znc has joined #elliottcable
jvulc|znc has quit [Changing host]
jvulc|znc has joined #elliottcable
<cuttle> joelteon: sounds awful :p
<cuttle> alexgordon: jdflaksjadklfsjlfkdsjkfladsfjldkasljkfdsa:::::::::
<alexgordon> hi cut
<cuttle> haha
<cuttle> chimpanzees drumming
<cuttle> alexgordon: so like i imagine there would be things like
<cuttle> screen = composite(images)
<cuttle> images is a set of images
<cuttle> with their positions or whatedver
<cuttle> yknow
Sgeo has joined #elliottcable
<cuttle> alexgordon: the problem is
<cuttle> alexgordon: sometimes i want pushing rather than pulling
<cuttle> like, side effects style pushing
<cuttle> like think about this
<cuttle> a ui element wants to change another ui element
<cuttle> sometimes it's ugly to express like
<whitequark> cuttle: look at how qt solved this
<cuttle> the other ui element in terms of the first one
<whitequark> it emits an event
gazoombo has quit [Ping timeout: 264 seconds]
<whitequark> that's pretty cool
<cuttle> whitequark: hm?
<whitequark> well it does like, emit fuckUpThatEditBox(int amountOfFucks)
<whitequark> and this event is connected to the respective slot in the edit box
<cuttle> well i mean that's like, an OO framework on top of an imperative language
<whitequark> it's basically message sending
<cuttle> i'm talking more on a deep level
<whitequark> doesn't matter
<whitequark> I show you how to build a push-style abstraction on a pull-like API
<whitequark> which is, well, not hard? if you can wait on conditions, just make a bogus condition and call it a pusher
gazoombo has joined #elliottcable
<cuttle> well what i'm saying is you can't do that in a pure frp system
<whitequark> why?
<cuttle> where in a = <expression> the *only* things that can affect a are encapsulated by that expression
chellio has quit [Ping timeout: 245 seconds]
<cuttle> it leads to ugly backwards things sometimes
<cuttle> for instance
<cuttle> say you have a set of sprites in a video game
<cuttle> and you want to have events result in the insertion or deletion of sprites
<cuttle> then your expression defining the set has to encapsulate all that
<whitequark> oh right, pureness strikes again
<whitequark> fuck pureness?
<cuttle> no
<cuttle> let me explain what I aim to achieve
<cuttle> i'm not having pureness for pureness' sake
<cuttle> this is a language where having the evaluation of an expression result in a side effect fundamentally doesn't make sense at all
<cuttle> because an expression denotes a value over time
<cuttle> so it's evaluated for its value every time anything it refers to changes
<cuttle> or you could have it evaluated every dt
<cuttle> either way, the program doesn't care
<whitequark> either way pureness bites you in the ass
<whitequark> I don't see a choice here
chellio has joined #elliottcable
<whitequark> hm
<whitequark> cuttle: I don't see a problem with side effects
<whitequark> so say
<whitequark> a = set.count
<whitequark> each time you destructively update set, a changes
<whitequark> no?
<whitequark> so there'll be say a declarative part and an imperative part
<whitequark> and when you refer to the declarative part from the imperative part, it gets evaluated with the "current" t
<whitequark> because your *host environment* is basically the imperative part anyway
fwg has quit [Ping timeout: 252 seconds]
alexgordon has quit [Quit: Computer has gone to sleep.]
<cuttle> whitequark: no division between declarative and imperative. hell no
<cuttle> whitequark: the only imperative part will be outside it, the c interopping
<cuttle> so i mean i guess that's what you said
<cuttle> but i need a way to do it within
<cuttle> not going to rely on the imperative part
<cuttle> just got a great idea
<cuttle> every line is just a statement of a fact/relationship
<cuttle> so, like entries in a pattern matchin
<cuttle> g
<cuttle> or like one of the things affecting a variable
<cuttle> i'll put something together to illustrate it
<devyn> holy. shit.
<joelteon> text clipping?
<devyn> it waves
<cuttle> devyn: kind of tired of all the css stuff, it's one of those things where you *can* but it's questionable if you *should* :p
<devyn> cuttle: the point is that you can, not necessarily that you should :p
<cuttle> lol I'm glad we agree
<purr> lol
<devyn> cuttle: I want more pointless artsy things like demoscene
<devyn> things that are really impressive but useless
<joelteon> yeah it's a really cool thing that we'll be able to use in 2018
<devyn> joelteon: what is? lol
<joelteon> the water loading text
<devyn> meh, you can always just say fuck everything that's not IE 11
<devyn> IE-wise
<devyn> :p
<devyn> MS thinks IE11 is good enough that they even changed the User-Agent to not mention IE anywhere
<devyn> instead it's Trident, and like Gecko
<joelteon> wooow
<joelteon> ok
<joelteon> good job internet exploder
<joelteon> so docker is cool
<devyn> we can hope that one day IE will be perfectly in line with WebKit & Gecko
<joelteon> apparently docker makes continuous deployment really fast
<devyn> seems like MS's strategy for backward compatibility lately is just to include all of the older engines and only trigger them when it recognizes old things
<devyn> <!DOCTYPE html> seems to be enough to trigger edge mode lately
<joelteon> good thing they're so committed to backwards compatibility
<devyn> they have to be... but this way at least they're not stuck
<devyn> they can have an actually modern engine that doesn't support any legacy IE stuff
<cuttle> devyn: demoscene is a good comparison, I guess
<cuttle> I relent, CSS stuff is cool
<joelteon> the biggest problem with compiled languages is the "compiled" part
<joelteon> :(
eligrey has quit [Quit: Leaving]
<devyn> cuttle: yes, I want nouveau-demoscene
<devyn> I mean the people optimizing insane 3D animations into tiny, tiny executables are awesome,
<cuttle> joelteon: haha what
<devyn> but... that doesn't have to be the only thing
<joelteon> it's
<cuttle> devyn: yeah good point
<joelteon> instead of deployment being
<joelteon> "git pull"
<joelteon> and restart unicorn
<joelteon> you pull, then you have to compile it again
<cuttle> /me nods
<joelteon> i'd be fine with compiling again except
<joelteon> for the whole
<joelteon> "memory" thing
<cuttle> wait what
<joelteon> ghc creates object files that make ld use a lot of ram
<joelteon> more than my poor little DO box can afford
<cuttle> oh ok
<joelteon> so i have to build in a VM and copy the built binary
<cuttle> jesus
<cuttle> :p
<joelteon> docker will fix that
<joelteon> not fix it exactly
<joelteon> but make it less painful
<joelteon> not make it less painful, really
<joelteon> since i'm still using a VM
<joelteon> so there's no point to doing it
<joelteon> well
<joelteon> I could build a CI server that does it
<joelteon> but then again I could just build a CI server that does the copy and the restart
<cuttle> hahaha that was a lot of second guessing every single thing you said
sharkbot has quit [Remote host closed the connection]
sharkbot has joined #elliottcable
<devyn> :) :)
upgrayeddd has quit [Quit: Connection closed for inactivity]
niggler has quit [Quit: Computer has gone to sleep.]
<devyn> woo, multiboot available memory + kernel command line printing added
fwg has joined #elliottcable
niggler has joined #elliottcable
yorick has joined #elliottcable
fwg has quit [Ping timeout: 246 seconds]
fwg has joined #elliottcable
fwg has quit [Ping timeout: 272 seconds]
Sorella_ has joined #elliottcable
chellio has quit [Quit: Connection closed for inactivity]
Sgeo has quit [Read error: Connection reset by peer]
fwg has joined #elliottcable
PragCypher has joined #elliottcable
alexgordon has joined #elliottcable
<yorick> devyn: urbit is supposed to be some kind of martian, it redefines everything. have you seen their counting system? http://www.urbit.org/2013/08/22/Chapter-4-syntax.html
<yorick> the obsession with 4 letter names isn't the worst part of it
<whitequark> devyn: haha osdev is cool
<whitequark> I used to obsess with it
<whitequark> loooong time ago
<whitequark> in like 8th grade... 2006 or so?
<devyn> whitequark: :p
<devyn> yorick: the counting system isn't on that page...
<yorick> devyn: true :/
<yorickpeterse> yes it is
<whitequark> 419!
<devyn> ah, yes it is
<devyn> lol is it just me or do strings have to be escaped for a line break on both sides?
<purr> lol
<devyn> 'hhh\
<devyn> /aaa'
<devyn> >_<
<yorick> devyn: it's base256 little endian
<yorick> so there's dozzod, marzod, binzod, wanzod, samzod, litzod, ... doznec, marnec, binnec, wannec, samnec, ... dozbud, marbud, binbud
<devyn> I don't think that's crazy; I think that's awesome
<devyn> but
<devyn> the crazy part of it all is
<devyn> What is %brts? The atom also known as 1937011298 or 0x73747262. Simply a string mapped to an unsigned integer, LSB first. It’s easy to see why the vowels got lost - %bartis is 126896762413410 or 0x736974726162. On a 32-bit CPU with 31-bit direct atoms, %brts is direct and %bartis indirect (not that the programmer can tell the difference). But you still say “bartis.”
<devyn> BECAUSE FITTING SYMBOLS INTO A PROCESSOR REGISTER IS TOTALLY A GOOD REASON
<yorick> devyn: my fear is that 4-char strings fit inside 32 bits
<devyn> yorick: 4-char strings fitting in 32 bits is reasonable if each char is only a byte...?
<yorick> yes
<devyn> so...?
<devyn> this obviously isn't a language that cares about Unicode
<devyn> :p
<yorickpeterse> nobody cares about unicode
<yorick> devyn: no, martian is strictly ascii
<devyn> yorickpeterse: BUT UNICODE IS WEB SCALE
<yorick> devyn: ascii is mars-scale.
<yorickpeterse> actually, compared to ascii Unicode would not be webscale
<yorickpeterse> errrr
<yorickpeterse> UTFX
<devyn> yorick: lol add is based on increment and decrement, and decrement is based on increment + wraparound... :p
<purr> lol
<yorick> devyn: no, it's based on loop to one prior to it
<devyn> yes, wraparound
<devyn> ._.
<devyn> class time.
<yorick> devyn: no, it increments from 0 until it's one lower
<yorick> *I think*
fwg has quit [Ping timeout: 246 seconds]
Sorella_ is now known as Sorella
Sorella has quit [Changing host]
Sorella has joined #elliottcable
<devyn> yorick: that would be too logical :)
<devyn> yeah, probably.
<joelteon> h-hi guys
<devyn> hopefully nock doesn't just assume it's running with 32-bit integers
<devyn> wrapping a 64-bit integer would take a long time
<devyn> lol
<purr> lol
fwg has joined #elliottcable
PragCypher has quit [Remote host closed the connection]
niggler has quit [Quit: Textual IRC Client: www.textualapp.com]
niggler has joined #elliottcable
eligrey has joined #elliottcable
Sorella has quit [Quit: Ex-Chat]
<joelteon> hi
<purr> joelteon: hi!
<joelteon> hi purr
<purr> joelteon: hi!
<whitequark> devyn: it does not actually wrap integers.
<whitequark> the backend pattern-matches specifically that loop in decrement and emits proper code for it
<whitequark> the idea is that you can mechanically verify soundness of the "long" wrapping code
<whitequark> the problem is that nothing at all guarantees you that your fast pattern-matched primitives will behave the same way
<whitequark> the whole idea is moronic.
<joelteon> i think i'm going to make a freenode simulator
<whitequark> wat.
<whitequark> joelteon: wat.
<purr> beep.
<joelteon> it'll be like an IRC client, but it pipes to /dev/null
<joelteon> you ask it questions
<whitequark> nice idea
<joelteon> yeah
<joelteon> occasionally I might have it call you stupid
<cuttle> joelteon: :p
<alexgordon> hi cuttle
<joelteon> FUCK
<joelteon> BERKSHELF IS THE WORST PIECE OF SOFTWARE EVER MADE
<alexgordon> I love web developers
<alexgordon> in the biblical sense
<joelteon> you fuck them
<alexgordon> 1. before: use <b>/<i>
<alexgordon> 2. later: don't use <b>/<i> !
<alexgordon> 3. now: use <b>/<i> some of the time!
<alexgordon> so much bikeshedding goes on
<joelteon> who says to use <b>/<i>
<alexgordon> joelteon: the html standard
<joelteon> wotn
* alexgordon just uses <b>/<i> for everything. fuck the police
<joelteon> i use strong/em
<alexgordon> they're shorter, that's all the reason I need
<joelteon> heh
<alexgordon> joelteon: you're typing more characters AND you're violating the spec
<joelteon> >shorter >uses C++
<alexgordon> good job
<joelteon> ok
<alexgordon> joelteon: you're only "supposed" to use <strong> if the text is supposed to be said forcefully (i.e. strongly emphasised)
<alexgordon> for everything else you should use <b>
<joelteon> oh
<alexgordon> come to the dark side, joelteon
<joelteon> ok
<alexgordon> muahahaha
<joelteon> alexgordon, how much does it cost to pay a hitman in the UK
<alexgordon> joelteon: ... you think *I* would know?
<alexgordon> not sure whether to be flattered or offended
<joelteon> good idea
<joelteon> i'll ask EC
<joelteon> where is he
<alexgordon> no idea
<joelteon> damn
<ELLIOTTCABLE> ?
<joelteon> EC how much does it cost to hire a hitman
<alexgordon> joelteon: you realize it's probably illegal to ask that question and DEFINITELY illlegal to answer it
<joelteon> darn
<alexgordon> even as a joke
<joelteon> ok
<joelteon> i'm sorry ec
<whitequark> hi ELLIOTTCABLE
<alexgordon> joelteon: but don't fear, a russian has appeared!
<joelteon> neat
fwg has quit [Ping timeout: 246 seconds]
<niggler> lol how does this happen
<purr> lol
<niggler> https://github.com/trending #11 is the xlsx, #13 is xls and #12 is angular
<cuttle> ELLIOTTCABLE: !
<cuttle> alexgordon: !
<alexgordon> cuttle!
<ELLIOTTCABLE> ?
fwg has joined #elliottcable
<cuttle> hey look
<cuttle> someone skeptical about sexism is presented with evidence and accepts it
<cuttle> hi ELLIOTTCABLE i have cool ideas about a lnaguage
<cuttle> alexgordon: i have cool idaes about a language
<alexgordon> cuttle: go on
<whitequark> cuttle: go on
<cuttle> ok
<cuttle> one sec
<cuttle> oh god look at this
<cuttle> buzzwords held together by function words
<cuttle> ok so, idea:
<cuttle> a program is a big ol list of facts
<cuttle> some define parts of a data type
<cuttle> some define parts of values
<cuttle> so you might say
<cuttle> true : bool
<cuttle> false : bool
<cuttle> now you have two bools
<cuttle> you might say
<cuttle> f(true) = 3
<cuttle> f(false) = 4
<cuttle> now f is fully defined on bools
<cuttle> you could say
<cuttle> f : bool -> number or whatever
<cuttle> not sure how i'm going to differentiate between type annotations and data declarations, maybe just a data keyword or some shit
<cuttle> anyway
<cuttle> you can also say like
<cuttle> velocity = integral(acceleration)
<cuttle> position = integral(velocity)
<cuttle> and when you say =, something is true forever
<cuttle> but for instance you can say things like
<cuttle> not sure what the syntax would be, but you could write a line of code that states that velocity is incremented by 3 per unit time
<cuttle> and then you could write another line of code that coexists with that, and each thing happens at the same time and they're combined togehter
<cuttle> imagine applying several forces to a physical object
<cuttle> another example could be
<cuttle> a line specifies, when this particular event fires/this value changes to this, then this value changes to that
<cuttle> or, a line pushes a thing to a queue
<cuttle> basically, lots of things are good at accumulating influence from a lot of sources
<cuttle> like for instance stdout is a queue you push strings to
<cuttle> or the screen is something you push image-drawing commands (an image and a position to draw it at or something) to
<whitequark> cuttle: so the language would essentially be a constraint solver
<whitequark> reminds me of prolog somewhat
<whitequark> the problem is that it's very very easy to write a completely undecidable problem that way
<cuttle> whitequark: no, it's completely deterministic
<cuttle> no solvers
<whitequark> mhm
<cuttle> hm, i guess some things could clash
<cuttle> like, if you had two conditions specifying contradictory states of a variable
<cuttle> and the conditions were potentially overlapping, you'd need halting problem etc.
<whitequark> exactly
<whitequark> I mean I think this kind of stuff is very cool, but it's also very hard and unpractical
<whitequark> the "simple problems in C become PhD topics in Haskell" catch
<cuttle> well i could limit the conditions to patterns
<cuttle> you can deterministically say whether all patterns have been matched
<whitequark> yup, but also pattern matching in... every langauge I know has those 'when' clauses
<whitequark> or, well, just conditionals
<cuttle> yes of course
<cuttle> there will be conditionals too
<whitequark> how'd you handle that?
<cuttle> well
<whitequark> I'm afraid you will end up in the haskell route, aka "let's complicate our type system until it can express everything... oh wait, no, let's just complicate it until we have no idea how it works"
<cuttle> restrict the multiple definitions that can make up a single value to patterns
<cuttle> for more complex conditions it has to be in an expression
<whitequark> okay
<whitequark> so what do you do if two expressions conflict?
<cuttle> ?
<cuttle> what do you do if the if and else clause in haskell or ruby "conflict"
<cuttle> that's what i'm taling about with expressions
<whitequark> ok
<whitequark> so you basically limit data flow with your pattern matching sublanguage
<whitequark> or can you express everything you can express with patterns, with just expressions?
<cuttle> patterns are for like
<cuttle> polymorphism
jvulc|znc has quit [Ping timeout: 240 seconds]
<cuttle> turing complete wise you can express everything with expressions
<whitequark> gimme examples
<whitequark> in code
<cuttle> ok
<cuttle> type move
<cuttle> rock : move
<cuttle> paper : move
<cuttle> scissers :move
<cuttle> game(paper, rock) = paper
<cuttle> game(rock, scissors) = rock
<cuttle> game(scissors, paper) = scissors
<cuttle> game(a, b) = game(b, a)
<cuttle> exhaustive patterns
<whitequark> isn't this like
<whitequark> prolog?
<cuttle> deterministically verifiable
<cuttle> not really
<cuttle> there's no searching to satisfy constraints
<cuttle> this is just normal old functions
<cuttle> it's like if you said in haskell
<whitequark> oh ok
<whitequark> I see
<cuttle> game a b = case a of { ... }
<whitequark> ok so
<whitequark> what's the point?
<cuttle> in fact i got the idea for an RPS game from Atomo
<cuttle> well, you could do this:
<cuttle> gun : move
<cuttle> somewhere else
<cuttle> and then write
<cuttle> game(gun, x) = gun
<whitequark> so extensibility
<cuttle> yeah
<cuttle> so the problem with OO hierarchies is that
<whitequark> seems like some kind of awkward special case
<cuttle> you can add new cases of a datatype
<whitequark> maybe it's not
<cuttle> but you can't add new operations
<cuttle> (barring monkeypatching)
<cuttle> the problem with haskell data types is
<cuttle> you can add as many operations as you want
<whitequark> refinements?
<cuttle> but not new cases to a data type
<cuttle> so this lets you both add new operations and add new cases of a data type
<cuttle> freelly
<cuttle> sure, refinements are a solution
<cuttle> and c# util classes
<whitequark> also
<cuttle> and go and rust's methods and stuff
<whitequark> your thing is equivalent to monkeypatching
<whitequark> totally
<cuttle> well it's scoped
<whitequark> what if a value escapes?
<cuttle> if you import a module that uses types that aren't available to you it'd be an error
<whitequark> so you can extend it but cannot use it in unextended modules?
<whitequark> why would you want to extend it then?
<cuttle> doesn't that stand to reason?
<cuttle> look at this
<cuttle> you have a data type
<cuttle> people are using it happily
<cuttle> you want to extend it in your project
<cuttle> so you don't have to break open the library, you just write a module that extends it, and your project uses that module
<cuttle> but other projects don't
<cuttle> why would it ever make sense to have an extended data type where using operations on it is just an error
<whitequark> well
<cuttle> basically, it's statically verified that all operations in the scope you're running in have code for every case of a data type
<cuttle> and if they don't it's an error
<cuttle> and the scope can come from imports
jvulc|znc has joined #elliottcable
<whitequark> ok, so
<whitequark> do you have closures?
<whitequark> any indirect call mechanism, for that matter
<whitequark> #send, etc
<cuttle> probably will have first class functions
<whitequark> ok
<whitequark> so you want to have statically checked safety for your data type extension
<whitequark> this means that you need to enrich the function signature with its scope
<whitequark> basically, the module it came from, or, in a more flexible way, its set of imports
<cuttle> a closure has to have its entire originating scope available
<cuttle> that's nothing new
<whitequark> available?
<whitequark> define available.
<cuttle> available to the containing code
<cuttle> the literal definition of a closure
<whitequark> nono, what I mean is
<whitequark> say module A defines a datatype and a function operating on it accepting a closure
<whitequark> module B extends this datatype and passes a closure to module A
<whitequark> if you want this to be statically rejected, you need to encode the fact that the closure expects the datatype to be extended in its signature
<whitequark> see?
<cuttle> ok
<whitequark> this can cause ripple effects in some cases
<cuttle> that's less
<cuttle> encoding information in the closure, and more encoding information in the return type/argument types of the closure
<cuttle> it's really irrelevant to whether it's a closure
<whitequark> mhm
<whitequark> yes, probably
<whitequark> ok so
<whitequark> another thing
<whitequark> you'll have subtyping relation between unextended and extended datatype right?
<cuttle> i guess so
<whitequark> what about passing stuff the other way?
<cuttle> error?
<whitequark> what when you need it?
<whitequark> so you import some lib, extend its type, now you cannot use any of the functions it has?
<cuttle> hm how do other languages solve it
<cuttle> casting?
<cuttle> :/
<whitequark> well
<whitequark> it depends
<whitequark> java does it in runtime
<whitequark> ocaml plain out forbids it
<cuttle> ok
<cuttle> sounds bad
<cuttle> forget the whole thing
<whitequark> sorry I broke your idea -_-
<whitequark> usually this feels good though
<cuttle> :p