←2011-06-07 2011-06-08 2011-06-09→ ↑2011 ↑all
00:00:02 <CakeProphet> !delinterp wc2
00:00:02 <EgoBot> ​Interpreter wc2 deleted.
00:00:25 <CakeProphet> !addinterp wc2 perl $_=<>;chomp;s/^\W*([-]\w+\W+)*//;$opt=$1;print `echo "$_" | wc $opt`
00:00:26 <EgoBot> ​Interpreter wc2 installed.
00:00:30 <CakeProphet> !wc2 -c abc
00:00:30 <EgoBot> ​1 2 6
00:00:35 <CakeProphet> fffff
00:00:41 <CakeProphet> but yeah Iwas confusing \w and \W
00:00:53 <CakeProphet> \w stands for "word character" not "whitespace"
00:01:32 <CakeProphet> !delinterp wc2
00:01:32 <EgoBot> ​Interpreter wc2 deleted.
00:02:51 <oerjan> > mapM (length <$>) [lines, words, id] "test\nho there"
00:02:52 <lambdabot> Couldn't match expected type `GHC.Types.Char'
00:02:52 <lambdabot> against inferred type...
00:02:52 <elliott> im...robot
00:02:58 <oerjan> f
00:03:10 <elliott> im...robot
00:03:11 <elliott> im...robot
00:03:12 <elliott> im...robot
00:03:12 <elliott> im...robot
00:03:12 <elliott> im...robot
00:03:16 <elliott> im...robot
00:03:18 <elliott> im...robot
00:03:26 <elliott> could this ircing get any better???
00:03:47 <oerjan> oh duh
00:04:19 <CakeProphet> !addinterp wc2 perl $_=<>;chomp;s/^\s*((?:[-]\S+\s+)*)//;$opt=$1;print;print `echo "$_" | wc $opt`
00:04:19 <EgoBot> ​Interpreter wc2 installed.
00:04:24 <CakeProphet> !wc2 -c weorjsoidfjiuwehriuwheriuhweriuh
00:04:25 <EgoBot> ​weorjsoidfjiuwehriuwheriuhweriuh33
00:04:38 <CakeProphet> okay, now I'm Leibniz.
00:04:47 <CakeProphet> except with emulating wc as an IRC bot command
00:04:51 <CakeProphet> instead of calculus.
00:04:57 <CakeProphet> !delinterp wc2
00:04:57 <EgoBot> ​Interpreter wc2 deleted.
00:05:20 <CakeProphet> !addinterp wc2 perl $_=<>;chomp;s/^\s*((?:[-]\S+\s+)*)//;$opt=$1;print `echo "$_" | wc $opt`
00:05:20 <EgoBot> ​Interpreter wc2 installed.
00:05:23 <pikhq_> Hmm. include-what-you-use may be the single greatest boon to porting something to work on musl.
00:05:41 <CakeProphet> musl?
00:05:46 <pikhq_> A simple libc.
00:06:43 <oerjan> > mapM (length.) [lines, words, (pure.)] "test\nho there"
00:06:44 <lambdabot> [2,3,13]
00:07:05 <pikhq_> And include-what-you-use is a static analysis tool built with clang that does, well, what you think it does.
00:07:10 <CakeProphet> !addinterp sh++ perl $_=<>;print `$_`
00:07:11 <EgoBot> ​Interpreter sh__ installed.
00:07:21 <CakeProphet> elliott: it's an improved sh because it runs through perl...
00:07:59 <CakeProphet> I recommend using it in the future.
00:11:12 <Patashu> lol
00:11:35 <CakeProphet> elliott: also, because there was totally an implied golfing contest, my code has few bytes with whitespace removed
00:11:43 <CakeProphet> *fewer
00:12:07 <CakeProphet> !delinterp wc2
00:12:07 <EgoBot> ​Interpreter wc2 deleted.
00:12:49 <CakeProphet> !addinterp wc2 perl $_=<>;chop;s/^\s*((?:[-]\S+\s+)*)//;print`echo "$_"|wc $1`
00:12:49 <EgoBot> ​Interpreter wc2 installed.
00:12:58 <CakeProphet> -ahem- and now even fewer.
00:20:41 <pikhq_> Hmmmm. I think that I might be able to get GNU coreutils to coöperate with me. Near as I can tell, the stupid bits of gnulib are actually just someone being overzealous.
00:20:53 <pikhq_> That is, I may well be able to fix it via rm.
00:21:49 <elliott> but why would you want gnu coreutils
00:23:21 <pikhq_> I was just wondering, mostly.
00:23:45 <pikhq_> I'm going to be amused if the portability problems of GNU shit is because they just stuck too much stuff from gnulib in there.
00:26:52 <CakeProphet> How much money do I make working at FSF?
00:27:01 <CakeProphet> :3
00:27:17 <elliott> stallman's foot clippings
00:28:47 <CakeProphet> I wonder why stallman is the butt of so many jokes. He's a pretty cool guy, doesn't afraid of anything.
00:29:06 <pikhq_> *facepalm*
00:29:08 <pikhq_> #if 1
00:29:13 <pikhq_> # include <xlocale.h>
00:29:13 <pikhq_> #endif
00:29:27 <pikhq_> Guess what won't work anywhere at all?
00:29:36 <coppro> pikhq_: ...
00:29:47 <CakeProphet> lolwhut
00:29:53 <pikhq_> Incidentally, that header only exists on OS X 10.5.
00:30:00 <coppro> pikhq_: xlocale.h?
00:30:02 <coppro> it's quite common
00:30:20 <pikhq_> /* MacOS X 10.5 defines the locale_t type in <xlocale.h>. */
00:30:24 <pikhq_> Well, that's what they claim.
00:30:28 <coppro> ah
00:30:38 <coppro> glibc does the same but they #include <xlocale.h> in <locale.h?
00:30:43 <coppro> s/\?/>
00:32:49 * elliott myndzi
00:32:50 * myndzi elliott
00:33:52 <CakeProphet> coppro: on an utterly pedantic note, I don't think you have to escape the ? if there's nothing in front of it.
00:36:04 <CakeProphet> though it would be an interesting extension if a ? at the beginning of the regex signified that the null string is acceptable or something.
00:36:43 <CakeProphet> equivalent to (?:...)? around the entire expression
00:37:48 -!- cheater_ has quit (Ping timeout: 248 seconds).
00:40:47 -!- cheater_ has joined.
00:52:20 <CakeProphet> I have no idea what I would be doing with myself if I had never learned how to program.
00:52:31 -!- oklopol has quit (Ping timeout: 258 seconds).
00:52:56 <CakeProphet> I'd probably write a lot more.
00:53:25 <CakeProphet> and would have become an English major or something awful like that.
00:54:26 <CakeProphet> elliott: link me an interesting data structure that I haven't heard of.
00:56:18 <CakeProphet> and on yet another unrelated note, they should REALLY put something like fclabels into Haskell by default, and completely redo the record syntax.
00:56:57 <elliott> haskell records are pretty much the worst yeah
00:57:24 <CakeProphet> because as it currently stands there is no higher-order mechanism to re-set record fields cleanly.
00:57:42 <CakeProphet> without using fclabels, which uses template haskell I believe.
00:57:49 <elliott> we also need some kind of type-directed name resolution.
00:57:51 <elliott> http://hackage.haskell.org/trac/haskell-prime/wiki/TypeDirectedNameResolution
00:57:58 <elliott> CakeProphet: you can derive the accessors manually if you want to avoid TH
00:58:20 <CakeProphet> expand TH plz.
00:58:26 <CakeProphet> oh
00:58:27 <CakeProphet> nvm
00:58:28 <CakeProphet> :P
00:59:04 <CakeProphet> well it's not so much that I want to avoid it, it's just that the fclabels syntax to declare something as a fclabel is somewhat ugly.
00:59:27 <elliott> you can omit the $() in ghc 7
00:59:36 <elliott> data Point = Point { _x :: Integer, _y :: Integer }
00:59:40 <elliott> mkLabels [''Point]
00:59:43 <elliott> that's not so bad.
01:00:31 <CakeProphet> elliott: essentially this proposal is proposing a kind of overloading. Which I think is a good idea(tm)
01:00:41 <elliott> it isn't
01:00:47 <elliott> we already have overloading (typeclasses)
01:00:51 -!- Sgeo has quit (Ping timeout: 252 seconds).
01:00:52 <elliott> (unstructured overloading is Dangerous)
01:01:10 <elliott> it's in fact just exactly what it says on the tin ... type-directed name resolution :P
01:03:19 <CakeProphet> elliott: to me the . lexeme seems somewhat unecessary.
01:04:35 <elliott> brb
01:04:38 <CakeProphet> you could just overload the accessor name based on the type of the first argument (read: type directed name resolution) but skip the . syntax, which already has enough things that it represents.
01:06:24 -!- augur has quit (Remote host closed the connection).
01:08:13 <CakeProphet> the only problem would be that :t accessorName is now ambiguous, or would refer to only one while hiding all others. But, that proposal has that problem as well.
01:22:58 <elliott> back
01:23:10 <elliott> CakeProphet: that's really ugly. and no, the proposal doesn't have the latter problem
01:23:15 <elliott> note that most of the later sections are just /ideas/
01:23:26 <elliott> and the ones that involve two functions with the same name in the same module scope are bad ones :)
01:24:00 <CakeProphet> I don't see anything wrong with M.accessor x
01:24:49 <CakeProphet> http://hackage.haskell.org/trac/haskell-prime/wiki/ExistingRecords#First-classsyntax
01:24:58 <elliott> M.accessor x is ugly.
01:25:03 <elliott> and verbose.
01:25:08 <CakeProphet> I do like this proposal. Except the second syntax form is kind of weird and isn't really needed.
01:25:09 <elliott> M is usually more than one letter :P
01:25:28 <elliott> anyway WHAT WE REALLY NEED IS ML-STYLE MODULES DAMMIT
01:25:42 <CakeProphet> so what's wrong with "accessor x", where the name is resolved by the type of x?
01:27:11 <CakeProphet> > let (=:) x = "test" in (=:) 3
01:27:12 <lambdabot> "test"
01:28:29 <CakeProphet> @hoogle (~)
01:28:29 <lambdabot> Test.HUnit.Base (~:) :: Testable t => String -> t -> Test
01:28:30 <lambdabot> Test.HUnit.Base (~=?) :: (Eq a, Show a) => a -> a -> Test
01:28:30 <lambdabot> Test.HUnit.Base (~?) :: AssertionPredicable t => t -> String -> Test
01:28:31 <elliott> <CakeProphet> so what's wrong with "accessor x", where the name is resolved by the type of x?
01:28:36 <elliott> because unstructured overloading is Scary.
01:28:51 <oerjan> CakeProphet: lazy pattern
01:28:58 <CakeProphet> it's equally structured to x.accessor
01:29:11 <CakeProphet> there's just no sugar.
01:29:23 <elliott> CakeProphet: no, it's not about sugar
01:29:32 <elliott> the .accessor denotes something very important here, it conveys the intent
01:29:46 <oerjan> > case Nothing of ~Just x -> "This will break " ++ x
01:29:47 <lambdabot> <no location info>: Parse error in pattern
01:29:51 <oerjan> erm
01:30:01 <oerjan> > case Nothing of ~(Just x) -> "This will break " ++ x
01:30:04 <elliott> i feel http://r6.ca/blog/20090511T013939Z.html is quite relevant here
01:30:07 <lambdabot> mueval-core: Time limit exceeded
01:30:10 <elliott> even though it's about a more dynamic kind of dispatch than this.
01:30:12 <oerjan> > case Nothing of ~(Just x) -> "This will break " ++ x
01:30:15 <lambdabot> "This will break *Exception: <interactive>:(3,0)-(4,21): Irrefutable patter...
01:30:30 <elliott> oh FUCK NO fly
01:30:35 <elliott> get the FUCK out of this room
01:33:00 <CakeProphet> elliott: I thought it was about structured overloading..
01:33:38 <elliott> CakeProphet: yes but "f x" doing any kind of overloading is Scary :)
01:33:51 <CakeProphet> what's unstructured about "accessor functions are special, can overlap in a namespace, and are resolved by the type of their first argument"
01:34:58 <CakeProphet> scary for the timid, I suppose. It changes absolutely nothing about the semantics. It's purely a syntax thing to convey a smidgeon of extra warning that something (apparently) EVIL is going on.
01:35:00 <elliott> um what? "accessor functions are special"?
01:35:06 <elliott> type-directed name resolution works on /every/ function
01:35:35 <CakeProphet> right, that's what you're defending, I'm defending someting else.
01:36:12 <elliott> guys what does fly poo look like
01:36:16 <elliott> this is important
01:36:23 <CakeProphet> miniscule.
01:36:43 <elliott> ok so this thing on my bed
01:36:45 <elliott> isnt fly poo
01:36:52 <elliott> oh its fluff
01:37:02 <CakeProphet> if it's large enough to cause alarm probably not.
01:40:05 -!- augur has joined.
01:40:21 <CakeProphet> I mean, accessor functions are already special in the sense that they're automatically generated. It would be perfectly reasonable to specialize them a small step further by allowing their names to be disambiguated by first argument. Regular functions don't /need/ type-directed name resolution so they should be excluded.
01:41:09 <CakeProphet> because, yes, unstructured overloading is scary.
01:42:17 <CakeProphet> overloading of record field names is not scary, and is pretty commonly encountered in languages.
01:43:58 <CakeProphet> overloading of the . symbol to be a kind of reversed function application, a means to qualify variable names, and function composion... is pretty scary.
01:44:18 -!- oklopol has joined.
01:46:07 <elliott> back
01:46:16 <elliott> CakeProphet: but dude
01:46:18 <elliott> you can pass accessor functions around
01:46:27 <elliott> treating applications of accessor functions differently to all other functions
01:46:30 <elliott> with the exact same syntax
01:46:33 <elliott> and the exact same naming rules
01:46:38 <elliott> is the most perverse, horrible thing ive ever heard of
01:46:49 <elliott> and goes right against everything i know about the spirit of haskell i.e. no insane non-local shit like that
01:47:09 <elliott> anyway . as composition already needs spaces around it because of module resolution
01:47:16 <elliott> ideally I would prefer some kind of unicode for composition
01:47:19 -!- Sgeo has joined.
01:47:22 <elliott> so that . could be less weird like that
01:47:24 <elliott> but it's like that anyway
01:47:28 <elliott> so we might as well take advantage of it
01:49:12 <elliott> four days without homestuck update :'(
01:50:13 <Sgeo> There isn't going to be a Flash, is there?
01:50:38 <Sgeo> I mean, I'd assume there would be, if not for the fact that the point of Doc Scratch narrating seems to be to prevent it
01:55:18 <elliott> see formspring. no flash till EOA
01:55:46 <Sgeo> The last Bonobo Conspiracy update was July 10, 2010
02:07:12 <elliott> and?
02:11:15 -!- fizzie has quit (*.net *.split).
02:11:16 -!- Wamanuz3 has quit (*.net *.split).
02:11:16 -!- ttm_ has quit (*.net *.split).
02:11:16 -!- Herobrine has quit (*.net *.split).
02:11:16 -!- HackEgo has quit (*.net *.split).
02:11:17 -!- yiyus has quit (*.net *.split).
02:11:24 -!- HackEgo has joined.
02:11:25 -!- Herobrine has joined.
02:11:31 <Sgeo> Just noting that some webcomics are kind of sad in how irregular updates have become, and MSPA hasn't hit that point
02:11:40 -!- yiyus has joined.
02:11:41 -!- Wamanuz3 has joined.
02:11:42 -!- ttm_ has joined.
02:13:35 -!- EgoBot has quit (Remote host closed the connection).
02:13:46 -!- EgoBot has joined.
02:14:08 <elliott> DAMMIT TARSKI
02:15:47 <elliott> Sgeo: so... "some comics are dead -> a comic which has updated as often as twenty-one pages in one day not updating for four consecutive days, despite there being no Flash update coming, is irrelevant"? :p
02:15:57 <elliott> ofc it's not actually a big deal that it hasn't updated, but still
02:16:23 <CakeProphet> elliott: GHC could easily substitute the first argument of the accessor name to be a until the type is known. It doesn't have to resolve it immediately. :)
02:16:31 <elliott> CakeProphet: um how is that relevant
02:17:20 -!- fizzie has joined.
02:17:27 <CakeProphet> elliott: it's relevant because it has nothing to do with insane non-local shit.
02:17:50 <elliott> it is definitely non-local; the semantic definition of "f x" can change just because the definition of f was changed
02:17:53 <elliott> consider that
02:18:13 <elliott> newtype MyMonadStack a = MyMonadStack { runMyMonadStack :: LotsOfTransformers a }
02:18:15 <elliott> is often used but also
02:18:22 <elliott> newtype MyMonadStack a = MyMonadStack (LotsOfTransformers a)
02:18:27 <elliott> runMyMonadStack (MyMonadStack m) = m
02:18:28 <elliott> is used too
02:18:31 <elliott> in similar proportions
02:18:42 <CakeProphet> well fuck 'em.
02:18:46 <elliott> to have this kind of trivial refactoring drastically change the semantics of every function application in another module
02:18:48 <elliott> is completely insane
02:18:49 <elliott> and terrible
02:18:50 <CakeProphet> time to make my Haskell/Perl hybrid.
02:18:54 <elliott> ugh
02:18:57 <elliott> you have terrible taste
02:19:18 <zzo38> How do you make a Haskell/Perl hybrid?
02:19:26 <CakeProphet> carefully.
02:19:41 <elliott> badly
02:19:54 <CakeProphet> hybrid in principle, not in exact semantics, of course.
02:20:00 -!- augur has quit (Remote host closed the connection).
02:25:00 <CakeProphet> functional style (not ncessarily pure), powerful type system, convenient syntactic/semantic constructs, general awesomeness all around.
02:27:17 <elliott> sounds like you want perl 6.
02:28:03 <elliott> tab gc time
02:28:11 <elliott> "Running at only 91.5MHz on an FPGA, the Reduceron is faster than mature bytecode implementations of Haskell running on a 2.8GHz PC." ;; wow, I had no idea things were /this/ good
02:28:36 <elliott> it would be cool if there was some automatic parallelisation stuff going on too with a many-cored graph reducer...
02:29:05 <elliott> hmm, "bytecode implementations"
02:29:09 <elliott> I wonder if that's excluding GHC?
02:29:18 <CakeProphet> yes
02:29:24 <elliott> are you sure?
02:29:26 <CakeProphet> considering that GHC isn't a bytecode implementation..
02:29:34 <elliott> ghc has a few stages which could be described as similar to bytecode
02:30:03 <CakeProphet> well, that's probably not what they mean, in the context of final state execution.
02:30:09 <CakeProphet> s/state/stage/
02:30:15 <elliott> oerjan I think knows more than me, but spineless tagless g-machine?
02:31:50 <elliott> ah:
02:31:51 <elliott> On average, the Wide Reduceron (on FPGA) outperforms the Reduceron,
02:31:51 <elliott> Yhc, and Nhc98 bytecode interpreters (on PC). All of these implementations
02:31:51 <elliott> share a common frontend, so each interpreter runs the same core Haskell programs.
02:32:14 <elliott> "The leading native-code compiler GHC performs many advanced optimisations. For example, GHC spots that the critical safe function in Queens is
02:32:14 <elliott> strict, so need not be instantiated on the heap. Similar optimisations might be
02:32:14 <elliott> used in a future Reduceron implementation, but architectural changes would be
02:32:16 <CakeProphet> Hugs is bytecode right?
02:32:19 <elliott> times slower than GHC -O2 (on PC)."
02:32:21 <elliott> no, hugs is a straight interpreter
02:32:23 <elliott> still
02:32:31 <elliott> 4.85 slower than GHC with -O2
02:32:31 <elliott> is
02:32:32 <elliott> really impressive
02:32:41 <elliott> because the Reduceron is an /FPGA/ running at 91.5MHz...
02:33:04 <CakeProphet> so a modest improvement in hardware should make it run faster I'd think.
02:33:16 <elliott> yes, although investing into getting such optimisations working would be a more productive use of time
02:33:27 <CakeProphet> yeah.
02:33:36 <elliott> brute force doesn't usually scale :)
02:34:06 <CakeProphet> unless you have elastic super powers.
02:34:22 <elliott> i should ask ais about fpgas again.
02:34:25 <CakeProphet> then you can scale to whatever you please..
02:34:33 <elliott> or Vorpal, he's done some stuff with them iirc.
02:34:53 <elliott> they are just so expensive, though :(
02:36:41 <oerjan> doesn't ghci use a bytecode backend
02:36:49 <elliott> http://www.altera.com/products/devkits/altera/kit-cyc3-starter.html ;; bet this is shit
02:36:57 <elliott> cheap though
02:37:20 <elliott> and seemingly their highest-end "starter kit" (i.e. thing anyone could ever hope to afford)
02:37:33 * elliott checks xilinx
02:37:42 <elliott> (fucking duopolies)
02:38:06 <elliott> gah, xilinx's site is user-hostile
02:38:50 <elliott> JESUS I JUST WANT SOMETHING ORDERED BY PRICE
02:38:56 <elliott> hate you hate you hate you
02:39:35 <elliott> Atlys Spartan-6 FPGA Development Kit$349
02:39:35 <elliott> ($199 for academic customers)A complete, ready-to-use development platform based on a Xilinx Spartan-6 LX45 FPGA, the Atlys kit features high-end peripherals and is an ideal host for complete digital systems built around embedded processors like Xilinx’s MicroBlaze.
02:39:35 <elliott> Spartan-6 FPGA SP605 Evaluation Kit$495Conveniently delivers all the basic components for developing cost and power-sensitive applications that require transceiver capabilities in one package.
02:39:41 <elliott> stab my eyes out
02:40:06 <elliott> i kind of want to try the reduceron but im not paying hundreds of pounds more for something that is compatible with the reduceron toolchain :D
02:40:29 <elliott> Clocking
02:40:29 <elliott> 50-MHz on-board oscillator
02:40:36 <elliott> ok so it's about half as fast as the one the reduceron guys used i guess
02:41:25 <elliott> ok they used Virtex-5 it seems
02:41:46 <elliott> oh my fuck xilinx site
02:41:47 <elliott> i hate your shits
02:42:57 <CakeProphet> elliott: start a t-shirt business.
02:43:01 <elliott> what
02:43:06 <CakeProphet> find trendy things to make t-shirts about. profit.
02:43:36 <CakeProphet> especially obscure trendy nerdy things. Read xkcd for ideas.
02:44:01 <elliott> id rather stab my eyes out
02:44:12 <CakeProphet> but you can't make money from that!
02:44:20 <elliott> fuck you i can do whatever i want
02:45:06 <CakeProphet> your reduceron isn't going to be much use if you can't write Haskell programs because you don't have any ideas.
02:45:12 <elliott> ideas for what
02:45:17 <CakeProphet> s/ideas/eyes/ :P
02:45:24 <elliott> anyway i don't want a reduceron well i mean i do but
02:45:28 <elliott> i mostly want to write my OWN SHIT YEAAAAAAAH
02:45:38 <elliott> dont tell anyone that im essentially talentless and unmotivated
02:46:00 <CakeProphet> hey you can write a wc shortcut faster than me.
02:46:20 <elliott> that's just because i have a functioning brain ;DDDDDD
02:47:13 <CakeProphet> hey, that's not nice.
02:47:31 <elliott> im sorry can yo ufind it in ur hert.... to forgive me.........
02:48:05 <CakeProphet> ..no? asshole.
02:50:59 <elliott> ok
02:51:59 * elliott cry
02:52:46 -!- elliott has set topic: hurt feelings on irc: the game | | Logs: http://codu.org/logs/_esoteric/ and http://tunes.org/~nef/logs/esoteric/?C=M;O=D.
02:52:47 <elliott> * Topic for #esoteric set by elliott!~elliott@unaffiliated/elliott at Tue Jun 7 19:36:45 2011
02:52:54 <elliott> wtf happened there
02:53:03 -!- elliott has set topic: hurt feelings on irc: the game | Logs: http://codu.org/logs/_esoteric/ and http://tunes.org/~nef/logs/esoteric/?C=M;O=D.
02:53:48 <CakeProphet> elliott: must have been a server glitch.
02:54:03 <elliott> or a bad copy-paste.
02:54:12 <CakeProphet> what? never.
02:54:42 <oerjan> always use fresh paste when copying
02:55:26 <CakeProphet> Always kill it before you yank it.
02:56:38 <elliott> gross gross
02:57:11 <CakeProphet> you know nothing of my work.
02:59:48 <CakeProphet> so I decided for my regexp language it would be a good idea to not make bare symbols means "match this character", which makes things a lot easier when trying to specify a complex language of any sort.
03:00:31 <CakeProphet> so you use quotes to match literal strings of text. *(capturename = "literalstring")
03:00:43 <CakeProphet> I also decided to make * and friends prefix, because that's how I roll.
03:01:20 <CakeProphet> also () doesn't implicitly capture to a numeric group because that's lame when you can just assign to variables.
03:02:23 -!- Lymia has quit (Ping timeout: 276 seconds).
03:04:04 -!- elliott has quit (Remote host closed the connection).
03:04:56 -!- elliott has joined.
03:06:16 <elliott> whos a...
03:06:29 <elliott> <cakeproophet> i dunno
03:06:50 <CakeProphet> ...whut?
03:06:53 <elliott> ar
03:07:21 <CakeProphet> should I attempt to call an ambulance?
03:08:33 <Sgeo> I'm going to take a Benadryl and a melatonin. If anything bad happens, blame my dad who claims he gives that to his patients all the time
03:08:48 <CakeProphet> absolutely nothing bad will happen.
03:09:27 <elliott> CakeProphet: wtf are you talking about
03:09:30 <elliott> thats a fatal dose
03:09:31 <elliott> jesus Sgeo
03:09:33 <elliott> get to a fucking hospital
03:09:37 <CakeProphet> you can take a whole bottle of melatonin tablets and be fine.
03:09:46 <CakeProphet> elliott: what the fuck were /you/ talking about?
03:10:09 <elliott> CakeProphet: JESUS CHRIST do you KNOW what benadryl and melatonin fucking do together?
03:10:16 <elliott> Sgeo trust me please jesus christ get to a hospital
03:10:22 <elliott> you could die
03:12:21 <elliott> its funny because sgeo is actually on his way right now
03:14:15 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
03:15:18 <Sgeo> If I were to say I took 8 pills of Tylenol, how would elliott actually attempt to tell me that that's bad, given that he pretends things like this are bad
03:15:27 <Sgeo> (this==benadryl + melatonin)
03:15:53 <zzo38> It is bad. It is as bad as anything else.
03:16:27 <CakeProphet> no... not really.
03:16:29 <elliott> Sgeo: guess what
03:16:39 <CakeProphet> there are definitely different levels of bad in relation to drugs.
03:16:40 <elliott> Sgeo: i am not here to tell you what cocktail of deadly drugs will or will not end your life
03:16:57 <CakeProphet> Sgeo: actually I believe you would also survive 8 tylenol as well.
03:17:03 <myndzi> is this a complicated troll or ignorance at work? i can't tell!
03:17:04 <elliott> im sorry ive not yet explained to you... but this is not...... an internet doctor..........
03:17:13 <elliott> myndzi: what, Sgeo?
03:17:17 <myndzi> i had to go check out the details of tylenol to be sure i wasn't misremembering
03:17:19 <myndzi> lol yes
03:17:27 <Sgeo> Erm, 16 tylenol then
03:17:31 <myndzi> "if i take a bunch of tylenol i bet that's not bad either!!!"
03:17:36 <elliott> myndzi: no he just doesn't have any kind of built-in reaction to making a fool of himself in public
03:17:43 <Sgeo> myndzi, I didn't say that
03:17:56 <elliott> it appears to be unrectifiable
03:18:10 <CakeProphet> most lethal concoctions of drugs will result in you vomiting and thus surviving. If you really want to kill yourself with drugs the best way is to also take an anti-vomiting agent (there is a fancy term for it but I can't remember the name)
03:18:23 <myndzi> lol
03:18:24 <elliott> CakeProphet: erm tylenol is paracetamol is it not?
03:18:32 <myndzi> or take one bullet to the head every hour until success
03:18:35 <Sgeo> I know Tylenol is dangerous, I'm just saying if I didn't, what would elliott say if I said I was taking it?
03:18:35 <elliott> so actually, a bunch of them is an excellent way to kill yourself
03:18:39 <CakeProphet> elliott: er, no.
03:18:48 <myndzi> Sgeo: probably that it was dangerous?
03:18:49 <CakeProphet> acetominophen
03:18:53 <CakeProphet> *aceta
03:18:55 <myndzi> same thing
03:18:58 <elliott> Sgeo: i think there would be more obvious signs that you were fucked
03:19:01 <elliott> CakeProphet: um that's another name for paracetamol
03:19:07 <CakeProphet> oh, well then yes. :)
03:19:13 <myndzi> every drug has TWO NAMES!
03:19:21 <elliott> CakeProphet: well that's actually quite a large cause of death
03:19:22 <Sgeo> myndzi, unless it has 3
03:19:23 <myndzi> because it's awesome that way
03:19:26 <elliott> it just takes ages
03:19:28 <elliott> and is really painful
03:19:34 <elliott> i don't think you just vomit it up
03:20:05 <myndzi> eh, i think most over the counter stuff that is dangerous includes things to make you puke if you take too much
03:20:09 <CakeProphet> well, okay, 16 tylenol MIGHT kill you. But most suicide attempts with medicine fail for that reason.
03:20:10 <myndzi> or something like that
03:20:26 <elliott> CakeProphet: right, but actually paracetamol is one of the exceptions, overdoses are _really_ bad
03:20:38 <elliott> CakeProphet: there's a bunch of stories of suicidal people taking a bunch of paracetamols as a cry for help
03:20:48 <elliott> CakeProphet: get woken up from unconsciousness hours later
03:20:55 <elliott> CakeProphet: told to call their family because they're going to die slowly and painfully
03:21:02 <CakeProphet> lovely.
03:21:05 <elliott> totally
03:21:33 <Sgeo> Maybe I just don't have a reaction to making a fool of myself in here?
03:21:34 <elliott> moral: always try to suicide with something harmless like ibuprofen
03:21:39 <CakeProphet> man, if I ever kill myself, I will know exactly what I'm doing. I have this shit down.
03:21:51 <elliott> (ok ibuprofen overdoses can do some bad shit but it's not going to be that bad)
03:21:52 <CakeProphet> I will most certainly die as a result.
03:22:01 <elliott> Sgeo: you mean we alone have to experience this shit??
03:22:02 <elliott> FUCK
03:22:06 <elliott> where did we go wrong
03:22:45 * CakeProphet makes a fool of himself on #esoteric quite often.
03:23:04 <CakeProphet> we are all fools.
03:23:08 <CakeProphet> except maybe oerjan.
03:23:16 <CakeProphet> he's got a ph.d and shit.
03:24:47 <coppro> elliott: itym N-(4-hydroxyphenyl)ethanamide
03:24:55 <pikhq_> CakeProphet: BTW, a normal dosage of Tylenol can actually cause liver failure in rare cases; it's *very* close to the lethal dose.
03:25:13 <elliott> coppro: go fuk urself
03:25:15 <pikhq_> Tylenol, BTW, is the leading cause of liver failure.
03:25:19 <CakeProphet> pikhq_: good to know.
03:25:21 <pikhq_> Not drinking. Tylenol.
03:25:26 <pikhq_> It is *fucking scary shit*.
03:26:01 <coppro> pikhq_: doesn't help that it's in a lot of non-tylenol drugs
03:28:16 <pikhq_> Yup.
03:30:42 <elliott> pikhq_ you also get a free Perfect Computer
03:30:48 <elliott> that makes my cost-free receiver list: oerjan, pikhq
03:31:25 * pikhq_ barfs some more at gnulib's usage
03:32:20 <elliott> "
03:32:21 <elliott> A notable feature of our new design is that each of its six
03:32:21 <elliott> semantic reduction rules is performed in a a single-clock cycle. All
03:32:21 <elliott> the necessary memory transactions required to perform a reduction
03:32:21 <elliott> are done in parallel. The Reduceron performs on average 0.55
03:32:23 <elliott> hand-reductions per clock-cycle. A hand-reduction is a reduction
03:32:25 <elliott> that programmer would perform in by-hand evaluation trace of a
03:32:27 <elliott> program; it includes function application and case analysis, but not
03:32:29 <elliott> machine-level reductions such as updating and unwinding."
03:32:56 <pikhq_> A function to *concatenate file names* ends up pulling in basically a reimplementation of stdio.h.
03:33:16 <pikhq_> That's it. I give up on GNU. It is the worst software.
03:33:26 <elliott> http://esolangs.org/wiki/Brainfuck#External_resources
03:33:27 <elliott> sigh
03:33:32 <coppro> pikhq_: serious question.
03:33:36 <elliott> pikhq_: oh man i totally want you to meet your few-years-ago self
03:33:41 <coppro> pikhq_: would you help write a libc?
03:34:01 * elliott predicts the answer: "yes if musl didn't already exist"
03:34:09 <pikhq_> coppro: No, but only because there is already a libc I find entirely satisfactory, modulo a small handful of missing bits.
03:34:13 <coppro> k
03:34:15 <elliott> i was riiiiiiight
03:34:17 <pikhq_> musl!
03:34:19 <elliott> coppro: why did you ask?
03:34:28 <coppro> elliott: I may be writing a libc
03:34:44 <elliott> coppro: for what purpose?
03:34:46 -!- augur has joined.
03:34:54 <coppro> elliott: LLVM project
03:35:02 <elliott> coppro: why are existing libc unsuitable?
03:35:04 <elliott> legit question
03:35:20 <pikhq_> If only PCC could build Busybox and Linux. Then, I could have a GNU-less system up and running easily.
03:35:32 <coppro> pikhq_: clang?
03:35:32 <pikhq_> Though, there is rather a lot of GTK software. Ah well.
03:35:35 <elliott> pikhq_: pcc kind of sucks though.
03:35:39 <elliott> also, you'd still need binutils
03:35:44 <coppro> elliott: musl is unsuitable due to GPL.
03:35:51 <pikhq_> coppro: musl is not GPL.
03:35:58 <elliott> coppro: musl is not GPL
03:36:04 <coppro> sorry, lpgl
03:36:04 <pikhq_> elliott: Clang needs a C++ library.
03:36:05 <coppro> *gpl
03:36:10 <coppro> pikhq_: it has one
03:36:11 <elliott> coppro: why does lgpl make it unsuitable?
03:36:12 <coppro> mostly complete
03:36:17 <coppro> elliott: LLVM project is BSD
03:36:20 <elliott> coppro: and?
03:36:28 <elliott> coppro: why does LLVM need to integrate musl?
03:36:29 <pikhq_> elliott: Would you like a list of C++ libraries that can bootstrap?
03:36:35 <elliott> pikhq_: what?
03:36:49 <elliott> coppro: I'm not sure how the license is a problem here, or anything
03:36:50 <pikhq_> elliott: GNU's. That's it. There are no other suitable free C++ libraries.
03:37:02 <pikhq_> Though LLVM's is at least getting there.
03:37:03 <elliott> pikhq_: it was coppro who mentioned that llvm has a c++ library, not me
03:37:05 <coppro> pikhq_: I believe libc++ can do so on Mac
03:37:06 <coppro> not sure though
03:37:15 <tswett> oklopol: hey, we agreed to meet up some time in 2014, didn't we? I think I lost the plan.
03:37:31 <pikhq_> Presently, though, you need GNU to get clang working.
03:37:37 <coppro> elliott: because the LLVM project can't have a libc that is LGPL, since it's a BSD-licensed project... what's so hard to understand?
03:37:42 <coppro> pikhq_: You need a C++ compiler
03:37:47 <CakeProphet> <a>**<i> := a*(ia); *. ** "|" #awww yeah
03:37:49 <elliott> coppro: Why does musl need to be "part" of the LLVM project?
03:37:49 <coppro> it's perfectly capable of compiling itself
03:37:51 <pikhq_> Hence why I care about PCC *at all*. PCC can bootstrap, very quickly.
03:37:52 <elliott> coppro: I do not understand.
03:38:01 <pikhq_> coppro: Yes, except for the need for a C++ library.
03:38:18 <coppro> elliott: k
03:38:24 <elliott> coppro: that was a request for clarification
03:38:35 <coppro> pikhq_: Suppose that it compiled and worked under libc++
03:38:43 <coppro> which is not that far off on Linux
03:38:44 <elliott> like... I don't expect the pcc team to suddenly announce "We're importing uClibc!"
03:38:54 <elliott> idgi, why does the fact that LGPL is not the same license as LLVM matter
03:38:59 <elliott> what's the goal
03:39:03 <pikhq_> coppro: If libc++ worked on musl, or could be ported easily, then I would be entirely satisfied with clang.
03:39:15 <pikhq_> Except for the simple fact that Linux doesn't build yet...
03:39:19 <coppro> pikhq_: It's supposed to be as C-library agnostic as possible
03:39:23 <coppro> pikhq_: Enough of Linux builds
03:39:27 <pikhq_> Which I think is the only major thing that *doesn't*.
03:39:28 <zzo38> While I have no complaint if you use BSD-license, I do not want to use BSD-license for my own projects. (Although I make some projects in the public domain, which is compatible with BSD-license so it isOK)
03:39:49 <pikhq_> coppro: So, in short, clang is still a WIP, but it is *very very close*.
03:39:55 <coppro> pikhq_: there are some issues with parts of the C++ library being unimplementable on top of a purely standard C library, though
03:40:01 <pikhq_> elliott: I suspect LLVM is attempting an embrace/extend/extinguish on GNU's build chain.
03:40:11 <pikhq_> coppro: Hence why I said "or could be ported easily".
03:40:19 <elliott> pikhq_: we will never know, since coppro has apparently decided he doesn't want to answer me any more
03:40:25 <coppro> pikhq_: is musl posix-compliant?
03:40:36 <pikhq_> coppro: Not quite, but nearly so.
03:40:40 <coppro> if so, the required facilities are logical extensions
03:40:42 <coppro> in locale
03:40:55 <zzo38> What is musl and clang and these things?
03:40:57 <coppro> in particular, if every locale-aware function has an _l version, I think it's good
03:41:25 <coppro> if musl already has _l functions, adding them to the others is a fairly straightforward transformation
03:41:35 <coppro> possibly even something clang could do automagically
03:41:50 <pikhq_> I'm pretty sure it does, though its locale support is somewhat anemic.
03:41:53 <elliott> coppro: are you actually going to answer my simple question...? i'm actually curious.
03:41:56 <pikhq_> It supports C.UTF-8 as its locale.
03:42:08 <coppro> pikhq_: not just "C"?
03:42:08 <pikhq_> Yeah, it has _l functions.
03:42:19 <pikhq_> coppro: Nope, it's very specifically UTF-8.
03:42:27 <pikhq_> Because ASCII is old and retarded.
03:42:30 <coppro> pikhq_: that's non-compliant :/
03:42:43 <pikhq_> And a very minor issue.
03:42:48 <coppro> or well it is if it doesn't support "C"
03:42:56 <elliott> coppro: are you /ignoring me
03:42:58 <coppro> if it just has "C.UTF-8" as the default, no issues
03:42:59 <coppro> elliott: no
03:43:17 <zzo38> ASCII is not retarded.
03:43:18 <coppro> elliott: I think e/e/e is a bad way of putting it, but is effectively the goal
03:43:31 <coppro> given that GNU has already actually e/e/ed the build chain
03:43:31 <elliott> coppro: why not just endorse musl?
03:43:35 <elliott> it is pointless to duplicate work
03:43:48 <coppro> elliott: because Apple, the main sponsors, want BSD
03:43:51 <elliott> and I don't think even Apple would object to an LGPL libc, though of course they won't likely be switching because they're BSD
03:44:15 <pikhq_> "The default locale is named C.UTF-8 and has all the required properties of the C or POSIX locale, plus UTF-8 semantics for high bytes. Collation is plain codepoint-order, and character classes are based on Unicode."
03:44:19 <pikhq_> Okay, there we go.
03:44:39 <coppro> ah ok
03:44:42 <coppro> that's fine then
03:44:47 <coppro> and not relevant to the C++ stuff
03:44:50 <elliott> coppro: well if the justification is just "Steve Jobs wants us to duplicate the large amount of work that goes into creating a conformant, fast, lightweight libc because he's being unreasonable about licenses", then who the hell would want to devote time to that??
03:45:24 <zzo38> But what if you are using a single-byte encoding and do not want UTF-8? Then there might be some problem. I think UTF-8 already has the feature that sorting using normal strcmp can still work with Unicode
03:45:33 <coppro> elliott: Well they have their own libc so it's actually irrelevant to them directly
03:45:38 <pikhq_> Seems that what it's missing is some C99 math functions, *perhaps* a few wide character interfaces, POSIX priority scheduling options, and stuff added in POSIX 2008.
03:45:45 <coppro> crud
03:45:48 <coppro> locale_t was 2008
03:45:59 <elliott> pikhq_: musl has some oh-eight stuff
03:46:05 <pikhq_> coppro: What header would it be in? I can check.
03:46:05 <elliott> coppro: precisely... so I don't see the need to do anything more than endorse musl.
03:46:12 <elliott> coppro: it just sounds like completely duplicated work.
03:46:13 <coppro> pikhq_: locale.h; possibly xlocale.h
03:46:19 <coppro> elliott: the simplest answer is that LLVM wants a complete toolchain. LLVM is BSD-license
03:46:31 <coppro> it would make no sense to add some LGPL stuff to it
03:46:34 <pikhq_> It has locale_t.
03:46:35 <elliott> coppro: ok, so "we're being pointlessly anal about licenses, and we want to NIH things"
03:46:39 <coppro> of course it's goddamn duplicated work
03:46:42 <coppro> that's why GPL sucks
03:46:48 <elliott> coppro: IT'S LGPL
03:46:55 <coppro> elliott: s/GPL/copyleft/
03:46:56 <coppro> sorry
03:46:57 <elliott> GPL is unacceptable for licenses
03:46:58 <elliott> LGPL isn't
03:47:11 <elliott> coppro: LGPL isn't copyleft in the "bad" sense because _it doesn't affect linkers_
03:47:22 <coppro> elliott: it's not absurd copyleft
03:47:34 <coppro> but it makes no sense from the LLVM project's perspective either
03:47:41 <elliott> come on, it is absolutely ridiculous for LLVM to want to duplicate a massive amount of effort because "we want a COMPLETE toolchain (for no reason) under this SPECIFIC license (because of our egos)"
03:47:43 <coppro> suppose someone is considering using LLVM
03:47:49 <elliott> pointless waste of time
03:47:49 <coppro> but then they see that it's LGPL
03:47:53 <coppro> and they don't do LPGL code
03:47:56 <coppro> well shit
03:48:01 <pikhq_> Anyways, musl is a libc I'm actually happy with on a technical basis.
03:48:03 <elliott> wow you're... actually making less than 0 sense.
03:48:04 <coppro> lots of corporate users won't touch any GPL
03:48:17 <elliott> coppro: lots of corporate users aren't exactly going to switch out their libc
03:48:18 <coppro> elliott: you have not worked in the software industry
03:48:18 <pikhq_> I *actually understand how the damned thing works*.
03:48:28 <coppro> elliott: you'd be surprsied
03:48:30 <coppro> *surprised
03:48:57 <pikhq_> elliott: The corporate world runs around Windows. Each compiler has its own libc there. Any further questions?
03:49:00 <elliott> coppro: ok... so "we're going to duplicate a massive amount of work for (a) our egos (b) so that a few corporate idiots will be happy"? Is anyone not using LLVM right now because it doesn't have its own libc?
03:49:14 <elliott> "Oh, I was going to use LLVM, but it doesn't have a graphical display server? Skip it."
03:49:19 <coppro> elliott: Not AFAIK, but the project would like to provide that and I agree with that idea
03:49:28 <coppro> elliott: also, duplicated work is not all bad in this instance
03:49:39 <elliott> I still haven't heard a single good reason for llvm to provide a libc
03:49:40 <coppro> if there are more viable options, e/e/e is less likely to happen
03:49:46 <pikhq_> Anyways, I'm certainly uninterested in writing a libc when there's a perfectly *great* one already around.
03:49:49 <coppro> elliott: because why not?
03:49:52 <coppro> pikhq_: k
03:50:01 <elliott> coppro: because why not?
03:50:08 <elliott> by that logic LLVM should provide a complete fucking OS and application set
03:50:26 <coppro> elliott: why does LLVM provide a C compiler?
03:50:33 <coppro> clearly that's not part of the project
03:50:36 <elliott> coppro: because it's a compiler project.
03:50:39 <coppro> no
03:50:42 <coppro> it's a compiler backend project
03:50:52 <elliott> it obviously isn't
03:51:05 <elliott> whatever, i'm done with this conversation, it has reached heights of stupidity I thought impossible
03:51:09 <coppro> k
03:51:42 <coppro> pikhq_: please go extend every locale aware function to have one with an _l suffix that takes a locale_t
03:51:49 <coppro> (if it already has _s, make it _sl)
03:52:18 <pikhq_> What are the locale-aware functions, anyways?
03:52:37 <coppro> any function that is defined in the C spec to alter its behavior when the locale changes
03:53:06 <zzo38> If LLVM becomes with many good things than GNU, then maybe it will be good thing idea to use.
03:53:09 <coppro> there is going to be a paper to this effect in front of the C committee at some unspecified time in the future
03:54:37 <pikhq_> zzo38: Already, it's generally got a better toolchain than GNU...
03:54:48 <pikhq_> coppro: What, incidentally, are the chances of binutils being replaced?
03:55:09 <coppro> pikhq_: high
03:55:22 <elliott> coppro: to what effect?
03:55:24 <coppro> pikhq_: there's already an integrated assembler on some platforms
03:55:42 <zzo38> pikhq_: Does it optimize? There are some features of GNU that should be used, such as, being able to declare array with [0] is good thing I think
03:55:47 <coppro> elliott: 23:51 < coppro> pikhq_: please go extend every locale aware function to have one with an _l suffix that takes a locale_t
03:55:53 <elliott> oh
03:56:09 <coppro> zzo38: The optimizer is not quite as good as GCC's yet, but it has other advantages
03:56:16 <coppro> like having a compiler that doesn't suck
03:56:19 <elliott> coppro: you know, it might be worth contacting eta labs about relicensing and integrating musl.
03:56:36 <elliott> maybe unlikely, but a better use of time than writing yet another libc when a very good one has just recently been created.
03:56:59 <coppro> pikhq_: not sure what will happen to the ELF linker
03:57:20 <coppro> pikhq_: in theory it's unnecessary as you could create a platform where all libraries are linked in bitcode form
03:57:35 <pikhq_> elliott: At present, most of the locale-aware functions only look at the globally stored locale. That is, a global variable that needs to have a lock over it in a large number of functions.
03:57:39 -!- Sgeo has quit (Ping timeout: 255 seconds).
03:57:54 <zzo38> coppro: Yes, as long as they do not change the license so that it is no longer acceptable, then it should be OK.
03:58:02 <pikhq_> coppro: True, there is the llvm-ld.
03:58:29 <coppro> more importantly, C++ needs thread-safe access to those functions in specific locales and cannot do so because it can't lock them unless it just pauses every other thread
03:58:51 <pikhq_> Also, the optimizer may not be *quite* as good as GCC, but it is *definitely* good enough for general use.
03:58:55 <coppro> yeah
03:59:09 <pikhq_> Actually, I'd even call pcc's good enough for general use, and that's not as good as LLVM.
03:59:18 <zzo38> GCC is very slow. Is LLVM faster?
03:59:42 <zzo38> Is it less messy than GNU programming?
03:59:42 <pikhq_> zzo38: Yes, clang's something like 3 times faster.
03:59:55 <pikhq_> I actually can understand LLVM source code.
04:00:10 <CakeProphet> can't wait for Diablo 3.
04:00:18 <CakeProphet> it must surely be as epic as Starcraft 2.
04:00:20 <pikhq_> It's not exactly elegant, but it's actually readable by humans.
04:00:31 <zzo38> pikhq_: Then I suppose those things do help.
04:01:44 <Patashu> declare an array with [0]?
04:01:48 <Patashu> why would you ever do that
04:02:20 <CakeProphet> obfuscation of a pointer, perhaps.
04:02:48 <pikhq_> Patashu: It's a GNUism for indicating that at the end of a structure is a dynamically allocated array.
04:02:58 <Patashu> oh? hmm, okay
04:03:16 <pikhq_> There's a different means of doing it in C99, and so [0] is a deprecated GNU extension.
04:03:39 <coppro> LLVM uses that pattern in C++ without a standard syntax
04:05:49 <pikhq_> Oh, wow. Apparently current SVN checkouts of clang builds pretty much all of Linux.
04:06:16 <pikhq_> And the integrated assembler works, making it so that the only GNU thing needed ATM to build Linux is GNU ld.
04:06:30 -!- Lymia has joined.
04:07:21 <coppro> yeah
04:07:31 <coppro> I wasn't sure if the integrated assembler was that mature
04:07:33 <coppro> but apparently it is
04:08:38 <elliott> it'd be cool to have a fully clang/musl system
04:09:06 <pikhq_> Surprisingly, it's not that far off.
04:09:14 * elliott plays around with this modular synthesiser
04:09:23 <pikhq_> I think all that's needed is LLVM's libc++...
04:10:18 <coppro> pikhq_: get on it then
04:10:33 <elliott> pikhq_: C++ is irrelevant
04:10:39 <elliott> at least for a basic Linux system.
04:10:52 <pikhq_> elliott: clang itself needs C++, though.
04:11:07 <elliott> oh right
04:11:13 <elliott> ugh
04:11:16 <elliott> someone should fix that :p
04:20:30 <zzo38> I think using [0] makes more sense than the C99 way, actually.
04:20:57 <elliott> this is fun
04:21:02 <elliott> zzo38: seriously?
04:21:04 <elliott> [0] makes more sense than []?
04:22:44 <zzo38> elliott: Yes. Since, in a structure, the size of the structure when measuring, is only the part before that array. So, you put [0] to mean its sizeof measures 0 and when added to everything else, you can then add to sizeof, the number of elements and malloc, you can do it. And it should be allowed [0] anywhere in a structure, not necessarily at the end (but most commonly use at the end).
04:22:51 <pikhq_> Wow. GCC can be bootstrapped with a non-GCC compiler.
04:22:54 <pikhq_> Clang.
04:23:09 <zzo38> At least to me, it makes mathematical sense.
04:23:40 <coppro> pikhq_: EDG's been doing it for years, but it's proprietary
04:24:17 <pikhq_> It's kinda sad that it's notable when a compiler builds GCC.
04:24:35 <pikhq_> It seems like the sort of package you'd want to be able to build on anything that's no completely crazy.
04:24:38 <pikhq_> s/no/not/
04:24:47 -!- oerjan has quit (Quit: Good night).
04:24:54 <coppro> no, that would make it too easy for people to infect it with proprietary software
04:24:56 <zzo38> In TeXnicard, I have used a [0] array in a union.
04:25:04 <coppro> or use it on systems where proprietary software is known to lurk
04:25:07 <coppro> zzo38: you're a bad person
04:25:42 <pikhq_> coppro: ... Which you generally can do, because GCC until very recently has been effectively the only compiler not from Microsoft.
04:25:51 <zzo38> coppro: Why do you think I am a bad person?
04:26:12 <coppro> pikhq_: not at all true
04:26:29 <pikhq_> (I'm discounting the proprietary UNIX vendor's C implementations, because, well, you can discount everything else from them.)
04:26:44 <coppro> pikhq_: are you familiar with EDG?
04:26:51 <pikhq_> Oh, right, EDG.
04:27:04 <zzo38> It also uses sizeof(struct{...})
04:27:21 <pikhq_> zzo38: That's entirely valid.
04:27:27 <coppro> if a little evil
04:27:30 <pikhq_> A bit weird, but entirely valid.
04:27:43 <pikhq_> If a C compiler doesn't handle that, it's a pretty big bug.
04:27:48 <coppro> yeah
04:28:06 <coppro> hrmhrmhrm
04:28:37 <zzo38> pikhq_: Yes I know that, and I have it being used in some macros for allocating nodes.
04:28:52 <coppro> goddamn it
04:29:19 <zzo38> Why is it "a little evil"?
04:29:27 <pikhq_> Anyways, it seems to me that you'd really *want* for a C compiler to be able to at least build on any ISO C89 platform.
04:29:36 <coppro> pikhq_: C99
04:29:41 <coppro> let's not bury ourselves in the past
04:29:55 <pikhq_> If not anything supporting K&R...
04:30:11 <coppro> god no
04:30:20 <pikhq_> coppro: The idea being to allow you to get a sane C environment up and running on anything.
04:30:22 <CakeProphet> So, is switching everything over to prefix/infix instead of the traditional prefix/postfix for regular expressions going to freak anyone out?
04:30:27 <zzo38> If you use [0] to allocate an array then the compiler should just do the same things as if a positive number is in there, it would make most sense, at least to me.
04:30:27 <pikhq_> Rather than being stuck with retardedly old shit.
04:30:31 <CakeProphet> er *infix/postfix
04:31:09 <pikhq_> coppro: I don't care if you pull this off by just building a retardly simple compiler to build the rest of the thing, BTW.
04:31:22 <pikhq_> (for an example of something "retardly simple", see TCC)
04:36:24 * elliott wonders if SmallBug will freakout on us for being so ~rude~
04:37:14 <pikhq_> Incidentally, it'd be *really* awesome to have a full, tiny UNIX building with TCC. :P
04:37:42 <pikhq_> Not as a serious thing, but y'know, just as a toy. An OS with every bit understandable...
04:37:45 <elliott> pikhq_: well it can build a modified kernel...
04:37:51 <elliott> linux that is
04:37:51 <pikhq_> ... I'm describing Minix, aren't I.
04:37:57 <pikhq_> elliott: That was 2.4.
04:38:41 <elliott> pikhq_: so? :P
04:38:55 <elliott> also, minix is a microkernel, which is probably not an aid to having a really small understandable system
04:39:01 <zzo38> No! You have to make a book. Such as, write the operating system with CWEB. And then sell the book with the DVD in the back cover.
04:39:08 <pikhq_> elliott: Minix is entirely intended as a small, understandable system.
04:39:26 <pikhq_> It's also a textbook.
04:39:38 <elliott> pikhq_: yes but that doesn't mean it succeeds.
04:39:40 <elliott> zzo38: -_-
04:40:25 <zzo38> elliott: _-_
04:40:31 <pikhq_> elliott: Your criticism of microkernels probably comes from how fucked up HURD is...
04:41:07 <elliott> pikhq_: No, I'm just saying that if you want a self-contained, tiny system, a microkernel is probably an impediment to that
04:41:15 <elliott> It's abstraction designed to make something easy that you don't want to do (extend the system)
04:41:22 <pikhq_> Aaah.
04:43:47 <CakeProphet> Screw microkernals, I run on this: http://www0.us.ioccc.org/2004/gavin.c
04:44:18 <pikhq_> I specified "UNIX" for a reason. :P
04:44:33 <elliott> it would be fun to golf a unix kernel (not golf as in raw bytes or lines of code, but)
04:44:55 <elliott> unfortunately, question is, define Unix
04:44:59 <elliott> something that can run bash?
04:45:12 <elliott> that means running a pretty GNU-compatible libc
04:45:18 <elliott> pdclib won't cut it
04:45:21 <elliott> (probably)
04:45:37 <elliott> tcc implies ELF
04:45:47 <elliott> but doesn't tcc also depend on linux somehow? dunno
04:45:50 <CakeProphet> implies implies implies
04:46:00 <elliott> (are the ELF headers linux-only?)
04:46:39 <pikhq_> The ELF headers aren't Linux-only; they *should* exist in the same place on all ELF platforms.
04:47:00 <elliott> writing a filesystem would be fun
04:47:12 <pikhq_> And there's rather a lot of ELF platforms...
04:47:48 <elliott> even though I'm not quite sure how filesystems work :(
04:48:00 <pikhq_> Such as "every non-Microsoft console since 2000". :P
04:48:26 <pikhq_> elliott: Filesystems are really, truly nothing special.
04:48:37 <elliott> i know
04:48:45 <elliott> but like HOW DO YOU APPEND A DIRECTORY ENTRY TO A DIRECTORY :D
04:48:49 <elliott> HOW DOES SHOT COMPUTER :(
04:48:54 <pikhq_> Just one of a handful of fairly mundane data structures on disc.
04:49:04 <elliott> hmm, I suppose you could just have a pointer at the end of every directory entry
04:49:06 <elliott> and do it linked-list style
04:49:09 <zzo38> That IOCCC operating system is not even complete
04:49:10 <elliott> and just allocate randomly all over the disk
04:49:20 <elliott> but like do you need a freelist of blocks?
04:49:39 <pikhq_> elliott: You do also need to implement, basically, a malloc.
04:50:29 <elliott> diskmalloc :D
04:52:05 <augur> does anyone happen to know what the brightness-equivalent of resolution is in a camera?
04:53:20 <augur> like what the term for that is?
04:53:42 <pikhq_> I'm going with "color space".
04:54:12 <Patashu> as in, how much brightness you can fit in?
04:54:15 <Patashu> sounds like a property of color space to me
04:54:30 <augur> no no, i mean how many distinct brightness levels you have
04:55:01 <Patashu> it may as well be a property of the color space/color depth
04:55:03 <augur> greyscale is still a monochromatic colorspace but there are many kinds of greyscale depending on how finely you cut the greyness
04:55:10 <augur> color depth, maybe thats it
04:55:20 <augur> yeah color depth
04:55:21 <augur> there you go
04:55:54 <augur> thank you, Patashu!
04:56:49 <elliott> Patashu: you need to submit some awesome bf joust contestants to revive the sport again :P
04:56:59 <Patashu> hah
05:12:16 <CakeProphet> so what if my bfjoust program is really long?
05:12:20 <elliott> ?
05:12:23 <CakeProphet> how do I submit it?
05:12:31 <elliott> [exclamation mark]bfjoust <url>
05:12:34 <elliott> most of the current programs are really long
05:12:59 <elliott> http://codu.org/eso/bfjoust/in_egobot/?C=S;O=D
05:13:04 <elliott> largest program is 200K
05:13:32 <elliott> space_elevator kicked off the recent "zomg huge programs" streak though, at 38K
05:13:41 <elliott> those are machine-generated, I think
05:13:44 <elliott> anticipation is
05:13:50 <elliott> the furry-furry programs are, although actually
05:14:01 <elliott> their K ratings are wrong because they include the base-sixtyfour encoding of the perl program that generated them
05:14:10 <elliott> definer2 is generated too
05:14:16 <elliott> (all these meaning partially generated, ofc)
05:14:23 <elliott> dunno about defend9.75 but I think so
05:14:32 <elliott> the waterfall programs were
05:14:33 <elliott> yeah
05:14:35 <elliott> slowpoke too I think
05:14:45 <elliott> we really need quintopia's scoring system though.
05:14:54 <elliott> CakeProphet: btw http://codu.org/eso/bfjoust/in_egobot/report.txt
05:23:43 <CakeProphet> I don't really have a place I can host my program.
05:24:01 <elliott> um sprunge.us
05:24:28 <Patashu> has anyone attempted to genetically create bfjoust programs?
05:25:02 <elliott> yes.
05:26:08 <CakeProphet> my bf joust program is the best of all
05:26:24 <CakeProphet> an efficient killer
05:26:41 <elliott> lol
05:26:45 <elliott> youre about to submit a shitty program aren't you
05:26:49 <CakeProphet> never.
05:26:56 <elliott> oh so you are concealing it from us
05:27:03 <CakeProphet> unpossible.
05:27:43 <CakeProphet> so uh, what's the best way to git from a git.
05:27:47 * CakeProphet has never used git before.
05:29:19 <elliott> what
05:29:26 <elliott> how's git relevant to bf joust
05:29:43 <CakeProphet> don't worry about it.
05:30:14 <CakeProphet> so uh, 5.2 is a good score right?
05:30:22 <elliott> CakeProphet: no. btw please submit things in-channel
05:30:31 <CakeProphet> nope. :)
05:30:34 <elliott> it makes us antsy if the board changes without us knowing :<
05:30:40 <CakeProphet> you will laugh at how excellent my program is
05:30:50 <Patashu> why is rushpolarity STILL so high up
05:30:51 <Patashu> it's so ooooold
05:30:55 <elliott> CakeProphet: please, it's a matter of common courtesy
05:31:20 <elliott> i could set up a bot to constantly refresh the hg log, but it'd be easier just to submit in channel.
05:31:26 <elliott> wtf is vlad even supposed to be
05:31:54 <CakeProphet> the impaler. :)
05:31:57 <elliott> Patashu: it's really successful for some reason
05:32:01 <elliott> CakeProphet: i mean the strategy.
05:32:12 <CakeProphet> oh, well http://sprunge.us/LPcT
05:32:16 <CakeProphet> as you can see, it's genius.
05:32:19 <elliott> yes i can see it.
05:32:23 <Patashu> augh
05:32:26 <elliott> i'm asking how you made it, apart from vomiting on the keyboard
05:32:28 <elliott> anyway, congratulations, you're at position 48
05:33:16 <Patashu> btw you don't have to paste it
05:33:16 <Patashu> http://codu.org/eso/bfjoust/in_egobot/
05:33:18 <Patashu> just find it in the list
05:33:24 <Patashu> oh nvm it's not in the list
05:33:29 <Patashu> probably because it didn't beat anyone
05:33:36 <elliott> it did, but it was on the bottom
05:33:37 <elliott> so it got trimmed
05:34:00 <Patashu> yeah what I meant
05:34:03 <elliott> CakeProphet: but seriously, it's vastly preferred if you submit programs in-channel. especially since the activity tends to generate interest in bf joust.
05:34:21 <CakeProphet> elliott: well the idea was to go forward the minimum of 10 spaces, fill it with stuff because presumably that will slow someone down, and then proceed to blindly wipe everything in front of it to 0.
05:34:22 <Patashu> lol at this
05:34:23 <Patashu> CakeProphet_vlad.bfjoust vs Gregor_return_of_ehird_defend8mwahahaha.bfjoust
05:34:24 <Patashu> <<><<<><><><><><><><> <><<<<><><><><><><><> 6
05:34:24 <Patashu> Gregor_return_of_ehird_defend8mwahahaha.bfjoust wins.
05:34:29 <Patashu> some nice parity going on there
05:34:37 <elliott> CakeProphet: let's put it this way
05:34:45 <elliott> CakeProphet: any attack program will have obliterated you before you even get to their flag
05:34:51 <elliott> because you waste endless cycles putting dummy values up
05:34:57 <elliott> also, you don't seem to be aware of the various abbreviations that exist.
05:35:04 <elliott> Patashu: sieved up all the kettles
05:35:07 <CakeProphet> nope, just looked at the wiki article
05:35:14 <CakeProphet> the top part
05:35:15 <CakeProphet> :)
05:35:21 <elliott> the wiki article sucks
05:35:27 <elliott> because quint rewrote it making it unreadable
05:35:37 <Patashu> look on the bright side
05:35:38 <elliott> read http://esolangs.org/w/index.php?title=BF_Joust&oldid=21108 instead
05:35:40 <CakeProphet> ah I see the * syntax
05:35:40 <Patashu> you beat anticipation.bfjoust
05:35:41 <elliott> :p
05:36:02 <elliott> Patashu: well it's a sufficiently stupid program that "advanced" defenders and the like might get confused :P
05:36:09 <Patashu> hah, yes
05:36:23 <CakeProphet> yes, I was hoping that I would be jousting against very complicated defensive things.
05:36:43 <elliott> yeeeeeeeeees
05:36:47 <elliott> well there's always a mix on the hill
05:36:51 <Patashu> well, you even lost to my not very complicated things
05:36:51 <Patashu> soooo
05:36:58 <elliott> because whenever the hill is full of defensive programs, attack programs do really well
05:37:00 <elliott> and vice versa
05:37:06 <elliott> so basically the hill is always quite balanced.
05:37:41 <CakeProphet> I don't really see a sane way to encode any kind of logic when the other program can mess with my variables.
05:37:59 <elliott> CakeProphet: that is because you are not an experienced jouster :)
05:38:19 <Gregor> ... does x86_64 have delay-slot semantics???
05:38:25 <elliott> basically: set up large decoys before cells if you /really/ need scratch space. but generally, you don't want to store any values
05:38:31 <elliott> use [] as a conditional of sorts
05:38:38 <elliott> set up tripwires and use them to work out what the program is doing
05:38:46 <elliott> CakeProphet: read http://esolangs.org/wiki/BF_Joust_strategies
05:38:47 <elliott> it's there for a reason
05:38:54 <Patashu> just read what elliott posted
05:38:56 <elliott> it's practically How to Write Joust Programs: The Manual.
05:38:56 <Patashu> it is enlightenin
05:38:57 <elliott> yeah
05:38:59 <Patashu> soul transcending even
05:39:47 <elliott> CakeProphet: basically it goes through a bunch of simple to advanced attack and defence techniques, then covers all the number-one programs from the start of egobot's bf joust tournament setup to the present day, with explanations of the most interesting programs, and traces and animations in the online egojsout tool.
05:43:10 <CakeProphet> elliott: I think I would probably go with a defensive strategy. or the poke.
05:43:39 <Gregor> So, nobody knows if x86_64 has delay-slot semantics :P
05:43:47 <Patashu> I don't have a clue what that is
05:43:56 <elliott> youre a delay slot
05:44:02 <elliott> slottiest delay slot in all the galaxy
05:44:09 <Gregor> To put it differently, why did GCC generate this code:
05:44:10 <Gregor> call*368(%rdx)
05:44:10 <Gregor> movqGGGGC_fytheConstBank(%rip), %rdx
05:44:18 <elliott> wow are you still working on fythe stuff?
05:44:23 <Gregor> Uhh, yes?
05:44:28 <Gregor> Given that GGGGC_fytheConstBank[368] is my function.
05:44:33 <elliott> sorry, just before my fythe commits there had been none for like five thousand years :D
05:44:35 <elliott> I'm planning to keep working on bignums soon btw
05:44:48 <Gregor> elliott: You should look at GGGGC, not Fythe :P
05:45:03 <Gregor> I got distracted building a friggin' amazing general-purpose GC.
05:45:27 <elliott> Gregor: Does it have finalisers yet.
05:45:32 * elliott prepares the "WHOOPS you suck".
05:46:20 <CakeProphet> a defensive poke vibrator
05:47:10 <elliott> Gregor: I'M GOING TO DROP THE WHOOPS YOU SUCK IF YOU DON'T REPLY SOON
05:49:22 <elliott> BTW, is there a reason you use T-Rex instead of RE2? The latter is better-maintained and I would guess faster (though I don't have any benchmarks). OK, RE2 doesn't do backreferences, but it doesn't look like T-Rex does either.
05:49:44 <elliott> And both are C++, although T-Rex seems to have a few C wrappers that you'd have to whip up by hand with RE2.
05:49:58 <elliott> (Also RE2 handles Unicode; dunno about T-Rex.)
05:50:34 <Gregor> elliott: It doesn't have finalizers, I've been working on threadsafety.
05:50:37 <Gregor> And T-Rex is in C.
05:50:47 <Gregor> Also I don't use it unless PCRE is unavailable :P
05:51:06 <elliott> http://codu.org/projects/fythe/hg/index.cgi/rev/8d99109d97d7 ;; Oh, it just has a C++ wrapper.
05:51:11 <Gregor> And even then you have to say "No seriously I want this bullshit"
05:51:16 <elliott> Gregor: Doesn't T-Rex support different things to PCRE though?
05:51:22 <elliott> 'cuz, like, that's totally stupid if so :P
05:51:37 <Gregor> So does JS regex; I haven't defined what subset of regex Fythe is supposed to support yet.
05:51:39 <elliott> (Personally I'd advocate for always using RE2 since it'll make parsing stupidly fast, but then I'm me :P)
05:51:53 <elliott> (Also because using backreferences in regexp literals in a parser is a sign of insanity.)
05:51:58 <elliott> (And not the good kind ether.)
05:52:00 <elliott> [asterisk]either
05:53:36 <elliott> Sweet logic from Elliottcorp: "I sure am really fucking ill. And getting to sleep is a royal horrible pain when I'm feeling like this! OBVIOUS SOLUTION: DON'T SLEEP".
05:58:04 <pikhq_> Gregor: Hmm. I bet Fythe works on PCC and musl.
05:58:19 <pikhq_> Because you don't suck. :P
05:58:50 <elliott> Implying Gregor isn't the worst person.
05:59:51 <pikhq_> Oh, poo, it depends on GMP. I will have to build that.
06:01:14 <elliott> pikhq_: YOU CAN THANK ME FOR THAT ;D
06:01:28 <elliott> Note that arithmetic is what you might call broken right now because I'm a lazy ass wrt the bignum support.
06:02:21 <CakeProphet> elliott: I like space elevator. :)
06:03:47 <elliott> spelevator
06:04:54 <pikhq_> Come on, libtool, if you're going to get your nasty teeth in everything couldn't you at *least* have the decency to check if shared libraries can be built?
06:07:15 -!- pingveno has quit (Ping timeout: 246 seconds).
06:09:06 <comex> i should try BF Joust :)
06:09:21 -!- pingveno has joined.
06:11:47 <CakeProphet> alright, time to try a better program.
06:13:13 <elliott> comex: good luck :P
06:13:22 <elliott> comex: the current hill is _extremely_ competitive.
06:13:35 <elliott> the top program was considered game-breaking by its author for a while
06:13:54 <Patashu> how can a bfjoust program be 'game breaking'?
06:14:41 <elliott> Patashu: because the only programs that beat it might do terribly against all other types of opponents, etc.
06:14:55 <Patashu> aah
06:16:16 <myndzi> wow, there's a new king
06:16:27 <myndzi> i didn't think bf joust saw much activity most times ;)
06:16:37 <myndzi> slowrush has really sorta stood the test of time it seems, for which i am glad
06:16:47 <myndzi> 'cause damn i don't want to write anything all complicated ;p
06:16:59 <elliott> myndzi: it had a huge burst of activity earlier this year
06:17:15 <elliott> and simple programs can still do very well, it's just that they tend to turn into complicated programs very quickly
06:17:17 <elliott> just ask Gregor :P
06:18:44 <myndzi> har
06:18:48 <myndzi> i was here during that time i think
06:28:33 <CakeProphet> elliott: so, ] doesn't remember the starting point of the while right?
06:28:43 <elliott> Uh, what?
06:28:45 <CakeProphet> starting tape element that is.
06:28:55 <CakeProphet> it's only interested in whether or not the current cell is zero.
06:28:57 <Patashu> it looks at whatever tape element is under your guy
06:29:03 <CakeProphet> right.
06:29:07 <CakeProphet> just checking. :P
06:29:12 <Patashu> if you want to check the starting point use some <>s
06:29:21 <Patashu> it's more flexible this way
06:30:00 <CakeProphet> not if I go back more spaces on each loop. :P
06:30:05 <CakeProphet> *want to go
06:30:28 <Patashu> aah
06:30:37 <Patashu> the tape length is guaranteed to be within a finite range, so...
06:30:44 <Patashu> you could write a program to generate whatever algorithm you're after
06:30:48 <Patashu> program can be as big as you want
06:30:50 <elliott> yeah
06:30:54 <elliott> that's the standard practice nowadays
06:31:00 <elliott> try to detect tape length and what the program's doing, react accordingly
06:31:08 <elliott> with big partially-generated programs
06:31:20 <elliott> (with a generator tailored to that one algorithm, that is)
06:31:33 <elliott> CakeProphet: You could look at some of Gregor's generated programs, they include the Perl code used to generate them
06:31:42 <elliott> (as base-sixtyfour; running them as Perl produces the Perl code)
06:31:48 <elliott> (this is because BF Joust doesn't have full comments)
06:32:00 <CakeProphet> how on earth can you deduce the board length
06:32:21 <elliott> Didn't you READ space_elevator? :P
06:32:39 <elliott> But basically, number of cycles passed + where the opponent has tripwires + where the opponent's flag is + a bunch of other stuff = deduction.
06:33:19 <Patashu> I wonder how randomly_arbitrarily_large bfjoust would fare
06:33:26 <elliott> Patashu: wat? :P
06:34:13 <Patashu> as opposed to randomly_fairly_small bfjoust which is what we have
06:34:37 <elliott> Hey, Homestuck update, finally.
06:34:45 <elliott> Patashu: oh
06:34:48 <elliott> Patashu: the original tapes were very long
06:34:49 <elliott> tl;dr it sucked
06:34:51 <Patashu> yeah
06:34:54 <Patashu> figured
06:36:01 <elliott> "Let's pull back from this ever narrowing dark pocket. All this uncertainty is wearing thinner than the only pair of pants in an immortal's wardrobe."
06:37:53 <elliott> oh come the fuck ON Scratch did you just pull the "ONLY KIDDING THAT WASN'T THE ALPHA TIMELINE" shit
06:38:29 <Patashu> huh, so that's quarters' ability
06:38:53 <elliott> wait, what was it? I must have missed it
06:39:08 <Patashu> you've noticed the top banners change right
06:39:13 <elliott> I was too busy fantasising about making Scratch speak in sentences of five words of four syllables each at maximum
06:39:15 <elliott> Patashu: yes of course :P
06:39:20 <Patashu> give them anotherl ook
06:39:22 <elliott> oh wait
06:39:25 <elliott> disappearing into the quarter?
06:39:32 <Patashu> it's some kind of pokeball
06:39:34 <Patashu> apparently
06:39:37 <elliott> right
06:39:42 <elliott> the gif loaded wrongly for me
06:40:14 <elliott> But seriously what a cheap recovery.
06:42:38 <CakeProphet> elliott: I'm going to do this one entirely by hand over the course of several days.
06:42:54 <elliott> CakeProphet: You want to be testing it really regularly :P
06:42:57 <elliott> Or you'll just end up with a shitty program.
06:43:01 <elliott> Use egojsout extensively, it is REALLY useful.
06:43:07 <elliott> Oh, and SEND THE COMMANDS IN-CHANNEL >:|
06:44:03 <elliott> Patashu: (...but seriously how come all the deceased members of the Felt are back to life. Spades has all his injuries, so this isn't pre-intermission.)
06:44:07 <elliott> (Maybe he's travelled back in time.)
06:44:19 <Patashu> I'm not sure, I hadn't even thought of that
06:44:27 <Patashu> I just assumed pre-intermission
06:44:56 <elliott> Patashu: The banner on 5738 makes that even less likely X-D
06:45:20 -!- Deewiant has quit (Ping timeout: 276 seconds).
06:45:29 -!- Deewiant has joined.
06:45:40 <Patashu> hah
06:45:53 <Patashu> but...jack noir = spades slick right? so he can't die. right??
06:50:21 <CakeProphet> elliott: egojsout, what is that?
06:50:33 <elliott> http://codu.org/eso/bfjoust/egojsout/index.php
06:50:34 <CakeProphet> I am too lazy to read things before I plunge into something, obviously.
06:50:37 <elliott> as seen on the wiki
06:50:46 <elliott> CakeProphet: you should _really_ read the entire strategies page.
06:50:50 <elliott> or you _will_ get beaten mercilessly
06:51:00 <elliott> basically egojsout is an interactive warrior development/debugging tool
06:51:13 <elliott> it lets you pit any two warriors against each other, see a full trace of the execution, an animated version so you can see how the programs are operating...
06:51:25 <elliott> it's basically vital for developing warriors.
06:51:33 <elliott> see all the "Trace and animation" links on http://esolangs.org/wiki/BF_Joust_strategies
07:06:04 <CakeProphet> elliott: who is left in egojsout?
07:06:26 <Patashu> what do you mean?
07:06:29 <Patashu> you can give it any two programs
07:06:40 <elliott> CakeProphet: nobody is left. only our dead souls.
07:06:43 <elliott> hth
07:07:12 <CakeProphet> ...
07:07:21 <CakeProphet> I mean, which program is left and which is right.
07:07:41 <elliott> left istop
07:07:42 <elliott> is top
07:07:44 <elliott> right is bottom
07:10:00 -!- monqy has quit (Quit: hello).
07:11:03 <CakeProphet> the tape length is always 10...
07:11:32 <Patashu> it should let you adjust it
07:12:10 <CakeProphet> ah it does.
07:12:23 <CakeProphet> NOT USER FRIENDLY
07:12:37 <Patashu> brainfuck is user friendliness paramount!
07:12:56 <Patashu> sucks at doing fast fourier transforms though
07:13:30 <elliott> CakeProphet: um that's what all the links are for
07:13:35 <elliott> first line is sieve, second line is kettle
07:13:40 <elliott> from left to right are the tape lengths
07:13:54 <Patashu> sieve? kettle?
07:14:12 <elliott> Patashu: sieve means + increments and - decrements for both players
07:14:16 <elliott> kettle means that + and - are swapped for one player
07:14:17 <Patashu> oooooh
07:14:19 <Patashu> and kettle is- right
07:14:21 <Patashu> interesting
07:14:25 <elliott> i named these and will never apologise for their naems.
07:14:27 <elliott> [asterisk]names.
07:14:36 <elliott> remember how flipping polarity used to be a viable strategy?
07:14:38 <elliott> yeah
07:14:41 <elliott> <-- GUY WHO PUT A STOP TO THAT HERE
07:14:55 <elliott> lol oh wow i remember people rerunning programs ten times just to get a good tape length
07:15:11 <elliott> but yeah we need quintopia's fixed-point scoring system IMHO
07:15:32 <elliott> http://esolangs.org/wiki/Talk:BF_Joust#Scoring
07:16:30 <Patashu> interesting
07:16:37 -!- Phantom_Hoover has joined.
07:21:02 <elliott> Phantom_Hoover: how is a donkey
07:21:44 <CakeProphet> elliott: my current program beats slowpoke at some of the small boards and some of the middle boards.
07:22:12 <CakeProphet> http://codu.org/eso/bfjoust/egojsout/?l=c8f08955801dce28866a597d4ef33ea66dfba938&r=9a8203d4a81d0e908f795647f147054a602211bf
07:22:18 <Deewiant> Anything can be beaten part of the time, it's beating stuff consistently that's troublesome
07:22:41 <Phantom_Hoover> *sigh*
07:22:41 <lambdabot> Phantom_Hoover: You have 21 new messages. '/msg lambdabot @messages' to read them.
07:22:54 <elliott> Wow, how did I manage that.
07:23:06 <elliott> CakeProphet: lol ok so it basically doesn't beat it at all
07:23:08 <elliott> that's an unquestionable loss
07:23:11 <elliott> remember that slowpoke is /slow/
07:23:12 <CakeProphet> yes I know
07:23:13 <elliott> try it against a rush program
07:23:23 <elliott> allegro beats it on every single configuration
07:23:28 <elliott> almost instantly
07:23:41 <CakeProphet> elliott: on small boards my program is a rush program. Just needs some finetuning.
07:24:03 <elliott> Looking at it, it's a rush program on every configuration, just a bad one :P
07:24:26 <elliott> Loses against the furry furry girls on pretty much every configuration.
07:25:01 <elliott> Hmm, you are actually fairly competitive with waterfall
07:25:12 <elliott> Three, that is
07:25:13 <Phantom_Hoover> elliott, congratulations, you have broken lambdabot with your stupidly large number of messages.
07:25:17 <elliott> On two you win but only by a small margin.
07:25:29 <CakeProphet> elliott: yeah there are ties and shit on waterfall
07:25:33 <CakeProphet> TIES
07:25:37 <elliott> CakeProphet: Fuck you, you beat ICA.
07:25:42 <elliott> Un-for-fucking-givable.
07:26:32 <elliott> Loses against spelevator :P
07:26:51 <CakeProphet> badly.
07:27:15 <CakeProphet> so what would make it more defensive?
07:28:11 <elliott> Uhh, a complete rewrite? They're orthogonal strategies.
07:28:19 <Patashu> is it deliberate that there's no 'wait' command?
07:28:24 <elliott> You can write a hybrid, but that's really two programs fused into one.
07:28:25 <CakeProphet> . is wait
07:28:26 <elliott> Patashu: . is a nop
07:28:28 <Patashu> ah ok
07:28:38 <Patashu> it wasn't listed
07:29:01 <elliott> The revised version
07:29:01 <elliott> User:ais523 introduced a revised version of BF Joust, with the following changes:
07:29:01 <elliott> A new command . is added, which does nothing but takes one cycle
07:29:03 <elliott> That's in the old revision
07:29:07 <elliott> In the new one, it's with every other command
07:29:13 <elliott> Which is saner, but unfortunately the text itself is unreadable :P
07:29:38 <Patashu> merge 'em then
07:29:43 <CakeProphet> elliott: well I blindly rush the first 5 cells the flag could be, and then go back and try to set up a defense but it seems by the time I get to that point they're already beyond my tripwire.
07:30:16 <elliott> CakeProphet: To be perfectly honest, this is the kind of program that would have done well two years ago :P
07:30:22 <elliott> Patashu: Too lazy. :p
07:30:27 <elliott> Maybe if we get another resurgence.
07:31:02 <coppro> holy shit
07:31:08 <coppro> holy fucking shit
07:31:10 <coppro> question period
07:31:35 <CakeProphet> elliott: I guess mine isn't generated and massive enough.
07:31:43 <CakeProphet> doesn't help that I'm a shitty BF programmer. :P
07:31:44 <Patashu> so?
07:31:46 <Patashu> mine isn't generated
07:31:51 <Patashu> it's still like 10th for some fucking reason
07:32:06 <elliott> coppro: what
07:32:12 <CakeProphet> I tie with i_like_turtles
07:32:16 <coppro> elliott: it's almost respectable
07:32:17 <elliott> Patashu: yours is a modified version of a polarity thing iirc :P
07:32:24 <Deewiant> Mine isn't generated and it's third
07:32:24 <coppro> the MPs are actually letting each other talk
07:32:25 <elliott> coppro: what is
07:32:27 <elliott> oh
07:32:41 -!- zzo38 has quit (Quit: Others he will beat and that will be neat.).
07:32:53 <elliott> coppro: that would never happen in britain
07:32:54 <elliott> atrocious
07:33:34 <coppro> elliott: it got particularly out of hand last Parliament
07:33:45 <coppro> going in, they all said they wanted a better parliament, but no one believed them
07:33:53 <coppro> turned out they seemed to actually mean it, at least so far
07:34:00 <elliott> coppro: i'm fucking disgusted.
07:34:03 <elliott> coppro: ok we're coming over.
07:34:05 <CakeProphet> elliott: I seem to win quite often on small boards.
07:34:05 <elliott> the queen and everyone.
07:34:07 <Patashu> politicians not interested in long term well being of nation
07:34:08 <Patashu> film at 11
07:34:09 <elliott> we're going to rebuild your society.
07:34:18 <elliott> you have clearly been led astray by your lumberjacks. and kindness.
07:34:28 <elliott> CakeProphet: it's easy to win on small boards, because you can do a lightspeed rush
07:35:16 <CakeProphet> well right
07:35:18 <CakeProphet> which is what I do.
07:41:13 <CakeProphet> how do you trick someone into suiciding.
07:41:41 -!- Vorpal has joined.
07:42:48 <elliott> CakeProphet: complicatedly
07:42:52 <elliott> hi Vorpal what fpga board should i buy
07:43:54 <Vorpal> elliott, I will tell you what I know about that if you give me the spec to the computer first
07:44:20 <elliott> do you want to know a spoiler.........................................
07:44:29 <Vorpal> elliott, however, why are you interested in an FPGA?
07:44:36 <pikhq_> coppro: MPs, *talking*?
07:44:39 <elliott> I'm reading extensively about the Reduceron
07:44:47 <pikhq_> coppro: What's next, a constitution?
07:44:49 <Vorpal> elliott, what is the spoiler?
07:44:54 <elliott> and am getting interested in purely-functional hardware
07:45:06 <elliott> Vorpal: i never.........made a spec i................ was too busy doing.......... other things...........
07:45:15 <Vorpal> elliott, ... when will you do it then
07:45:19 <coppro> pikhq_: Canadian MPs
07:45:25 <pikhq_> Oh, wait, Canada. Technically has a constitution.
07:45:33 <coppro> They talk. Typically all at once
07:45:39 <coppro> except not today, apparently
07:45:40 <pikhq_> Dammit, need some other way of poking fun.
07:45:58 <pikhq_> Harder to do for Canada, because their government is *less* ridiculous.
07:46:02 <elliott> Vorpal: i don't know, ph has been waiting for like at least five months
07:46:09 <Vorpal> <pikhq_> Harder to do for Canada, because their government is *less* ridiculous. <--- than US? yes
07:46:14 <elliott> you can't rush genius
07:46:15 <elliott> or uh
07:46:18 <pikhq_> Vorpal: Than the UK, actually, in this case.
07:46:20 <CakeProphet> bah, brainfuck programming is difficult. :P
07:46:20 <elliott> you can't rush mismotivated
07:46:30 <Vorpal> elliott, you did it for bsmnt
07:46:34 <pikhq_> Well. It's still a monarchy ruled by divine right.
07:46:35 <elliott> yeah, and nobody since
07:46:39 <pikhq_> That's pretty ridiculous.
07:46:49 <Vorpal> elliott, anyway I guess I'll go ahead without you then
07:46:49 <elliott> i had the spark that day, maybe i'll have the spark tomorrow, maybe two days in the future, but relying on me is generally a bad plan
07:47:07 <Vorpal> elliott, dude you won't survive university if you can't keep deadlines
07:47:21 <coppro> pikhq_: If I see 5 conservatives vote against party lines and see an opposition-moved amendment on a government bill, I will go to Ottawa and attempt to hug every MP
07:47:26 <elliott> Well to be fair there is significantly less resting on creating a spec for you.
07:47:37 <elliott> Also your deadlines kept not actually being deadlines anyway.
07:47:45 <coppro> pikhq_: also I will publicize this promise
07:47:58 <coppro> actually I might raise the numbers a bit
07:48:04 <coppro> given that they've four years to implement them
07:48:11 <pikhq_> coppro: So, some dude ruled the country, and had his kid take over, and so on, right? And you call this a way to rule a country?
07:48:19 <pikhq_> coppro: You deserve everything you get, you git.
07:48:21 <pikhq_> :P
07:48:25 <Vorpal> elliott, are you using EDF or LST scheduling for your life?
07:48:43 <elliott> Vorpal: Boy howdy, that's undoubtedly a really hilarious joke I don't get.
07:48:51 <Vorpal> elliott, no I'm serious
07:48:59 <elliott> I Wikipediad it. Hilarious.
07:49:07 <Vorpal> elliott, which method do you think works best for real life.
07:49:15 <coppro> pikhq_: If by 'rule' you mean 'sit in a different country and only get directly involved very rarely, the last time to help a politician commit political suicide in order to implement the most intelligent economic measure attempted in 50 years', sure, got no problem
07:49:18 <Vorpal> elliott, I'm utterly serious.
07:49:31 <elliott> Vorpal: I don't know, but I do know that my inability to "do X now" makes using any actual algorithm pointless.
07:49:35 <Patashu> EDF sounds a lot like me
07:49:41 <Vorpal> Patashu, ah
07:50:02 <pikhq_> coppro: Still less ridiculous than the UK. Where the Queen could do just about anything...
07:50:07 <pikhq_> (and get lynched for it, mind.)
07:50:12 <Vorpal> Patashu, LST works better in the presence of sporadic tasks iirc.
07:50:17 <Patashu> yeah
07:50:52 <Vorpal> pikhq_, if she tried to do it, that right would very quickly be revoked
07:51:04 <pikhq_> Vorpal: As I said, "and get lynched for it".
07:51:07 <Vorpal> yeah
07:51:14 <pikhq_> coppro: Y'know what? Fuck it. Think you could invade?
07:51:35 <Vorpal> pikhq_, how does US and CA compare to each other wrt this?
07:51:40 <coppro> pikhq_: I love framing
07:51:51 <elliott> MAYBE I'LL JUST ASK AIS ABOUT FPGAS INSTEAD ;_______________;
07:52:13 <pikhq_> Vorpal: The US is nominally ruled by just consent of the governed, and there exists no single individual with a high level of power.
07:52:31 <Patashu> counterexample: koch bros
07:52:35 <Vorpal> pikhq_, well, only nominally.
07:52:38 <pikhq_> Patashu: "Nominally".
07:52:44 <pikhq_> In practice, it depends.
07:52:44 <Patashu> oh, nominally, sure
07:52:48 <pikhq_> Sometimes, that's how it works.
07:52:55 <Patashu> in practice, most people do what they're told/what their parents do
07:52:59 <Patashu> because of lack of free time
07:53:01 <elliott> sometimes that's how it works? r u srs
07:53:12 <pikhq_> Sometimes, the President has large brass testicles and can effectively act as monarch.
07:53:21 <Vorpal> elliott, heh I ended up doing an ineiros. I have a "restore session" tab listed in the "restore session" one.
07:53:40 <elliott> Vorpal: OK Mr. FPGA "Enemy-Of" Vorpal
07:53:57 <elliott> "Bad person"
07:53:59 <pikhq_> And this turns out both good and bad, depending.
07:54:01 <Vorpal> elliott, iirc you need state of the art for redueron.
07:54:08 <Vorpal> elliott, simpler ones won't work
07:54:15 <pikhq_> Bush is the most recent example of it turning out bad.
07:54:17 <elliott> Vorpal: It only ran at ninety megahertz, but that's probably irrelevant :P
07:54:27 <elliott> And only thirty-two kilowords of heap :P
07:54:31 <elliott> Anyway I don't expect to run the Reduceron.
07:54:34 <Vorpal> elliott, how many gates did it use?
07:54:34 <pikhq_> And by "bad" I mean "holy fuck, he's probably fucked over the next few generations".
07:54:40 <elliott> I just want the best evaluation board that I can afford.
07:54:52 <elliott> Vorpal: I don't know; the VHDL file is available but it is generated code.
07:55:13 <Vorpal> elliott, ah, you need to feed it into the synthesiser to get that info out
07:55:38 <Vorpal> elliott, anyway, the PC software... The cheap editions are generally very sucky from what I understood
07:55:44 <elliott> "It requires over
07:55:44 <elliott> 2,000 logic gates, but this is less than 1% of our FPGA’s logic-gate
07:55:44 <elliott> capacity." ;; comment on one specific piece of functionality
07:55:45 <Vorpal> I used the pro version at university
07:55:52 <elliott> Vorpal: I could always pirate the software, couldn't I?
07:56:11 <Vorpal> elliott, not sure how easy it is to find such specialised software...
07:56:27 <elliott> True.
07:56:35 <elliott> http://torrentz.eu/search?f=xilinx
07:56:35 <elliott> http://torrentz.eu/search?f=altera
07:56:38 <elliott> Doesn't look too bad.
07:56:58 <Vorpal> elliott, I only used xilinx boards. You might get more info from ais on this stuff
07:57:18 <Vorpal> elliott, only the windows versions from what I can see
07:57:26 <Vorpal> xilinx at least makes linux versions too
07:57:34 <elliott> Anyway, I pretty much just want something that can run something bigger than "hello world", and that can do serial I/O :P
07:57:42 <elliott> (Why serial? 'Cuz it's fucking simple.)
07:57:59 <elliott> Plugging serial into a MacBook Air (via an adapter of course): HEIGHT OF WEIRDNESS?
07:58:20 <Vorpal> elliott, the board I programmed used parport. Anyway serial is easy. You can do the basics with two GPIO pins!
07:58:50 <Vorpal> elliott, assuming you mean UART
07:59:01 <elliott> It would be kind of sad if the Reduceron required a high-end board.
07:59:09 <elliott> I mean, it's generated code, but I presume the design is probably simply that complex.
07:59:16 <Vorpal> if you want USRT it would be more complicated
07:59:35 <elliott> Vorpal: I know nothing of serial ports TBH, I just know that they're meant to be simple to program with :P
08:00:04 <coppro> `/win 2
08:00:07 <HackEgo> No output.
08:00:23 <Vorpal> elliott, I have no idea how many gates it would use. You would have to test synthesise it for the model in question
08:00:35 <elliott> Can I do that without buying anything? :-P
08:03:09 <Vorpal> elliott, unsure
08:03:39 <elliott> I get the feeling it would be easier just to rob the high-end kits from a university.
08:03:45 <Vorpal> elliott, anyway programming FPGAs is *nothing* like writing a normal program
08:04:16 <Vorpal> completely different paradigm from any other sort of programming
08:04:21 <elliott> I'm aware, but then I learned functional programming after a lifetime of imperative languages too.
08:04:38 <elliott> And anyway there is always that thing ais is working on. :p
08:04:47 <elliott> (I plan to play with York Lava which looks cool too.)
08:05:18 <Vorpal> elliott, best way to describe VHDL would perhaps be as writing event driven code using imperative style in the time domain or something like that.
08:05:50 <Vorpal> elliott, basically it is better to approach it as electronics engineering rather than as programming
08:06:15 <elliott> Which is great 'cuz I know no EE at all.
08:06:22 <elliott> But event-driven shit is something I'm relatively comfortable with.
08:06:29 <Patashu> circuitry is very different - you can parallelize it as much as you want for starters
08:06:43 <Vorpal> it is *easier* to make it parallel than serial even
08:06:55 <Vorpal> I mean, doing stuff in a serial order is *hard* in vhdl
08:07:41 <Vorpal> you would need to do some sort of flip-flop to keep track of which state you are in. That is probably a screenful of code alone.
08:08:00 <Vorpal> elliott, and you need to take care of the clock signal in most places.
08:08:21 <elliott> UNLESS I MAKE EVERYTHING CLOCKLESS.
08:08:35 <elliott> Vorpal: You should look at the Reduceron's VHDL file, it's hilarious.
08:08:48 <Vorpal> elliott, ghdl + gtkwave might be a good way to learn the basics, by simulating
08:09:16 <elliott> c22274 : and2 port map (w22274_0,w74_0,w228_0);
08:09:16 <elliott> c22254 : or2 port map (w22254_0,w22255_0,w22274_0);
08:09:16 <elliott> c22250 : or2 port map (w22250_0,w22251_0,w22254_0);
08:09:16 <elliott> c83 : or2 port map (w83_0,w84_0,w22250_0);
08:09:16 <elliott> c22276 : inv port map (w22276_0,w138_0);
08:09:16 <elliott> c22277 : inv port map (w22277_0,w151_0);
08:09:18 <elliott> c22275 : and2 port map (w22275_0,w22276_0,w22277_0);
08:09:19 <Vorpal> <elliott> UNLESS I MAKE EVERYTHING CLOCKLESS. <-- uh. 1) damn hard 2) Most FPGAs are based on a clocked design, so it won't work well 3) damn hard
08:09:20 <elliott> c82 : and2 port map (w82_0,w83_0,w22275_0);
08:09:25 <elliott> c22280 : or2 port map (w22280_0,w1670_0,w1689_0);
08:09:27 <elliott> c22282 : or2 port map (w22282_0,w68_0,w202_0);
08:09:28 <elliott> c22281 : or2 port map (w22281_0,w1708_0,w22282_0);
08:09:30 <elliott> c22279 : or2 port map (w22279_0,w22280_0,w22281_0);
08:09:32 <Vorpal> elliott, looks normal apart from the generated names
08:09:32 <elliott> c22285 : or2 port map (w22285_0,w208_0,w1536_0);
08:09:35 <elliott> quality code
08:09:41 -!- augur has quit (Remote host closed the connection).
08:09:43 <elliott> Vorpal: it's thousands of lines of that
08:09:53 <elliott> the file is literally almost fifty thousand lines long
08:10:03 <Vorpal> elliott, that is in an architecture joining components right?
08:10:06 <elliott> before that there's a lot of
08:10:07 <elliott> attribute INIT of c21952: label is "0";
08:10:07 <elliott> attribute INIT of c21948: label is "0";
08:10:07 <elliott> attribute INIT of c21965: label is "0";
08:10:07 <elliott> attribute INIT of c21961: label is "0";
08:10:07 <elliott> attribute INIT of c21976: label is "0";
08:10:08 <elliott> attribute INIT of c21984: label is "0";
08:10:11 <elliott> attribute INIT of c21992: label is "0";
08:10:12 <Vorpal> uh wtf
08:10:12 <elliott> attribute INIT of c22000: label is "0";
08:10:15 <elliott> attribute INIT of c22008: label is "0";
08:10:16 <elliott> and at the start there's a lot of
08:10:18 <Vorpal> elliott, I have no idea what that means
08:10:18 <elliott> w22412_0,
08:10:20 <elliott> w22418_0,
08:10:21 <Patashu> nice spam
08:10:24 <elliott> w22419_0,
08:10:26 <elliott> w22417_0,
08:10:28 <Vorpal> elliott, link the file?
08:10:28 <elliott> w22421_0,
08:10:30 <elliott> w22422_0,
08:10:32 <elliott> w22420_0,
08:10:34 <elliott> w22416_0,
08:10:35 <Vorpal> I'd like to check it
08:10:36 <elliott> w22411_0,
08:10:38 <elliott> w22410_0,
08:10:39 <Vorpal> elliott, yes yes
08:10:40 <elliott> w22405_0,
08:10:42 <elliott> w48_0,
08:10:44 <elliott> w41_0,
08:10:45 <Vorpal> op!
08:10:46 <elliott> w40_0,
08:10:48 <elliott> w39_0,
08:10:48 <Vorpal> stop the spam
08:10:50 <Vorpal> come on
08:10:50 <elliott> Patashu: yw
08:10:54 <elliott> Vorpal: Tried to sprunge it but then I just realised it's a meg big
08:10:56 <elliott> Oh shut up
08:10:58 <Vorpal> elliott, link it?
08:11:02 <elliott> I didn't paste that much >_>
08:11:03 <Vorpal> I mean
08:11:06 <Vorpal> where did you get it from
08:11:08 <elliott> http://www.cs.york.ac.uk/fp/reduceron/reduceron.tar.gz
08:11:11 <elliott> fpga/Reduceron/Reduceron.vhd
08:11:13 <elliott> is what you want
08:11:23 <elliott> <Vorpal> elliott, that is in an architecture joining components right?
08:11:25 <elliott> what does this mean?
08:11:33 <elliott> The Reduceron is described in York Lava, not VHDL
08:11:38 <elliott> York Lava just compiles to VHDL
08:11:44 <elliott> (York Lava is a Haskell library)
08:11:49 <Vorpal> wha
08:11:52 <elliott> Wha?
08:11:59 <Vorpal> it *crashed* kate
08:12:03 <elliott> Nice.
08:12:15 <Vorpal> when I tried to scroll
08:12:16 <elliott> (For a brief introduction to York Lava, see YorkLava.txt in http://www.cs.york.ac.uk/fp/reduceron/york-lava.tar.gz.)
08:12:49 <Vorpal> what the fuck
08:12:53 <Vorpal> it is all one entity??
08:13:07 <Vorpal> elliott, okay that is no normal vhdl.
08:13:18 <elliott> Vorpal: It's. Generated. Code.
08:13:25 <elliott> How many times do I have to say this.
08:13:37 <Vorpal> elliott, yes but where the fuck is the non-structural definitions
08:13:43 <elliott> Why would there be any?
08:13:56 <Vorpal> elliott, because somewhere there has to be, or there is nothing to synthesise
08:14:04 <elliott> Oh, do you mean a "top level"?
08:14:08 <elliott> See extra/.
08:14:12 <elliott> README.txt and top.vhd.
08:14:23 <Vorpal> elliott, the fpga/Reduceron/Reduceron.vhd file *is* the top level as far as I can tell
08:14:27 <elliott> See extra/.
08:14:31 <Vorpal> it just joins together other components yeah
08:14:33 <elliott> Top-level .vhd and .ucf files that basically connect the reduceron to
08:14:33 <elliott> the LEDs and switches on the XUPV5 board (also known as ML509).
08:14:50 <Vorpal> elliott, I would suggest that fpga/Reduceron/Reduceron.vhd is the top level one yeah
08:15:13 <elliott> Does that answer your question about "where are the non-structural definitions"?
08:15:21 <Vorpal> hm top.vhd isn't it
08:15:51 <elliott> Has to be; that's all there is.
08:15:53 <Vorpal> hm
08:16:07 <elliott> Are you _sure_ it's not top.vhd?
08:16:36 <Vorpal> elliott, structural architectures is basically a way to join together many behavioural architectures. Like saying "place component foo and bar, and connect foo.out2 to bar.in1" or such
08:17:05 <elliott> presumably, it is joining together all those w560_0 things
08:17:10 <Vorpal> the problem here is that "architecture structural of Reduceron is"
08:17:11 -!- pikhq has joined.
08:17:34 <Vorpal> hm
08:18:37 <Vorpal> elliott, I mean there is process in the top.vhd file
08:18:54 <elliott> Are you sure structural architectures can't do more than you're thinking?
08:18:55 <Vorpal> w22497_0 : std_logic;
08:19:19 <Vorpal> elliott, could be. Actually they are freetext names. There are conventions though.
08:19:34 <Vorpal> elliott, and this doesn't seem to follow those conventions for names.
08:19:45 <elliott> Well it's generated code.
08:19:45 <elliott> red_instance : Reduceron
08:19:45 <elliott> port map (
08:19:45 <elliott> finish => fin,
08:19:45 <elliott> result1 => result(0),
08:19:45 <elliott> result2 => result(1),
08:19:47 <elliott> result3 => result(2),
08:19:49 <elliott> result4 => result(3),
08:19:50 <Vorpal> yes right
08:19:53 <elliott> (That's hand-written, obviously.)
08:20:00 <Vorpal> elliott, that looks like a structural one to me yes
08:20:01 -!- pikhq_ has quit (Ping timeout: 240 seconds).
08:20:07 <elliott> Right.
08:20:13 <Vorpal> elliott, it is just I would expect a shitload of "begin process" in the generated one
08:20:13 <elliott> Well, why's there nothing to synthesise?
08:20:27 <elliott> Why?
08:20:41 <elliott> Note that York Lava is still based around signals and the like.
08:20:42 <Vorpal> elliott, because how else would you do a latch or a flip-flop
08:20:45 <elliott> It's not compiling Haskell to VHDL or anything.
08:21:05 <elliott> Vorpal: Maybe look at YorkLava.txt in http://www.cs.york.ac.uk/fp/reduceron/york-lava.tar.gz to see its architecture.
08:21:17 <elliott> It's short.
08:21:21 <elliott> Ish.
08:21:27 <elliott> Quite a wide overview.
08:22:01 <Vorpal> elliott, right. But where are all the latches and so on!
08:22:14 <Vorpal> library unisim;
08:22:14 <Vorpal> use unisim.vcomponents.all;
08:22:14 <Vorpal> use work.all;
08:22:15 <Vorpal> hrrm
08:22:21 <elliott> Latches? Who needs 'em?
08:22:31 <Vorpal> elliott, flip-flops though
08:22:57 <elliott> Can they be simulated by anything lower-level in VHDL terms? :p
08:23:07 <Vorpal> elliott, processes that is how you do them
08:23:18 <elliott> Obviously there is another way, or the Reduceron wouldn't work.
08:23:27 <Vorpal> elliott, I suspect use unisim.vcomponents.all; might be it perhaps
08:23:30 <elliott> Seriously, look at YorkLava.txt. It's pretty damn low-level at its core.
08:23:44 <elliott> http://www.xilinx.com/itp/3_1i/data/fise/xst/chap03/xst03007.htm
08:23:54 <elliott> That's a summary of unisim.vcomponents.all. I think.
08:24:11 <elliott> I like how the Verilog code is consistently shorter and less noisy.
08:25:48 -!- nooga has joined.
08:26:15 <Vorpal> elliott, everything is processes in verilog iirc
08:26:47 <Vorpal> elliott, anyway top.vhd contains a set of flip-flops I can tell
08:26:55 <Vorpal> if (rising_edge(clock)) then
08:26:55 <Vorpal> saved_switches <= switches;
08:26:56 <Vorpal> after all
08:27:28 <Vorpal> fucked up indentation in that file
08:29:19 <Vorpal> elliott, what, Lava uses two-valued logic?
08:29:37 <Vorpal> normally in VHDL you have 7-valued logic.,
08:29:39 <Vorpal> s/,//
08:29:41 <elliott> Who says low and high are the only values of Bit? :P
08:29:49 <Vorpal> hm right
08:29:56 <elliott> data Bit =
08:29:56 <elliott> Symbol { componentName :: String
08:29:56 <elliott> , numOutputs :: Int
08:29:57 <elliott> , parameters :: [Parameter]
08:29:59 <elliott> , inputs :: [Bit]
08:30:01 <elliott> , instanceRef :: IORef (Maybe InstanceId)
08:30:03 <elliott> , outputNumber :: OutputNumber
08:30:05 <elliott> , outputSignal :: Signal
08:30:06 <Vorpal> heh
08:30:07 <elliott> }
08:30:09 <elliott> THAT'S TOTALLY A BIT YO
08:30:11 <elliott> (It's symbolic, obviously :P)
08:30:13 <elliott> -- | Logic '0'.
08:30:15 <elliott> low :: Bit
08:30:17 <elliott> low = makeComponent "low"
08:30:19 <elliott> {- Inputs: -} []
08:30:23 <elliott> {- Outputs: -} 1
08:30:25 <elliott> {- Simulate: -} (\[] -> [repeat False])
08:30:27 <elliott> {- Params: -} []
08:30:29 <elliott> {- Continue: -} (\[o] -> o)
08:30:30 <Vorpal> elliott, can it be high impedance?
08:30:31 <elliott> -- | Logic '1'.
08:30:33 <elliott> high :: Bit
08:30:35 <elliott> high = makeComponent "high"
08:30:37 <elliott> {- Inputs: -} []
08:30:39 <elliott> {- Outputs: -} 1
08:30:41 <elliott> {- Simulate: -} (\[] -> [repeat True])
08:30:43 <elliott> {- Params: -} []
08:30:45 <elliott> {- Continue: -} (\[o] -> o)
08:30:47 <elliott> logic2 :: String -> (Bool -> Bool -> Bool) -> (Bit, Bit) -> Bit
08:30:48 <Vorpal> sigh
08:30:49 <elliott> logic2 name f (a, b) =
08:30:53 <elliott> makeComponent name
08:30:54 <Vorpal> spam
08:30:55 <elliott> {- Inputs: -} [a, b]
08:30:55 <Vorpal> come on
08:30:57 <elliott> {- Outputs: -} 1
08:30:59 <elliott> {- Simulate: -} (\[a, b] -> [zipWith f a b])
08:31:01 <elliott> {- Params: -} []
08:31:03 <elliott> {- Continue: -} (\[o] -> o)
08:31:05 <elliott> Vorpal: Dunno :P
08:31:07 <elliott> Vorpal: What.
08:31:09 <elliott> It's helpful spam.
08:31:11 <elliott> :<
08:31:39 <elliott> Can I just record forever as my stupidity that I didn't realise x+y = (x^y) | ((x&y) << 1) until really recently.
08:32:09 <Vorpal> elliott, for signed integers?!
08:32:41 <elliott> Vorpal: ...
08:33:00 <Vorpal> elliott, I'm wondering what you are talking about here
08:33:11 <elliott> Unsigned, obviously.
08:33:14 <Vorpal> ah
08:33:21 <nooga> ;o
08:33:37 <elliott> XOR is just addition without carry, AND gives you the locations of all the bits where there would be a carry.
08:33:51 <elliott> Which means that the next digit needs setting, so you shift it one and OR it in.
08:33:52 <Vorpal> elliott, wait something must be wrong, why don't we all use that instead of complex carry forwarding networks.
08:34:05 <elliott> 'Cuz that's probably slow?
08:34:13 <Vorpal> it doesn't *look* slow to me
08:34:19 <elliott> Hmm, maybe it fails if there's a cascaded carry.
08:34:27 <Vorpal> elliott, it must do that.
08:34:32 <elliott> Are you suuuuuuuuuuuuure
08:34:54 <Vorpal> elliott, not 100% sure no. But it looks faster than ripple carry to me at least.
08:35:01 <elliott> > but adding is not a bitwise operator.[/color]
08:35:01 <elliott> ....but it is easy to implement in terms of bitwise operators, as long as you remember the truth table for the full adder.
08:35:02 <lambdabot> Not in scope: `but'Not in scope: `adding'Not in scope: `is'Not in scope: `b...
08:35:04 <elliott> DAMMIT GOOGLE YOU ARE INCONCLUSIVE
08:35:17 <elliott> "A full adder has three inputs: addend, augend and carry in and two outputs:
08:35:17 <elliott> sum and carry out. Carry in is 0 for the rightmost bit. Make a truth
08:35:17 <elliott> table and note that the exclusive or is very useful."
08:35:23 <elliott> STOP BEING A FUCKING SOCRATES TELL ME THE ANSWER
08:35:40 <elliott> aha
08:35:41 <elliott> Vorpal:
08:35:41 <elliott> Addition can be viewed as a sequence of bitwise operations.
08:35:41 <elliott> Exclusive or-ing the addend and augend yields all of the partial
08:35:41 <elliott> sum bits; while and-ing the addend and augend yields all of the
08:35:41 <elliott> carry bits. Shift the carry bits left one position.
08:35:43 <elliott> Put the partial sum in the addend.
08:35:45 <elliott> If there are no 1's in the carry bits, then you're done and the
08:35:47 <elliott> result of the addition is in the addend.
08:35:49 <elliott> Otherwise put the carry bits in the augend and repeat.
08:35:53 <elliott> So mine is actually just one step in a loop.
08:35:57 <Vorpal> elliott, indeed
08:36:07 <Vorpal> elliott, I said it wouldn't work like that :P
08:36:26 <Vorpal> and this explains why we use complex full adders and carry and so on instead
08:36:38 <Vorpal> elliott, what I don't get is why people don't use double adders or such lined up
08:36:44 <elliott> double the speed
08:36:54 <elliott> Lava> synthesiseHalfAdd
08:36:54 <elliott> Creating directory 'HalfAdd/'
08:36:55 <elliott> Writing to 'HalfAdd/HalfAdd.vhd'
08:36:57 <elliott> Done.
08:36:59 <elliott> HI-TEQUE
08:37:02 <Vorpal> elliott, not quite, but close I think.
08:37:10 <elliott> Vorpal: it was a joke but okay
08:37:19 -!- augur has joined.
08:37:24 <elliott> oh man type level naturals
08:37:27 <elliott> WHAT IS NOT THE BEST ABOUT THIS
08:37:35 <Vorpal> elliott, in circuitry you can trade speed for time to a large degree.
08:37:36 <Vorpal> err
08:37:39 <Vorpal> speed for space*
08:37:40 <Vorpal> I meant
08:37:50 <elliott> The function 'vat' indexes a vector.
08:37:50 <elliott> Lava> (13 :: Word N4) `vat` n2
08:37:50 <elliott> low
08:37:50 <elliott> A static type error is given if the index is out of bounds.
08:37:52 <elliott> WELL LAH DE DAH
08:38:11 <Vorpal> elliott, you could in *theory* do a 32-bit adder as a 2-level network of and and or gates for each output
08:38:19 <CakeProphet> !bfjoust anti_slowpoke_stolen_from_Deewiants +++(>)*8(>[++[-]]+)*21
08:38:26 <EgoBot> ​Score for CakeProphet_anti_slowpoke_stolen_from_Deewiants: 18.1
08:38:29 <Vorpal> elliott, the required space however would be stupidly large
08:39:17 <Vorpal> <elliott> A static type error is given if the index is out of bounds. <-- how is this different from vhdl? Array indexing going out of bounds would likely fail at synthesis
08:39:25 <CakeProphet> all Dewiant had to do was change his initial + to +++ to get a perfect score against slowpoke. :D
08:39:26 <elliott> Yeah, but it's at Haskell type-check time.
08:39:34 <elliott> (Haskell runtime is when the VHDL is output.)
08:39:42 <elliott> tl;dr Fancy type-level natural shit.
08:40:18 <elliott> {-# OPTIONS_GHC -fglasgow-exts -XUndecidableInstances -fcontext-stack=1024 #-}
08:40:20 <elliott> Always a good sign.
08:40:32 <Vorpal> elliott, oh btw vhdl synthesis is slow. I worked on systems with dual core 2 quads at university when I did that. For the basic stuff I did then it still took like half a minute
08:40:41 <elliott> Vorpal: Eurgh.
08:40:48 <Vorpal> elliott, expect synthesising redueron to be an over-nighter at least
08:41:04 <Vorpal> elliott, this is why you do simulation :P
08:41:14 <elliott> Xilinx provides a cool utility called Data2MEM. Given a bit-file,
08:41:14 <elliott> this utility can change the initial contents of a specified set of
08:41:14 <elliott> block RAMs. This allows us to change the program in the Reduceron's
08:41:14 <elliott> code memory without having to resynthesise, which would take ages.
08:41:26 <Vorpal> elliott, indeed
08:41:31 <Vorpal> elliott, overnighter at least :P
08:41:32 <elliott> York Lava provides the following constructs for writing behavioural
08:41:32 <elliott> descriptions.
08:41:33 <CakeProphet> woah no way, slowpoke vs slowpoke = tie
08:41:38 <elliott> this is the important part
08:41:39 <elliott> CakeProphet: No shit sherlock
08:41:48 <Vorpal> CakeProphet, of course a program ties against itself
08:42:20 <elliott> newMult :: N n => New (Mult n)
08:42:20 <elliott> newMult = return Mult `ap` newReg `ap` newReg `ap` newReg
08:42:20 <elliott> shiftAndAdd s =
08:42:20 <elliott> While (s!b!val =/= 0) $
08:42:20 <elliott> Seq [ s!a <== s!a!val!shr
08:42:21 <elliott> , s!b <== s!b!val!shl
08:42:24 <elliott> , s!b!val!vhead |>
08:42:26 <elliott> s!result <== s!result!val + s!a!val
08:42:28 <elliott> , Tick
08:42:30 <elliott> ]
08:42:32 <elliott> shr x = low +> vinit x
08:42:34 <elliott> shl x = vtail x <+ low
08:42:36 <elliott> prettyyyyyyyyy
08:42:38 <elliott> not ashamed of the spam
08:42:40 <elliott> that was pretty
08:42:42 <elliott> you all had to see it
08:43:07 <Vorpal> elliott, anyway I hope you like reading time graphs. Like these http://www.2lazy.nl/MartinsBlog/mpp_images/exp1_gtkwave.jpg (found by google image search)
08:43:19 <Vorpal> elliott, generally that is what you get from simulation
08:43:28 <elliott> Vorpal: Doesn't it have serial emulation? :P
08:43:55 <Vorpal> elliott, simulation for vhdl means writing a test program, that provides a set of input signals over time, then checking the output signals.
08:44:03 <elliott> LOOK AT ALL THESE VIBES OF MINE YOU'RE HARSHING
08:44:06 <Vorpal> elliott, so simulation for vhdl is very much like unit testing.
08:44:08 <elliott> LOOK AT THEM
08:44:12 <Vorpal> elliott, what
08:44:31 <elliott> "Making plans isn't the same as being alive!"
08:44:36 <Vorpal> elliott, anyway I don't know any vhdl simulation tool that lets you do interactive input to them
08:44:43 <elliott> Vorpal: :(
08:45:08 <Vorpal> elliott, vhdl is very... enterprisy.
08:45:22 <elliott> MAKES A MAN WANT TO BECOME A RENEGADE AND USE VERILOG ALL HIS LIFE
08:45:28 <elliott> OR, ALTERNATIVELY, STAB HIS EYES OUT
08:45:38 <Vorpal> elliott, I have no clue about verilog, but isn't it pretty similar
08:45:50 <elliott> LESS WORDS
08:45:52 <Vorpal> elliott, also come on, vhdl has an ada/pascal like syntax. Who doesn't love that.
08:45:57 <elliott> EVERYONE
08:46:09 <CakeProphet> dude slowpoke is ridiculous.
08:46:17 <elliott> CakeProphet: Reading the explanation of it?
08:46:42 <CakeProphet> the stuff that's in the source code anyways
08:46:50 <elliott> CakeProphet: it's generated, don't bother
08:46:55 <Vorpal> elliott, anyway I can't find any traces of the 7-valued logic in york lava.
08:47:01 <Vorpal> elliott, that will be "fun" then
08:47:02 <elliott> Vorpal: btw the York Lava code for Reduceron is actually quite readable.
08:47:18 <elliott> emulator/emu.c is still the most understandable bit of code though :P
08:47:26 <Vorpal> heh
08:47:38 <Vorpal> -- | A time-varying binary signal is clasically a list of booleans.
08:47:38 <Vorpal> type Signal = [Bool]
08:47:49 <Vorpal> elliott, yep, york lava's Bit is 2-valued
08:47:53 <Vorpal> elliott, sad
08:48:01 <elliott> Vorpal: Why's that sad :P
08:48:28 <Vorpal> elliott, because ieee.std_logic_1164 is a lot more useful in practise than vhdl's built in 2-valued logic
08:48:34 <elliott> Why :P
08:48:42 <Vorpal> elliott, see http://en.wikipedia.org/wiki/IEEE_1164
08:49:01 <Vorpal> elliott, it allows you to detect conflicting signals, like two strong drives on the same wire and what not
08:49:06 <elliott> Well don't do that then.
08:49:16 <Vorpal> elliott, and you can do weak drive, very useful
08:49:19 <elliott> I like how it's seven-valued but actually nine-valued.
08:49:22 <Vorpal> and high impedance of course
08:49:36 <Vorpal> err
08:49:40 <Vorpal> elliott, typo on my part then
08:49:46 <elliott> No, it's called seven-valued, I think.
08:49:48 <Vorpal> elliott, it was about a year ago I last used vhdl
08:49:50 <elliott> Because two values don't count.
08:49:53 <elliott> Uninitialised and don't care.
08:49:54 <elliott> I think.
08:49:56 <elliott> But still. So stupid.
08:50:04 <Vorpal> elliott, don't care is utterly useful
08:50:14 <elliott> Yeeeeees :P
08:50:14 <Vorpal> elliott, for example
08:50:23 <Vorpal> elliott, lets say you want to drive a 7-segment display
08:50:39 <Vorpal> and you get the input on 4 wires, so BCD coding basically (same as binary in this interval)
08:50:42 <elliott> And you wanted one of them to flicker on and off at random whims because "hey, I don't care".
08:50:43 <elliott> RIGHT?????
08:51:05 <Vorpal> elliott, that means that some of the input combinations are not valid. Which means you can output whatever is easiest on those
08:51:15 <Vorpal> since they never happen
08:51:21 <Vorpal> this can simplify gates and so on
08:51:25 <elliott> Heh :P
08:51:34 <elliott> An impossible branch just trailing off to the edge of the circuit.
08:51:36 <Vorpal> elliott, so yes don't care is very useful
08:51:42 <elliott> The impossible happens => circuit catches fire
08:51:43 <CakeProphet> elliott: I don't understand how these programs know when to reverse their polarity without relying on any kind of temporary variable.
08:51:43 <elliott> IT SAVED GATES
08:51:56 <elliott> CakeProphet: Nested branches. Lots and lots and lots of nested branches.
08:51:59 <elliott> Lots of nested branches.
08:52:00 <elliott> Tripwires.
08:52:00 <elliott> Lots of nested branches.
08:52:04 <elliott> CakeProphet: Read the ENTIRE strategy pages.
08:52:04 <Vorpal> elliott, let me get a real example of this. I have it on a paper somewhere
08:52:07 <elliott> CakeProphet: That INCLUDES all the program summaries.
08:52:09 <Vorpal> ah yes found it
08:53:17 <Vorpal> for the first segment in a 7-segment display (the upper on on the left side) we can do this given the inputs A,B,C,D: C+A+BC+D'B' where ' is "invert previous symbol"
08:54:12 <elliott> Nice :P
08:54:14 <Vorpal> elliott, this gives the right outputs for 0-9, which is the valid domain. However, it will give strange results for the values not allowed. Basically don't care means that the compiler can optimise without regard to what the result of these undefined values will be
08:54:29 <Vorpal> elliott, which in this case hugely simplifies the logic
08:54:30 <elliott> Where do you actually specify don't care there?
08:54:58 <Vorpal> elliott, well in the example I gave, I did it in the Karnaugh diagram I made on paper. I did this example for redstone logic, so no vhdl here
08:55:13 <elliott> Does redstone have don't care? :P
08:55:52 <Vorpal> elliott, no, but it doesn't matter. Because it is used so that I can assign that specific combination whatever value is easiest
08:55:54 <Patashu> redstone, a robust model for circuitry
08:55:59 <Vorpal> Patashu, har.
08:56:02 <Patashu> (lol)
08:56:20 <Vorpal> elliott, http://en.wikipedia.org/wiki/Karnaugh_map
08:56:32 <elliott> oh, you mean you did not actually write C+A+BC+D'B'
08:56:38 <elliott> but a diagram with each input/output enumerated
08:56:38 <elliott> right
08:57:03 <Vorpal> elliott, yes, then I try to encircle power of two sizes in the diagram. The larger area, the simpler the gate
08:57:17 <Vorpal> elliott, thus for don't care values I can encircle them *if* it would make the area greater.
08:57:29 <elliott> I AM SO GLAD I LIVE IN THE WORLD OF HAPPY DIGITAL BINARY LOGIC.
08:57:31 <elliott> IT'S SO FUCKING AWESOME.
08:57:52 <elliott> I'ma ask ais if his ALGOL compiler outputs code with that fancy seven-valued stuff so I don't have to :P
08:58:04 <elliott> And then spend two whole years coercing him out of his overly-legalistic mindset so that I can get a leaked copy.
08:58:12 <elliott> THIS IS MORE PRODUCTIVE THAN ATTEMPTING TO UNDERSTAND VHDL
08:58:20 <Vorpal> elliott, another case. Data bus. You definitely want the value Z there (high impedance)
08:58:33 <elliott> OBVIOUSLY
08:59:07 <Vorpal> elliott, well, you have to basically disconnect from sending to the data bus when you aren't sending
08:59:14 <Vorpal> elliott, this is done by high impedance
08:59:29 <Vorpal> if you didn't, then you would drive it to zero or to one all the time. Not a good idea.
08:59:50 <Vorpal> elliott, read the introduction to http://en.wikipedia.org/wiki/Tri-state_buffer
09:00:07 <elliott> Vorpal: http://www.altera.com/products/devkits/altera/kit-cyc3-starter.html How shitty is this.
09:00:20 <elliott> It's ubercheap which is nice.
09:00:30 <Vorpal> elliott, I have never used altera. But it looks like York lava is xlinix specific
09:00:40 <elliott> But actually it's the most expensive Altera starter kit that isn't completely unaffordable.
09:00:49 <elliott> I mean ignoring things like "Cyclone IV GX Transceiver Starter Kit" which is just, what is that even.
09:01:02 <elliott> Vorpal: I was just asking for opinions on the specs.
09:01:12 <Vorpal> trying to find them on the page atm..
09:02:04 <Vorpal> elliott, where is the spec for the actual FPGA found on that board
09:02:24 <elliott> You mean Cyclone III?
09:02:25 <Vorpal> elliott, you just gave me the spec for the board itself
09:02:27 <elliott> Or something more specific?
09:02:30 <Vorpal> "Cyclone III EP3C25F324 FPGA"
09:02:32 <Vorpal> that one
09:02:34 <elliott> http://www.altera.com/products/devices/cyclone3/cy3-index.jsp
09:02:40 <elliott> http://www.altera.com/products/devices/cyclone3/overview/cy3-overview.html has model info.
09:03:00 <elliott> 24,624 logic elements it seems?
09:03:05 <Vorpal> yep
09:03:07 <elliott> That is... piddly, isn't it.
09:03:13 <Vorpal> probably not enough for redueron no
09:03:19 <Patashu> high impedence means you'll be overwritten by any other value, right?
09:03:22 <Vorpal> remember 2000 was less than 1%
09:03:23 <elliott> One of the Reduceron papers said twenty-k was less than one percent of their capacity.
09:03:28 <elliott> It was twenty-k
09:03:30 <elliott> not two-k
09:03:35 <elliott> Vorpal: I realise that I've no hope of running the Reduceron
09:03:43 <elliott> oh wait
09:03:44 <Vorpal> Patashu, err, more like *you* won't overwrite anyone else
09:03:45 <elliott> it was two-k yeah
09:03:57 <elliott> Vorpal: But still, is that enough to ... do anything with?
09:04:00 <Patashu> what's the result if two signals conflict?
09:04:08 <Vorpal> elliott, ask ais on that
09:04:12 <Vorpal> Patashu, X
09:04:13 <elliott> Vorpal: Gah :P
09:04:27 <elliott> Can you make an FPGA catch fire with VHDL? Say yes.
09:04:43 <Vorpal> elliott, possibly you could make it overheat if there isn't adequate cooling
09:05:10 <Vorpal> elliott, hm 594 kilobits
09:05:13 <Vorpal> not a lot of ram
09:05:38 <elliott> It has megabytes doesn't it?
09:05:40 <elliott> Just on the board.
09:05:55 <Vorpal> elliott, yes but that will be somewhat more annoying to access you see
09:06:02 <Vorpal> elliott, for a start it will be fixed to byte IO
09:06:30 <Vorpal> elliott, likely they only provide the library of vhdl modules to access it in some more expensive edition
09:06:51 <elliott> Vorpal: I'm tempted to build my own little York Lava-esque thing where absolutely everything is done at the bit level :P
09:07:06 <elliott> Thirty-two-bit word? Why, that's just thirty-two bits in a tuple.
09:07:07 <Vorpal> elliott, hm? But with 7-valued logic?
09:07:11 <elliott> NO, NICE BINARY EVERYTHING
09:07:17 <elliott> BINARY LOVE HAPPY EVERYTHING NICE YUM HAPPINESS HUGS ALWAYS
09:07:17 <Patashu> 9-valued logic!
09:07:19 <Patashu> or possibly more
09:07:21 <Vorpal> <elliott> Thirty-two-bit word? Why, that's just thirty-two bits in a tuple. <-- vhdl does this :P
09:07:40 <Vorpal> Patashu, not sure what more useful values you could add
09:07:42 <elliott> Vorpal: Then byte IO to RAM is indeed inconvenient... it's eight times too much!!!!!
09:07:54 <Vorpal> elliott, eh
09:08:31 <Vorpal> # Quartus® II Web Edition (FPGA design software)
09:08:31 <Vorpal> # ModelSim®-Altera Web Edition (FPGA simulation software from ModelSim)
09:08:33 <Vorpal> web edition?
09:08:35 <elliott> Web edition.
09:08:38 <Vorpal> what the crap is that
09:08:40 <elliott> That... sure is... promising...
09:08:45 <elliott> WHAT HAVE THEY COME UP WITH THIS TIME
09:08:58 <Vorpal> elliott, yes, the thing is, the software is what they really charge you for
09:09:16 <Vorpal> elliott, the FGPA itself is relatively cheap compared to the software for developing
09:09:22 <elliott> It's like Macs, except that nobody actually wants to use the software at all.
09:09:43 <elliott> Vorpal: Do the synthesisers have a command-line interface?
09:09:52 <Vorpal> no clue
09:09:56 <elliott> Frankly if I can avoid creating a single "project" or "solution", it will not bother me in the slightest.
09:09:57 <elliott> :p
09:10:08 <CakeProphet> well, the barrier of entry on bfjoust is too steep now. So I think I'm going to not pursue that anymore and get some sleep.
09:10:17 <Vorpal> elliott, let me check a project directory from xilinix stuff
09:10:35 <elliott> CakeProphet: Is that... surrender I hear?
09:10:42 <elliott> I thought you were going to spend a week on this : (
09:10:55 <elliott> Vorpal: Unfortunately Xilinix's site is a huge huge pain to navigate.
09:10:56 <Vorpal> elliott, this was from a lab at university:
09:10:58 <Vorpal> $ ls
09:10:58 <Vorpal> automake.log full_blink.cmd_log full_blink.lso full_blink.pad full_blink.syr full_blink.ucf _impact.cmd Project.dhp vsim.wlf
09:10:58 <Vorpal> blinkers.dhp full_blink.data full_blink.mfd full_blink_pad.csv full_blink_tb.fdo full_blink.ucf.untf _impact.log __projnav _xmsgs
09:10:58 <Vorpal> blinkers.ise full_blink.gyd full_blink.mod full_blink.pnx full_blink_tb.udo full_blink.vhd _ngo __projnav.log xst
09:11:00 <Vorpal> blinkers.ise_ISE_Backup full_blink._hrpt full_blink.ngc full_blink.prj full_blink_tb.vhd full_blink.vm6 _pace.ucf tmperr.err
09:11:03 <Vorpal> full_blink.bld full_blink.jed full_blink.ngd full_blink.rpt full_blink.tim full_blink.xml pepExtractor.prj transcript
09:11:06 <Vorpal> full_blink_build.xml full_blink.lfp full_blink.ngr full_blink.stx full_blink._trpt half_blink.vhd prjname.lso work
09:11:06 <CakeProphet> no I'm not good at programming in brainfuck, and I definitely wouldn't know code to generate if I tried that.
09:11:09 <Vorpal> (sorry for the spam)
09:11:22 <elliott> CakeProphet: BF Joust is nothing like BF programming really
09:11:23 <coppro> .win 17
09:11:25 <elliott> Vorpal: Like, I literally yelled at the computer trying to navigate the site.
09:11:26 <Vorpal> elliott, a number of those are directories :P
09:11:29 <elliott> Multiple times.
09:11:43 <elliott> It _refuses_ to answer the question "what starter kits do you have?".
09:11:44 <Vorpal> elliott, I'm a bit scared about "automake.log"
09:11:52 <elliott> It _refuses_ to give a flat list of all kits that are available with the prices on the same page.
09:11:52 <Vorpal> it is empty though
09:11:55 <elliott> It is the _worst site ever_.
09:13:08 <Vorpal> heh
09:13:24 <CakeProphet> elliott: no, this is the worst website: http://www.angelfire.com/super/badwebs/
09:13:46 <elliott> this site is way too preachy
09:13:48 <elliott> F-
09:14:05 <elliott> basically this guy is jealous of everyone's web pages for looking far more cool than his which are probably all boring
09:14:13 <elliott> "Misspelled werds and impropr punktuation, make yur web look amaturish, and unfinishd. Awlays run a spel chek befor yu uplode!!!!!! : )"
09:14:16 <elliott> WHAT A FUKEN HYPOCRITES
09:14:29 <Vorpal> elliott, I hope this is a case of Poe's law
09:14:38 <Patashu> really
09:14:39 <elliott> Vorpal: whoosh
09:14:46 * elliott stabs Vorpal a bit.
09:14:48 <Patashu> a deliberately bad web page about bad web pages is...
09:14:53 <Patashu> ?_?
09:14:54 <Patashu> a fake?????
09:14:55 <Patashu> woah
09:14:59 <Patashu> never saw it coming
09:15:10 * Vorpal does a strong drive on the bit in "stabs a bit"
09:15:16 <Vorpal> elliott, hah, X!
09:15:46 <CakeProphet> also: http://www.dokimos.org/ajff/
09:15:51 <Patashu> is there a document somewhere that explains all the interactions betweeen states in 9 state logic?
09:16:03 <elliott> CakeProphet: god i love this one
09:16:07 <Vorpal> Patashu, a text book perhaps
09:16:12 <Patashu> probably lol
09:16:20 <elliott> unfortunately the front page is way better than all the others
09:16:26 <Vorpal> Patashu, anyway you generally don't mix them randomly
09:16:44 <Patashu> no I don't imagine you would
09:17:35 <Vorpal> Patashu, for a start Z only makes sense for an output.
09:17:46 <Patashu> war on drugs -> cryptography?? http://falkvinge.net/2011/06/07/weed-as-surprise-driver-for-mass-cryptoproficiency/
09:18:46 <elliott> war on cryptography -> drugs!
09:18:55 <Patashu> \o/
09:18:55 <myndzi> |
09:18:56 <elliott> cryptography on drugs -> war!
09:18:56 <myndzi> /´\
09:19:01 <elliott> war cryptography -> drugs on!
09:19:02 <Patashu> oh god text penis
09:19:09 <elliott> on! war -> drugs cryptography
09:19:51 <Vorpal> elliott, anyway I can't imagine you would like to program for FPGAs.
09:20:05 <Vorpal> elliott, it is far too low level
09:20:14 <elliott> its declarative
09:20:16 <elliott> and hey i wrote a bootloader
09:20:20 <elliott> HAVE YOU WRITTEN A BOOTLOADER ASSHOLE
09:20:22 <Vorpal> elliott, vhdl and verilog makes asm seem high level
09:20:34 <elliott> THINGS YOU HAVE NOT WRITTEN: A BOOTLOADER ASSHOLE
09:20:39 <Vorpal> elliott, in asm you do ADD r1,r2. In VHDL you write a page of code to do it
09:20:50 <Vorpal> same for verilog
09:21:01 <Patashu> once you have a circuit for adding can't you just reuse it?
09:21:13 <Vorpal> Patashu, yes indeed, but that takes a page of code :P
09:21:24 <Patashu> but you only have to do it once
09:21:27 <Vorpal> Patashu, besides, what about carry forwarding
09:21:31 -!- MigoMipo has joined.
09:21:39 <Vorpal> that would be annoying
09:21:48 <Vorpal> I mean a ripple carry adder is pretty simple
09:22:03 <elliott> yeah so you have to define addition so what
09:22:33 <Patashu> but can you define...division?
09:22:34 <Patashu> dun dun dun
09:22:42 <Vorpal> annoyingly hard likely
09:22:57 <elliott> Patashu: no.
09:23:05 <elliott> the mathematical impossibility of division is why arithmetic never really caught on.
09:23:06 <Vorpal> elliott, well the main issue is making things sequential when you need it. Everything sequential essentially has to be written as a clocked finite state machine
09:23:14 <Patashu> division sucks and dead
09:23:16 <Patashu> rip maths
09:23:17 <elliott> Vorpal: that's not hard.
09:23:21 <elliott> just have a global clock, woop pow done.
09:23:23 <Vorpal> elliott, no, but it is verbose
09:23:28 <Vorpal> elliott, and of course you have a global clock
09:23:39 <elliott> how do you do it clocklessly, anyway?
09:23:58 <Vorpal> elliott, well you can do that for purely combinatorial circuits.
09:24:11 <elliott> explain :P
09:24:12 <Vorpal> or do you mean the crazy sort of advanced clockless?
09:24:21 <Vorpal> like that clockless MIPS CPU?
09:24:24 <elliott> Explain both :P
09:24:50 <Vorpal> elliott, combinatorial circuits: output = logical expression of inputs, no memory of previous state
09:25:04 <Vorpal> for example. the 7-segment display. It doesn't have to keep track of previous state
09:25:11 <elliott> so nothing that requires more than one step to express at all?
09:25:40 <Vorpal> elliott, pretty much. You can express any such expression as a 2-level network of and + or gates (plus inverters before sometimes)
09:25:52 <Vorpal> or nand-nor
09:25:56 <elliott> OK, now what about the crazy sort of advanced clockless? :P
09:25:59 <elliott> But, like, at a slower scale.
09:26:01 <elliott> Clockless addition, say.
09:26:11 <elliott> Would it just have a local clock?
09:26:22 <Vorpal> well addition is clockless. Just wait for all the ripples to get through before reading the result.
09:26:29 <Vorpal> just make your clock slow enough
09:26:34 <Vorpal> a FA is not clocked after all
09:26:42 <Vorpal> but you have to take care of the gate delay
09:26:50 <Vorpal> which means that everything takes a finite time
09:27:00 <Vorpal> elliott, no clue how the super-advanced clockless CPUs work
09:27:03 <Vorpal> ask ais about that
09:27:07 <elliott> PAH
09:27:14 <elliott> The biggest disadvantage of the clockless CPU is that most CPU design tools assume a clocked CPU (i.e., a synchronous circuit). Many tools "enforce synchronous design practices".[4] Making a clockless CPU (designing an asynchronous circuit) involves modifying the design tools to handle clockless logic and doing extra testing to ensure the design avoids metastable problems. The group that designed the A
09:27:14 <elliott> MULET, for example, developed a tool called LARD to cope with the complex design of AMULET3.
09:27:21 <elliott> sure does sound painful
09:27:39 <Vorpal> likely
09:28:05 <Vorpal> metastability would be an issue yes
09:28:20 <Vorpal> clocked circuits nicely avoids that
09:28:23 <elliott> http://www.async.caltech.edu/mips.html ;; this paper isn't gonna be fun to read i guess :D
09:28:48 <elliott> the SEAforth multi-core processor (2008) from Charles H. Moore.[12]
09:28:48 <elliott> the GA144[13] multi-core processor (2010) from Charles H. Moore.
09:28:50 <elliott> oh sna
09:28:51 <elliott> p
09:28:53 <elliott> the chuck is in town
09:28:59 <elliott> and he ain't got no clocks
09:29:31 <Vorpal> eh
09:29:37 <elliott> The Honeywell CPUs 6180 (1972)[7] and Series 60 Level 68 (1981)[8][9] upon which Multics ran asynchronously
09:29:38 <elliott> hawt
09:29:46 <Vorpal> right
09:29:59 <elliott> SO WHAT IF YOU USED A SINE WAVE FOR A CLOCK LOL
09:30:16 <Vorpal> sounds stupid.
09:30:30 <elliott> ;D
09:30:41 <Vorpal> of course you don't get a square wave in practise, only reasonably close
09:31:43 <elliott> reassuring
09:31:50 <Vorpal> what
09:32:12 <Vorpal> elliott, come on, you can't do instantaneous voltage changes in reality...
09:32:33 <elliott> just saying, electronics is a lot less of a comfortable discipline than programming :D
09:32:41 <elliott> "well it's a square wave. ...sort of. physics kind of gets in the way."
09:32:47 <elliott> "uh, booleans. yeah. ours have 9 values..."
09:32:50 <Vorpal> elliott, har
09:33:06 <elliott> "oh well um... not using a clock might make your electronics just sort of fuck up and oscillate around."
09:33:13 <elliott> "but then that usually happens anyway."
09:33:17 <Vorpal> elliott, but yes. With vhdl and verilog you are working at a lower abstraction layer than when programming
09:33:18 <elliott> "we don't really know how to do any of this."
09:33:22 <elliott> "we're basically just bullshitting."
09:33:29 <elliott> "hello i am an electronics engineer and i suck."
09:33:31 <elliott> "elliott is awesome."
09:33:37 <elliott> "oh man i feel so good saying all these true things."
09:33:41 <Vorpal> ...
09:33:59 <elliott> ````It would have been better if images are included in the page
09:33:59 <elliott> --[[Talk:Fall time]]
09:34:00 <HackEgo> No output.
09:35:15 <Vorpal> elliott, just like haskell is a higher abstraction than asm, vhdl and verilog are on a lower level abstraction than asm. Of course both are still higher than EDA software...
09:35:32 <Patashu> EDA? :O
09:35:42 <Patashu> oh this
09:35:48 <Vorpal> Patashu, EDA is kind of like "well, lets place some p-type silicon here, and then some ...
09:35:52 <Vorpal> "
09:35:54 <Patashu> :D
09:36:01 <elliott> that sounds like fun
09:36:03 <elliott> does anyone actually do that?
09:36:33 <Vorpal> elliott, well yes, when designing ASIC for example
09:36:43 <Vorpal> elliott, they tend to have module based systems
09:36:46 <elliott> Vorpal: hmm, but surely Intel's Latest Fancy Processor isn't made by hand, right? :-P
09:37:02 <Vorpal> elliott, probably not, but designs for gate modules used might well be
09:37:04 <elliott> man... wouldn't it be cool to see the source code to the i7??????
09:37:36 <elliott> i wonder who has less ugly designs from a maintenance point of view, amd or intel :P
09:37:51 <nooga> elliott: i've read the memo 23
09:38:23 <Vorpal> elliott, the FP parts are likely auto generated
09:38:27 <elliott> nooga: that seems to be what YorkLava.txt is
09:38:29 <Vorpal> and formally verified
09:38:30 <elliott> Vorpal: FP?
09:38:33 <elliott> oh, floating point, right
09:38:36 <Vorpal> yeah
09:38:38 <elliott> well who cares about that.
09:39:13 <Vorpal> heh
09:39:31 <elliott> man, the York Lava specification of that simple stack machine is really pretty.
09:39:37 <nooga> yeah
09:39:43 <elliott> nicer than vhdl :P
09:39:54 <Vorpal> of course
09:40:11 <elliott> The function 'simPoly' has almost the same type has 'eval', and it is
09:40:11 <elliott> straightforward to define a correctness property for the processor.
09:40:11 <elliott> prop_poly :: Expr -> Integer -> Bool
09:40:11 <elliott> prop_poly e x = eval e x == wordToInt (simPoly e x)
09:40:12 <elliott> :D
09:40:17 <elliott> QuickCheck for hardware
09:40:34 <Vorpal> elliott, of course york lava is not quite as general as vhdl.
09:40:47 <Vorpal> likely there are things you can't do directly in york lava
09:41:01 <elliott> Vorpal: yeah but why would you want to.
09:41:17 <Vorpal> elliott, tri-state buffers looks like one case
09:41:24 <elliott> (I know, I know, "why would you want to create your own hardware anyway"...)
09:43:38 <Patashu> "America is in crisis, " the Republican governor says on a website promoting the event. "We have been besieged by financial debt terrorism, and a multitude of natural disasters."
09:43:38 <Patashu> ugh
09:43:41 <Patashu> FINANCIAL DEBT TERRORISM
09:43:47 <Patashu> the word terrorism is quickly becoming meaningless
09:44:25 <Patashu> <Patashu> haskell is shit!!! <elliott> OMG IRC TERRORISM
09:45:32 <elliott> Patashu: that was... so rude of you to... impersonate me......
09:45:35 <elliott> nick terrorism.............
09:45:41 <elliott> Nick Terrorism, superhero
09:45:54 <Patashu> don't you mean supervillain
09:45:58 -!- elliott has set topic: Programming terrorism: the channel | Logs: http://codu.org/logs/_esoteric/ and http://tunes.org/~nef/logs/esoteric/?C=M;O=D.
09:45:59 <elliott> Patashu: no
09:46:01 <Patashu> lol
09:46:07 -!- elliott has left ("Leaving").
09:46:12 <Vorpal> what
09:46:14 -!- elliott has joined.
09:46:15 <elliott> oops
09:46:16 <Patashu> NIC terrorism
09:46:19 <Patashu> what I am doing to you atm
09:46:20 <elliott> Patashu: he nicks terrorism
09:46:21 <elliott> that is
09:46:22 <elliott> he steals terrorism
09:46:23 <elliott> from societ
09:46:24 <elliott> y
09:46:25 <Patashu> accept my unsolicited IP packets
09:46:26 <elliott> and safely deposits it
09:46:27 <Patashu> ooooh
09:46:28 <elliott> in the TRASH
09:46:29 <Patashu> clever
09:46:31 <elliott> OHHHHHHH YEAAAAAAAAAAAH
09:46:36 <elliott> S/ [DOLLAR SIGN]//
09:46:38 <elliott> s/caps/not caps/
09:46:51 <cheater_> http://www.gravatar.com/avatar/fb7188d8be002ece64870dffe9ec6fa7?s=32&d=identicon&r=PG
09:47:22 <nooga> elliott: F-lite implementation is interesting itself
09:47:37 <elliott> nooga: it is?
09:52:27 <elliott> nooga: it is?
09:55:36 <elliott> nooga: it is?
09:55:37 <elliott> nooga: it is?
09:55:37 <elliott> nooga: it is?
09:55:38 <elliott> nooga: it is?
09:55:38 <elliott> nooga: it is?
09:56:28 <nooga> i think so
09:56:35 <elliott> howso?
10:00:08 <nooga> because it's simple and can be used as an example when writing a minimal, lazy, functional language
10:00:43 <elliott> well sure
10:01:12 <elliott> the modules are awfully broken up
10:01:21 <Vorpal> what is f-lite?
10:01:31 <elliott> Vorpal:
10:01:32 <elliott> F-lite is a core subset of Haskell. Unlike GHC Core and Yhc Core,
10:01:32 <elliott> F-lite has a concrete syntax. You can write F-lite programs in a
10:01:32 <elliott> file, and pass them to the F-lite interpreter or compiler. Another
10:01:32 <elliott> way to view F-lite is as a minimalist lazy functional language.
10:01:36 <elliott> a symbolic term-rewriting language
10:01:37 <Vorpal> ah
10:01:39 <elliott> that compiles to the reduceron
10:01:45 <elliott> and is the main programming language for it
10:01:55 <Vorpal> ah
10:01:58 <elliott> it's actually not quite a subset, since you omit data declarations
10:02:03 <elliott> so valid f-lite programs aren't necessarily valid haskell programs
10:02:05 <elliott> also it's untyped
10:02:06 <elliott> but yeah
10:06:29 <elliott> hey guys what's a good abbreviation for root
10:06:32 <elliott> as in square root, cube root, ...
10:06:35 <Patashu> rt
10:06:36 <Patashu> normally
10:06:38 <elliott> three letter
10:06:48 <Patashu> too bad
10:06:51 <Patashu> there's only a two letter one
10:07:10 <elliott> :(
10:07:13 <elliott> but Rot is weird :P
10:07:13 <Patashu> rot sounds like rotate, rut doesn't sound like anything...
10:07:28 <Patashu> why not use root(a,b) = pow(a,1/b)
10:07:29 <Patashu> or something
10:07:32 <Patashu> then say pow
10:07:36 <elliott> Oh well, I guess I'll call it Root
10:07:57 <Vorpal> elliott, anything wrong with "root"
10:08:01 <Vorpal> why would it have to be 3 letters
10:08:11 <elliott> Consistency :P
10:08:16 <elliott> data BinOp = Add | Sub | Mul | Div
10:08:16 <elliott> | Exp | Root | Log | Mod
10:08:16 <elliott> | Eq | Lt | Gt
10:08:16 <elliott> deriving (Show)
10:08:17 <elliott> :P
10:08:30 <Vorpal> elliott, you have three two letter ones
10:08:34 <Patashu> you don't need root if you have pow
10:08:37 <Vorpal> elliott, so why not Rt as said above
10:08:51 <Vorpal> elliott, and what is this for
10:08:53 <elliott> Yeah yeah :P
10:08:56 <elliott> Patashu: I do, it's in the spec
10:08:58 <elliott> Vorpal: SyL
10:09:02 <Patashu> hmm OK then
10:09:03 <Vorpal> elliott, esolang?
10:09:12 <elliott> Yes; I'm implementing it solely because I can call the result sylladex.
10:14:39 <elliott> hmm
10:14:45 <elliott> if "PRINT 9" is a statement, what would you call PRINT?
10:14:48 <elliott> people usually talk about like
10:14:50 <elliott> the PRINT statement
10:14:52 <elliott> but that's ambiguous :/
10:14:55 <elliott> the PRINT <???>
10:14:56 <elliott> command?
10:14:56 <Deewiant> Command
10:15:13 <Patashu> command, function, method, subprogram
10:15:21 <Patashu> action
10:15:31 <nooga> word
10:15:51 <elliott> Command should work, thanks
10:23:06 <nooga> what are you doing?
10:25:49 -!- Sgeo has joined.
10:26:51 <elliott> nooga: syl
10:34:32 <Sgeo> !
10:35:42 <elliott> Sgeo: what
10:35:48 <elliott> oh did you die of melatonin
10:35:51 <Sgeo> The update
10:36:23 <elliott> oh right that
10:36:32 <elliott> fucking scratch pulled the fucking beta timeline bullshit
10:36:36 <elliott> asshole
10:36:43 <elliott> also slick is very holy.
10:36:59 <Sgeo> lol
10:39:26 <Sgeo> I formed a hypotheses around the beginning of this update, the ending discarded it
10:46:20 <elliott> hmm, is n+0 -> n constant folding or dead code elimination?
10:50:43 <Deewiant> Instruction simplification
10:51:15 <Deewiant> It's not constant folding unless n is constant
10:52:10 <Deewiant> And DCE is for code that's never run, not code that does nothing
10:54:29 <elliott> Deewiant: My "constant folding" pass does instruction simplification too, then :P
10:54:36 <elliott> I suppose it's not all that unreasonable to interleave the two passes.
11:00:45 <nooga> syl?
11:00:55 <elliott> nooga: it's this semi-decent language.
11:01:00 <nooga> any spec?
11:01:59 <elliott> uh i didn't write it
11:02:01 <elliott> it's on the esowiki
11:02:12 <elliott> but hands off, i'm over-engineering implementing it >:|
11:16:23 -!- sebbu2 has joined.
11:16:23 -!- sebbu2 has quit (Changing host).
11:16:23 -!- sebbu2 has joined.
11:18:42 -!- sebbu has quit (Ping timeout: 240 seconds).
11:18:42 -!- sebbu2 has changed nick to sebbu.
11:19:18 <oklopol> "<Patashu> why not use root(a,b) = pow(a,1/b)" <<< how about Wop
11:20:38 <oklopol> 3 to the wopper of 2
11:21:51 <elliott> lol
11:27:14 <Patashu> LOL
11:27:39 <oklopol> Zwaarddijk: i saw your bachelor's supervisor today and he was bragging about his finnish skills
11:28:59 <oklopol> g2g ~>
11:29:11 <elliott> lol
11:30:33 <elliott> -- lt and gt can wait i am so fucking lazy
11:30:33 <elliott> -- also all the others, fuck this shit
11:46:13 -!- PatashuPikachuRe has joined.
11:46:50 -!- Patashu has quit (Ping timeout: 250 seconds).
11:47:51 <elliott> Maybe (Either Expr Value)... gross
11:58:20 <elliott> *Sylladex.Optimise> constFold (EBinOp Add EReadChar (EBinOp Add (EConst (VInt 0)) (EConst (VInt 0))))
11:58:20 <elliott> EReadChar
11:58:24 <elliott> Hooray.
11:58:29 <elliott> Now for EVEN MORE SPECIAL CASING.
11:59:07 <elliott> *Sylladex.Optimise> constFold (EBinOp Sub (EBinOp Add EReadChar (EConst (VInt 9))) (EConst (VInt 9)))
11:59:07 <elliott> EBinOp Sub (EBinOp Add EReadChar (EConst (VInt 9))) (EConst (VInt 9))
11:59:17 <elliott> This still needs some handling; re-arranging things is gonna be pretty ugly, though.
12:18:19 -!- copumpkin has joined.
12:20:14 -!- BeholdMyGlory has joined.
12:33:15 -!- FireFly has joined.
12:40:25 -!- foocraft has joined.
12:41:00 <nooga> aaaa
12:41:03 <nooga> i must code
12:41:11 <nooga> i have a concrete idea what to code
12:41:18 <nooga> and skills to code it
12:41:30 <nooga> but i'm procrastinating
12:43:58 <elliott> what is the idea
12:44:55 -!- pikhq_ has joined.
12:45:26 -!- pikhq has quit (Ping timeout: 260 seconds).
12:49:17 <elliott> nooga: WE DEMAND YOU TELL US
12:57:40 -!- Kustas has joined.
13:09:50 <CakeProphet> I am forward thinking in that, after a thought, it is now the future.
13:10:41 -!- Kustas_ has joined.
13:12:30 <elliott> CakeProphet: wat
13:13:08 -!- Kustas has quit (Ping timeout: 258 seconds).
13:13:09 -!- Kustas_ has changed nick to Kustas.
13:17:25 -!- ais523 has joined.
13:19:10 <elliott> hi ais523
13:19:10 <elliott> fpga
13:19:11 <elliott> what should i
13:19:13 <elliott> and the
13:19:31 <CakeProphet> elliott: compare to the situation in which I thought in reverse.
13:19:42 <ais523> hmm, I think I need more words to work out what the sentence means
13:20:28 <elliott> ais523: fpga buy kit affordable but is usable i had links but now i don't in clipboard and the fpga and also which of duopoly has support better linux
13:20:32 <elliott> what should i and the
13:20:45 <ais523> ah, I see
13:21:06 <elliott> thank god
13:21:16 <ais523> also, I think they both claim native support for Linux
13:21:27 <CakeProphet> elliott: let a thought be a string X where blah blah blah blah blah time goes backwards when I think.
13:21:28 <ais523> Xilinx's tools showed huge signs of running on Cygwin, when I tried them on Windows
13:21:31 <elliott> yes but that doesn't mean it's any _good_
13:21:34 <ais523> yep
13:21:46 <ais523> I know we're using Altera tools at the moment, because we couldn't figure out the Xilinx stuff at all
13:21:50 <elliott> i'm basically asking which is more tolerable, but actually, Xilinx seem to be a lot more expensive than Altera
13:21:54 <elliott> even for the evaluation boards
13:22:09 <elliott> the Reduceron stuff was done with Xilinx, but that's basically academic since there's no way I could afford anything that could fit it
13:22:14 <ais523> I think it's marketed at managers rather than programmers
13:22:24 <elliott> although being able to use York Lava would be a perk, and it compiles to Xilinx-specific VHDL
13:22:33 <elliott> (York Lava is the declarative Haskell library used to define the Reduceron)
13:22:43 <elliott> (it uses two-valued logic exclusively :-----O)
13:23:41 <elliott> ais523: I was also meaning to ask: how efficient is the code your ICA → VHDL compiler outputs?
13:24:08 <ais523> elliott: possibly not as good as code generated by hand, but much the same order of magnitude
13:24:28 <ais523> apart from it doesn't do pipelining yet, but we may fix that at some point
13:24:44 <elliott> I think York Lava may be similar; the actual basis of it is fairly direct mucking with signals, but it has a bunch of sequential stuff that probably generates less-than-ideal code
13:24:50 <ais523> I know what Lava is about
13:25:04 <elliott> I meant,
13:25:04 <ais523> I'd get in trouble if I didn't
13:25:06 <elliott> in terms of efficiency
13:25:10 <ais523> ah
13:25:24 <ais523> well, Lava is just a really good language for expressing circuits designed by hand
13:25:32 <elliott> yep, but there's also things like
13:25:38 <elliott> let instr = s!code!top in
13:25:39 <elliott> Seq [ Tick
13:25:39 <elliott> , While (instr!isHALT!inv) $
13:25:39 <elliott> Seq [ isLIT instr |> s!rtop <== getLIT instr
13:25:39 <elliott> , isDUP instr |> s!stack!push (s!rtop!val)
13:25:39 <elliott> , isREV instr |>
13:25:39 -!- ais523 has quit (Read error: Connection reset by peer).
13:25:41 <elliott> Seq [ s!rtop <== s!stack!top
13:25:43 <elliott> , s!stack!pop
13:25:45 <elliott> [...]
13:25:47 <elliott> which is decidedly not at...
13:25:48 <PatashuPikachuRe> yeah it's tough, we don't get eruptions around here so I never have enough of the stuff
13:25:49 <elliott> ugh great time to drop connection
13:25:53 <PatashuPikachuRe> and it's so viscious and slow to propagate
13:26:10 -!- PatashuPikachuRe has changed nick to Patashu.
13:26:13 <elliott> you know what ELSE Is viscous and slow to propagate??
13:26:15 <elliott> that's right
13:26:16 <elliott> oil.
13:26:23 <Patashu> idgi
13:26:25 -!- ais523 has joined.
13:26:28 <elliott> ais523:
13:26:32 <elliott> <ais523> well, Lava is just a really good language for expressing circuits designed by hand
13:26:32 <elliott> <elliott> yep, but there's also things like
13:26:32 <elliott> <elliott> let instr = s!code!top in
13:26:32 <elliott> <elliott> Seq [ Tick
13:26:32 <elliott> <elliott> , While (instr!isHALT!inv) $
13:26:33 <elliott> <elliott> Seq [ isLIT instr |> s!rtop <== getLIT instr
13:26:35 <ais523> the remote host closed the connection, for no reason at al
13:26:35 <elliott> <elliott> , isDUP instr |> s!stack!push (s!rtop!val)
13:26:37 <elliott> <elliott> , isREV instr |>
13:26:39 <elliott> <elliott> Seq [ s!rtop <== s!stack!top
13:26:41 <elliott> <elliott> , s!stack!pop
13:26:43 <elliott> which is decidedly not at the level of the low level stuff
13:26:47 <ais523> well, no obvious good reason, anyway
13:26:50 <elliott> or even VHDL
13:27:11 <ais523> it still looks pretty low-level
13:27:27 <elliott> certainly, but my understanding is that "While" and "Seq" are distinctly higher-level concepts than VHDL offers
13:28:32 <ais523> only marginally higher level
13:28:38 <ais523> seq in particular is just wires in what I'm doing
13:29:00 <elliott> fair enough
13:29:03 <ais523> and even while is just wires and one gate
13:29:19 <elliott> ais523: now the actually relevant question: how long is everyone who isn't you or someone else working on it gonna have to wait before we play with the compiler :-P
13:29:26 <elliott> (VHDL scares me. :( )
13:29:32 <ais523> probably a couple of years
13:29:41 <elliott> I WILL SIT HERE UNTIL THEN
13:30:07 <ais523> although I've been doing fun things putting the equivalent of printf statements in the input to the compiler and having them actually work
13:30:15 <ais523> by using the simulator debug API
13:30:32 <ais523> and even making the program exit via an assert-false set to the maximum severity level
13:30:36 <elliott> ais523: stop bragging about your amazing compiler powers while I sit here with the prospect of hacking VHDL manually >:(
13:30:41 <ais523> well, maximum but one, you don't use the one above that unless things go wrong
13:30:50 <elliott> Can I send you Algol code and get VHDL code that you obviously hand-translated really quickly in response? :-P
13:30:58 <elliott> You could even set up a bot. I mean, with strong AI. To translate the code.
13:31:16 <elliott> (Oblig.: You could even release the source code to the bot's AI!)
13:32:34 <ais523> well, the compiler isn't really working properly yet
13:33:02 <ais523> and even when we finish implementing what we've done so far, it'll be missing at least one important feature, and one massively important optimisation (which is about as fundamental to hardware programming as TCO is to functional programming)
13:33:04 <elliott> a (*b)() is the same as a (*b)(void) in C, right? even though (in C90) a b() and a b(void) aren't (as prototypes)
13:33:11 <elliott> ais523: which important feature?
13:33:16 <ais523> pipelining
13:33:48 <elliott> ais523: btw, Vorpal told me to ask you about advanced clockless stuff, so I'm going to go out on a limb and assume he really hates you
13:33:54 <ais523> and, I think a(*b)() isn't quite the same as a(*b)(void)
13:34:08 <elliott> ISTR it is; you can't have a function pointer to something of indeterminate arguments
13:34:14 <ais523> elliott: FPGAs aren't really designed for that
13:34:18 <elliott> You have to use a pointer to varargs or something else ~wAcKy~.
13:34:35 <ais523> you could get it working in theory, but you'd be wasting a large proportion of their circuitry
13:34:50 <ais523> and function pointer to something of indeterminate arguments is how it worked all the time prior to C89
13:34:55 <ais523> I've even used some in a program I was working on
13:35:07 <ais523> because I wanted a function that you could pass another function of the same type to as an argument
13:35:14 <ais523> and indeterminite arguments is obviously the only way to express that in C
13:35:40 <elliott> But IIRC you need to cast a function pointer into a () one
13:35:44 <elliott> Which obviously means they're not compatible
13:35:49 <ais523> no, you don't
13:35:58 <elliott> ah, stackoverflow agrees
13:36:02 <elliott> which actually makes me believe it less, but
13:36:37 <CakeProphet> ais523: I've been looking at cyclexa as inspiration for my own regular expression grammar, by the way. Looks very interesting.
13:36:43 <ais523> another example: int (*b)() = global_variable; b(2.0f) calls b as if it expects a double
13:36:54 <ais523> and int (*b)(float) = global_variable; b(2.0f) calls b as if it expects a float
13:37:13 <elliott> ais523: i'm asking this as part of a ridiculously intentionally-overengineered SyL implementation, FWIW
13:37:17 <ais523> SyL?
13:37:25 <elliott> it's this fairly decent language on the wiki http://esolangs.org/wiki/SyL
13:37:32 <elliott> i picked it because it was high up in recent changes and not completely idiotic
13:37:37 <ais523> you know, I didn't even think to ask what you were doing, I just assumed there was a reason and didn't care if there wasn't
13:37:42 <elliott> and also because i can call the resulting implementation sylladex
13:37:47 <elliott> my motives are
13:37:48 <elliott> rather flimsy
13:38:04 <elliott> but hey, it'll be the most useful, optimising, flexible of a language you'll never ever want to use
13:38:05 <ais523> they're good enough for #esoteric
13:38:22 <ais523> also, that page is uncategorised
13:38:27 <ais523> I've been forgetting to check that in the more recent languages
13:38:29 <Vorpal> <elliott> ais523: btw, Vorpal told me to ask you about advanced clockless stuff, so I'm going to go out on a limb and assume he really hates you
13:38:39 <elliott> i can't categorise it, i'm too busy poking five thousand holes in the spec: http://esolangs.org/wiki/Talk:SyL
13:38:45 <Vorpal> I only said that ais was more likely to know about it than me
13:38:57 <ais523> oh wow, http://esolangs.org/wiki/Special:Uncategorizedpages actually works
13:39:07 <ais523> perhaps I should clear it out some day
13:40:46 <elliott> you expected it to not work?
13:41:03 <elliott> only a hundred and eighty six pages, it seems
13:41:17 <elliott> you can reduce that by three by deleting the terrible articles:
13:41:24 <elliott> http://esolangs.org/wiki/Prefix_notation
13:41:25 <elliott> http://esolangs.org/wiki/Postfix_notation
13:41:27 <elliott> http://esolangs.org/wiki/Surround_notation
13:41:29 <ais523> well, some are subpages of other things
13:41:30 <elliott> although IIRC there's a fourth
13:41:33 <CakeProphet> lol surround notation
13:41:36 <elliott> ah, http://esolangs.org/wiki/Infix_notation
13:41:59 <elliott> CakeProphet: no no, the esowiki is _totally_ the place for tehz to make articles about his weird, arbitrary distinctions between different aspects of notation that nobody else really agrees with
13:42:14 -!- oerjan has joined.
13:42:15 <elliott> "Infix notation is one of the 4 possible ways to describe a program." ;; makes less and less sense each time i read it
13:42:16 <CakeProphet> the correct term for that is circumfix... but "surround" makes it sound high quality, like good speakers.
13:42:25 <elliott> lol
13:42:28 <elliott> thx surround notation
13:42:30 <ais523> he forgot postcircumfix!
13:42:35 <elliott> postumfix
13:43:04 <oerjan> also nullfix
13:43:24 <elliott> hmm, now do I compile the AST directly into the backend, or do I want to compile it to some kind of VM first...
13:43:51 <CakeProphet> elliott: compile to a shell script that JITs
13:44:11 <elliott> lol
13:44:12 <CakeProphet> JIT compiles a bytecode that is
13:44:20 <ais523> oerjan: is a nullfix operator one that has to be the entire program if it's used at all?
13:44:20 <CakeProphet> just one
13:44:45 <ais523> or did you mean the concept more commonly called an operand, but interpreted in a weird way?
13:44:49 <CakeProphet> on that note, time to go get a drug test brb
13:45:34 * elliott tests brb
13:45:39 <elliott> I haven't got a drug, though
13:45:45 <elliott> so my results may not be what you're looking for
13:46:15 <elliott> hmm, (somestruct){ ... } is C99, right?
13:46:29 <oerjan> ais523: i was thinking of haskell's f x notation :P
13:46:50 <ais523> ah
13:46:59 <oerjan> oh and the ever popular wontfix
13:46:59 <ais523> that's an infix operator, just the operator is zero characters long
13:47:14 <elliott> also, how does one actually do a union literal?
13:47:17 <elliott> I'm not sure how they work at all
13:48:05 <ais523> union float_or_int {float f; int i;} /* ... */ (union float_or_int){.i = 4}
13:48:18 <elliott> do you have to use field syntax like that?
13:48:22 <ais523> C99 only, that syntax, but I don't think it works at all in C89
13:48:39 <elliott> also, I don't need the (foo) if the union is a field of a struct, right?
13:48:41 <elliott> I can just do {...}
13:49:05 <ais523> in a struct literal, yes
13:50:47 <ais523> oh right, KDE
13:50:51 <elliott> wat
13:50:56 <ais523> I'd spent all this time complaining about an awkward default setting on my feed reader
13:51:00 <elliott> haha
13:51:06 <ais523> and then I realised it was KDE not Gnome and I'd never actually opened the settings dialog box
13:51:08 <elliott> hmm, challenge: write a C expression that, given x, evaluates to negative one if the result is negative ("equal to EOF" is also acceptable), and the value otherwise
13:51:10 <ais523> now it does what I want
13:51:11 <elliott> but x can only be evaluated once
13:51:12 <elliott> basically I want
13:51:20 <elliott> if (getchar() == EOF) -one else getchar()
13:51:23 <elliott> but as an expression
13:51:26 <elliott> without re-evaluating getchar()
13:51:56 <ais523> it's easy enough if you can cheat and use GCC extensions
13:52:05 <elliott> how?
13:52:29 <ais523> ((getchar() - EOF ?: -1-EOF)+EOF)
13:52:46 <ais523> but ?: takes three arguments in C89 and C99
13:52:46 <elliott> heh
13:53:51 <ais523> what was User:Uesr up to, btw?
13:53:54 <elliott> ais523: spambot
13:53:57 <ais523> I can find out but am worried it might be NSFW
13:54:00 <elliott> ais523: it's not
13:54:07 <elliott> well, unless you consider spam NSFW
13:54:13 <ais523> ah, right
13:54:15 <ais523> how pointless
13:54:23 <elliott> ugh, even addition is a pain with this direct-translation scheme
13:54:26 <ais523> I'd have probably blocked in addition to the userpage deletion
13:54:27 <elliott> definitely feelin' the VM vibes here
13:54:47 <elliott> although I don't really want to use a stack vm, it feels like such a copout when I could do register allocation
13:55:23 <ais523> haha, wow this is going to be beautifully insane
13:55:30 <ais523> will you have a reload pass more insane than gcc's?
13:55:59 <elliott> ais523: unfortunately, I don't know what a reload pass is
13:56:13 <ais523> I can explain what it is simply enough
13:56:15 <elliott> have I mentioned I'm planning a full FFI? :/
13:56:26 <elliott> -- TODO: constant-fold across [function -Ed] calls
13:56:30 <elliott> actual comment in Optimise.hs
13:56:32 <ais523> the way gcc and many other compilers work is, originally they assume an infinite number of registers
13:56:34 <elliott> well, sans the [] bit which I just added now
13:56:51 <ais523> and then adapt the code to allow for the finite number of registers they have in practice
13:57:05 <ais523> (SSA generally ends up naturally falling into an infinite-registers model)
13:57:21 <ais523> so they do it by reassigning registers, reusing registers with dead values, and worst-case spilling to memory
13:57:28 <ais523> that's the reload pass
13:57:48 <elliott> haha
13:58:00 <elliott> ais523: they should take that to its logical conclusion, and eliminate memory entirely
13:58:02 <ais523> apparently, everyone who understands how gcc's works has gone insane, or else recovered by refusing to speak of it ever again
13:58:16 <elliott> just treat all storage as part of the infinite domain of registers
13:58:23 <elliott> and let the reload pass sort out the best place to put it
13:58:36 <elliott> this feels like a remarkably ais523 thought to have, which pleases me greatly
13:58:53 <ais523> elliott: well, one of the main advantages we claim for our compiler is that it doesn't use centralised memory at all
13:59:08 <ais523> if it needs memory that it can't store in a LUT's delay slot, it goes and makes a small amount of memory locally
13:59:10 <elliott> i've always wanted a compiler that doesn't use centralised memory at all
13:59:22 <ais523> because memory bandwidth is the limiting factor nowadays, rather than actual storage capacity, for most programs
13:59:51 <elliott> ais523: do you have any opinion on how crappy/uncrappy this is? http://www.altera.com/products/devkits/altera/kit-cyc3-starter.html
14:00:10 <elliott> specs on the actual fpga model seem to be here http://www.altera.com/products/devices/cyclone3/overview/cy3-overview.html
14:00:38 <elliott> I know it has about a tenth of the logic elements that the Reduceron guys' FPGA has :P
14:01:02 <ais523> it looks /very/ small by FPGA standards
14:01:19 <ais523> anyway, I have to go to a meeting
14:01:23 <elliott> OK
14:01:30 <elliott> FWIW, that's the highest-end starter kit they seem to have
14:01:39 <elliott> apart from ones which seem to be targeted at people doing weird non-generic stuff
14:01:46 <elliott> something about "GX tranceivers"
14:02:37 <elliott> yikes, that has half the logic elements
14:02:41 -!- Patashu has quit (Ping timeout: 240 seconds).
14:03:33 <ais523> or, hmm, the person I'm meant to meet isn't there
14:03:55 <ais523> I'll wait for him to phone me
14:04:26 <ais523> ah, OK, the FPGA itself isn't all that small
14:04:36 <ais523> just that the board isn't designed to allow access to its full capabilities at all easily
14:04:57 <elliott> heh
14:05:16 <ais523> you'll find that this is often the case
14:05:24 <ais523> in fact, FPGAs nowadays tend not to have simple VHDL/Verilog interfaces
14:05:31 <elliott> really?
14:05:43 <ais523> instead you need to use some crazy design flow wizard thing that takes care of synthesizing a whole lot of crazy boilerplate automatically, more or less like firmware
14:05:56 <ais523> and custom VHDL or Verilog you have to plug into it via an FFI-type thing with crazy interfaces
14:06:00 <elliott> eurgh
14:06:08 <ais523> we figured out how to turn that off with the Altera tools, but not with the Xilinx tools
14:06:14 <elliott> does the Altera toolchain just have a command-line synthesiser I can use and forget about the rest? :P
14:06:44 <ais523> (or rather, the Xilinx tools, you could turn it off but then there was no obvious way to connect your program to anything, and I spent a week trying to work out how on the Xilinx website and failing)
14:07:03 <ais523> (at least Altera give pinouts for their board; how to actually tell them to the compiler is non-obvious but we worked it out eventually)
14:16:24 <elliott> hmm
14:16:29 <elliott> to stack machine or not to stack machine
14:22:39 -!- ais523 has quit (Read error: Connection reset by peer).
14:28:18 -!- ais523 has joined.
14:28:36 -!- Kustas has quit (Quit: appled into ipad).
14:34:29 <Sgeo> Chrome seems to have decided to stop displaying favicons
14:37:55 <Sgeo> Reading the lexical analysis wiki
14:38:00 <Sgeo> article
14:38:27 <Sgeo> It mentions a program that makes lexica analyzers. I don't need to do that, right, it's easy to make my own?
14:39:06 <oerjan> sure
14:39:29 <Sgeo> Although if there's something that makes lexers in Javascript, I might not bother to roll my own
14:41:08 <Sgeo> Wikipedia article continues to talk as though I shouldn't roll my own unless I have to
14:43:53 <Vorpal> elliott, what is that VM you are working on?
14:44:27 <elliott> for syl
14:44:45 <Vorpal> ais523, why would xilinx and altera do those insane boilerplate thingies you mentioned!?
14:44:59 <ais523> Vorpal: why does Windows do wizards?
14:46:27 <Vorpal> ais523, Hm. From what I remember it worked like this when I used xilinx stuff. You wrote your vhdl file. Then you told it which one was the top entity in the IDE and right clicked somewhere to get a file where you could map signals to pins.
14:46:35 <Vorpal> maybe that was some old model
14:47:13 <ais523> that still works, in both Altera and Xilinx, although the exact place to right-click can take us an hour to find sometimes and we keep forgetting
14:47:32 <ais523> the issue with the Xilinx tools is that they gave no indication of what pin was connected to what on the evaluation board
14:47:32 <Vorpal> hm
14:48:07 <Vorpal> ais523, oh okay. I think the board I used was a custom made one at the university. At least it looked like it was hand etched...
14:48:18 <Vorpal> (not completely straight lines and so on)
14:48:45 <ais523> (one frustrating issue with the Altera thing is that the pin assignments tools makes you pick the pin names from a drop-down list, you can't just type them in, which is really annoying as there are hundreds of pins and the names are no more than four characters long)
14:48:53 <ais523> and hand-etched boards still tend to have straight lines
14:49:03 <ais523> the major difference is that the boards tend to be white rather than green or blue if etched by hand
14:49:16 <Vorpal> ais523, the board was yellow
14:49:19 <ais523> ah, right
14:49:27 <Vorpal> I never seen white ones
14:49:31 <ais523> that's what the white boards look like if they've been sitting in an acid bath for an hour or so
14:49:33 <elliott> <ais523> (one frustrating issue with the Altera thing is that the pin assignments tools makes you pick the pin names from a drop-down list, you can't just type them in, which is really annoying as there are hundreds of pins and the names are no more than four characters long)
14:49:36 <ais523> which is part of the process
14:49:37 <Vorpal> ah
14:49:42 <elliott> do they support kb completion?
14:49:46 <ais523> nope
14:49:51 <Vorpal> hahah
14:49:51 <ais523> we tried that
14:49:56 <Vorpal> how awful
14:50:02 -!- foocraft has quit (Quit: Leaving).
14:50:14 <elliott> lol
14:50:16 <ais523> we assume that the thing is backed by a text file somewhere so we could edit it by hand, but we never found the file; perhaps it's in a binary format instead
14:50:42 <Vorpal> ais523, for xilinx it is definitely a text file, though iirc they have a GUI drag-and-drop kind of thingy too
14:51:11 <ais523> yep, agreed
14:51:15 <ais523> we found the file in question for xilinx
14:51:37 <Vorpal> you could even open it from the GUI thingy by simply clicking somewhere iirc
14:51:46 <Vorpal> ais523, but why don't they give you access to the pins in a straight-forward way? I don't get it. What is in it for them?
14:52:01 <elliott> incompetence
14:52:23 <ais523> yep, it's typical large program design
14:52:47 <ais523> hmm, have you ever used Eclipse? imagine a program designed along similar lines, but getting all the details wrong
14:52:48 <ais523> or, well, wronger
14:52:56 <Vorpal> ais523, btw, why do hand etched boards tend to be yellow/white rather than green or blue?
14:53:03 <ais523> it's a different process
14:53:38 <Vorpal> <ais523> hmm, have you ever used Eclipse? imagine a program designed along similar lines, but getting all the details wrong <-- eclipse is rather annoying. The IDE for VxWorks 6.x and later is based on eclipse, and it is annoying to use.
14:53:45 <ais523> I think it probably uses different chemicals, or something
14:53:50 -!- oerjan has quit (Quit: leaving).
14:53:56 <ais523> Vorpal: that's the sort of thing I'm getting at, wrt Xilinx/Altera toolchains
14:54:03 <Vorpal> ah
14:54:21 <Vorpal> ais523, are there any other FPGA companies?
14:54:40 <ais523> also, happy IPv6 day, everyone!
14:54:45 <ais523> Vorpal: no major ones, as far as I know
14:54:49 <Vorpal> hm
14:54:51 <ais523> as elliott said, it's a duopoply
14:54:53 <ais523> *duopoly
14:55:05 <Vorpal> is that a real word?
14:55:13 <Deewiant> Yes
14:55:17 <Vorpal> hm okay
14:55:31 <Vorpal> ais523, well, I guess altera is better, if they provide pinouts.
14:55:40 <Vorpal> are the pinouts hard to find?
14:56:03 <ais523> not too bad, they're in the manula
14:56:04 <ais523> *manual
14:56:08 <Vorpal> ah
14:56:14 <ais523> for the evaluation board
14:56:23 <Vorpal> right
14:56:36 <Vorpal> sounds fun
14:56:48 <Vorpal> ais523, how did you use it with the compiler
14:56:52 <Vorpal> might be useful to know
14:57:06 <ais523> I didn't set it up myself
14:57:08 <Vorpal> ah
14:58:37 <Vorpal> ais523, I saw something about "web edition" of their IDE. What was that about?
14:58:42 <Vorpal> altera's IDE that is
14:58:49 <Vorpal> that came with the board elliott was looking at
14:58:55 <ais523> I don't know
14:58:59 <elliott> prolly jusr means
14:59:03 <elliott> comes with no cdrom
14:59:08 <ais523> they tend to give academic versions of the IDEs to universities for free
14:59:13 <elliott> you download the ide from teh interwebs
14:59:15 <Vorpal> elliott, better check...
14:59:24 <ais523> e.g. Xilinx gave us a license for up to 50 unique MAC addresses
14:59:40 <elliott> well i know that for a fact, it's stated elsewhere
15:00:10 <ais523> bleh, this network isn't doing IPv6
15:01:27 <CakeProphet> ais523: you could also interpret function application in Haskell as being prefix, with the space not being a special operator but the function being the operator itself.
15:01:44 <ais523> CakeProphet: that muddles operators and operands
15:02:10 <Vorpal> In addition to ModelSim-Altera Starter Edition software, Altera offers ModelSim-Altera Edition with the following additional enhancements:
15:02:10 <Vorpal> * 33 percent faster simulation performance
15:02:10 <Vorpal> * Support for large FPGA designs with no line limitations
15:02:14 <Vorpal> 33% faster?
15:02:14 <Vorpal> what
15:02:20 <Vorpal> that is a stupid "feature"
15:02:54 <ais523> hmm, now I'm trying to remember if both Altera and Xilinx use ModelSim
15:02:56 <Vorpal> do they cap the speed of the other one by 33% of what your processor can do or something like that
15:03:02 <Vorpal> ais523, xilinx definitely does
15:03:11 <CakeProphet> really it's all relative to what is the object in question. A quoted string is circumfix if you go by quotes, but you could also say that the inner string leme itself is infix in relation to the quote lexemes
15:03:21 <Vorpal> "# 10,000 executable line limitations"
15:03:22 <Vorpal> ew
15:03:23 <CakeProphet> s/leme/lexeme
15:03:28 <ais523> Vorpal: ouch
15:03:30 <CakeProphet> though I now want to define the word leme..
15:03:33 <ais523> 10,000 is nothing in VHDL
15:03:37 <Vorpal> ais523, in the starter edition that is
15:03:44 <ais523> although I wonder if you could get around it by deleting all the newlines
15:03:51 <Vorpal> ais523, hehe
15:03:58 <ais523> if it's that arbitrary a restriction
15:04:56 <Vorpal> the web edition won't use more than one CPU core when synthesising it seems
15:05:09 <Vorpal> nor will it do incremental compilation
15:05:10 <Vorpal> ouch
15:05:34 <CakeProphet> but, yes, typically the operator is the thing in question. In the case of function application in Haskell I would say that the operator is prefix, because the function application isn't really a lexeme in itself.
15:05:35 <Sgeo> I have no idea how to write an incremental compiler
15:06:04 <Vorpal> Sgeo, make + multiple C files = incremental compilation at file level granularity
15:06:19 <Vorpal> I assume it means the web edition simply forces a full recompilation every time
15:07:12 -!- SimonRC has quit (Ping timeout: 260 seconds).
15:07:45 <Vorpal> $2,995 USD for the cheapest non-free version.
15:07:48 <Vorpal> oh come on...
15:08:23 -!- SimonRC has joined.
15:08:36 <Vorpal> that is more expensive than the computer I'm using
15:10:25 <CakeProphet> Vorpal: dude it's perfectly reasonable. strings of machine isntructions encoded as bytes are valuable commodities. There's a very limited supply of it and high demand, so the price is high. BASIC ECONOMICS.
15:12:24 <Vorpal> hare
15:12:26 <Vorpal> har*
15:13:35 <ais523> apparently, in the world of radio frequency electronics simulation, at any one time there's only one program that everyone uses
15:13:43 <ais523> what happens is that it gets more expensive over time, as it's the only one available
15:14:01 <ais523> then someone else writes a program that's better, more featureful, and a tiny percentage of the price, then drives the incumbent out of business
15:14:19 <ais523> then they're the only one available, and it gets more expensive over time...
15:14:31 <Vorpal> ouch
15:14:36 <Vorpal> ais523, and stupid too
15:15:12 <ais523> in the world of FPGAs, it's even worse, as it's hard to enter the market with the FPGA /manufacturers/ having a huge advantage in writing software
15:15:49 <elliott> howso?
15:16:19 <Vorpal> ais523, because they don't release the specs required for you to figure out how to compile stuff to their products
15:16:23 <Vorpal> err
15:16:24 <Vorpal> elliott, ^
15:16:40 <ais523> and also, they get to bundle software with hardware
15:17:07 <ais523> and hardware with other hardware that needs specialised software
15:21:09 <Vorpal> ais523, what about EDA? I guess it is about as bad there?
15:21:21 <ais523> I can't expand that acronym
15:21:28 <Vorpal> electronic design automation
15:21:33 <Vorpal> ais523, ASICs and so on
15:21:41 <CakeProphet> !simpleacro
15:21:45 <ais523> ah, in that case I don't know
15:21:48 <EgoBot> ​ZMGCMKM
15:22:01 <CakeProphet> How do you guys feel about ZMGCMKM?
15:23:16 -!- SimonRC has quit (Ping timeout: 252 seconds).
15:24:14 <Vorpal> CakeProphet, what is that one?
15:26:12 <CakeProphet> uh, Zesty Military-Guided Chickens Masturbating Kill Mode
15:26:38 <CakeProphet> it's the latest buzzword.
15:26:46 <Vorpal> ...
15:27:16 <CakeProphet> THE LATEST.
15:27:45 <CakeProphet> I have the buzzword feed /right here/
15:32:29 -!- CakeProphet has set topic: Redefining /Extreme/ Programming | Logs: http://codu.org/logs/_esoteric/ and http://tunes.org/~nef/logs/esoteric/?C=M;O=D.
15:36:00 <CakeProphet> We should make an esoteric software development methodology.
15:36:26 <CakeProphet> Complete with fancy diagrams
15:36:34 <CakeProphet> with lots of arrows.
15:51:18 <Sgeo> I think I understand lexing well enough at this point.
15:54:36 -!- Kustas has joined.
15:54:57 <Sgeo> http://en.wikipedia.org/wiki/File:Parser_Flow.gif I thought compiler==translator
15:55:13 <Sgeo> Even if the former has more of a connotation of complexity than the latter
16:01:53 <CakeProphet> I would say they're close enough in similarity to almost be the same thing.
16:07:39 -!- SimonRC has joined.
16:17:47 -!- SimonRC has quit (Ping timeout: 260 seconds).
16:23:19 -!- TOGoS has joined.
16:23:27 -!- TOGoS has left.
16:24:22 -!- SimonRC has joined.
16:57:38 -!- Kustas has quit (Quit: left forever).
16:58:42 <elliott> how do i shot assembly
16:59:35 <CakeProphet> how do I freakin' figure out US tax law
17:03:52 <Sgeo> Conservapedia makes me laugh
17:04:12 <Sgeo> There's an argument on a talk page's archive about whether autumn foliage is objectively beautiful
17:04:23 <Sgeo> http://www.conservapedia.com/Talk:Counterexamples_to_Evolution/archive1#Some_Comments
17:04:27 <elliott> fizzie: you're a nasm scientist right
17:04:34 <elliott> Sgeo: holy shit, I'm unblocked
17:07:02 <Sgeo> elliott, hmm?
17:08:30 <elliott> Sgeo: almost the entire world is blocked IP-wise (403) from Conservapedia
17:08:36 <elliott> but at least i can see it now, maybe they lifted it
17:08:39 <Sgeo> o.O
17:08:54 <elliott> Sgeo: (Schlafly asked if there was a way he could just ban all non-USA IPs so he wouldn't have to deal with trolls)
17:09:07 <elliott> (this... worked, but I gather a lot of US IPs are collateral damage)
17:09:19 <elliott> but evidently Conservapedia's five editors aren't affected
17:10:41 <Sgeo> Wouldn't it have made more sense to just block non-US IPs from editing?
17:10:53 <Sgeo> I guess it might require some sort of entry level programmer
17:11:30 <elliott> why should non-US people be allowed to view the American encyclopedia?
17:11:33 <elliott> they don't matter.
17:11:41 <elliott> to be honest, they're hardly even people.
17:11:46 <CakeProphet> "The annual rate of extinction of species far exceeds any plausible rate of generation of species. Expanding the amount of time for evolution to occur makes evolution even less likely."
17:12:05 <CakeProphet> High extinction rate is a recent phenomenon as a result of massive human habitation..
17:12:18 <elliott> arithmetics are hard
17:12:20 <elliott> how does nasm works
17:12:25 <elliott> how does ... archaeology
17:12:39 <Sgeo> CakeProphet, did you see the bit about "If there's a 5% chance of any one of these being true"?
17:12:45 <CakeProphet> ...yes.
17:12:49 <CakeProphet> Parsimonious repetition of design elements throughout creation, e.g. the eye's appearance in remarkably different species. For such complex structures to arise repeatedly via evolution is impossible, as evolution is an inherently random and historically contingent process.
17:12:57 <CakeProphet> ....what? that's an argument for evolution if anything.
17:14:01 <elliott> [SAssign varname (EConst (VInt 999)),
17:14:01 <elliott> SAssign varname (EBinOp Add (EVar varname) (EVar varname)),
17:14:01 <elliott> SIf (EVar varname) [SAssign varname (EConst (VInt 0))]]
17:14:08 <elliott> time to hand-translate this to hypothetical bytecode
17:14:23 <CakeProphet> Pleiotropy, the fact that a change of a single gene can have several different effects, renders the "improvement" of animals by random mutation impossible, as any mutation with a potentially beneficial effect will be coupled with one or more other potentially lethal effects.
17:14:43 <CakeProphet> except, you know, when the lethal mutations kill the organism and prevent inheritance, and the beneficial ones remain.
17:14:59 <Sgeo> CakeProphet, keep reading them in order. There's a ... I want to call it a punchline, it's so ridiculous
17:15:06 <elliott> guys, what's the best way to do a stack of floating point in xeightysix assembly
17:15:11 <elliott> just push fp values to the normal stack?
17:15:24 <Sgeo> Or, um, just skip ahead *shrug*
17:15:38 <CakeProphet> For evolution to be true, every male dog, cat, horse, elephant, giraffe, fish and bird had to have coincidentally evolved with a female alongside it (over billions of years) with fully evolved compatible reproductive parts and a desire to mate, otherwise the species couldn't keep going.
17:15:57 <CakeProphet> ...yes, there's a definite line. One day, a baby is born and it just can't mate with anything of its species..
17:17:06 -!- monqy has joined.
17:17:07 <CakeProphet> learn2 understand speciation plz.
17:18:39 <tswett> CakeProphet: well, the pleiotropy argument states that beneficial mutations are impossible, because a change to any gene will cause more harm than good.
17:19:52 <CakeProphet> is that a fact?
17:20:01 <tswett> I don't think so.
17:20:42 <CakeProphet> this one is the best so far:
17:20:45 <CakeProphet> Mutations cause a loss of information, rendering it mathematically impossible for mutations to advance the complexity of life. Similarly, entropy (disorder) increases over time, making it impossible for order to increase on its own. According to Cornell University geneticist John C. Sanford, not even the energy of the Sun, which might otherwise reduce entropy in a system not thermodynamically isolated such as the Earth,
17:22:43 <CakeProphet> poorly formulated information theory, mathematical assertions about complexity, thermodynamics, ecology, and Biblical apocalypse. There's even a smart guy as a source.
17:23:44 <CakeProphet> ...this is such an entertaining read.
17:24:09 -!- zzo38 has joined.
17:24:59 <elliott> <CakeProphet> For evolution to be true, every male dog, cat, horse, elephant, giraffe, fish and bird had to have coincidentally evolved with a female alongside it (over billions of years) with fully evolved compatible reproductive parts and a desire to mate, otherwise the species couldn't keep going.
17:25:00 <elliott> tru luv
17:25:35 <tswett> Some of the things on that list seem like interesting, potentially valid arguments. Some of them seem like confused ravings.
17:26:17 <tswett> See, here's a potentially valid one: "Lack of genetic diversity among the Homo sapiens species. Were evolution and the old earth true, the human population would show a much larger genetic variance."
17:26:39 <tswett> Maybe they've done some mathematical models that show that, if evolution is true, then there indeed must be more genetic variance than there actually is.
17:28:55 <tswett> And here's a confused raving: "Evolution does not account for the immense amount of information in the genome, as well as the origin of the information-processing systems in the cell. Information always has a sender, who must be God in this case."
17:29:41 <elliott> tswett: I'm sorry that you deny beauty.
17:29:51 <elliott> You will suffer for it for the rest of your pitiful heathen life.
17:30:03 <zzo38> "...beneficial mutations are impossible, because a change to any gene will cause more harm than good..." This seems nonsense. Even if this is the case there can be changes to multiple genes and this can cause beneficial. And even if one causes more harm than good, does it say the harm is significant? However, none of this means any of the stuff I said actually happens either.
17:30:37 <zzo38> You also failed to account for quanglement.
17:30:46 <elliott> everyone always fails to account for quanglement
17:30:54 <Sgeo> "Scientists have found proof that the first chicken came before the first egg,[40] consistent with a special creation of chickens but not with a gradual descent with modifications from a proto-chicken and proto-egg."
17:31:54 <zzo38> ??? How old have chickens be? And how do you define what exactly counts as a first chicken or first egg, etc?
17:32:36 <zzo38> And why did Conservapedia block everyone?
17:33:31 <elliott> gah, dealing with things greater than one machine word in assembly is a pain :(
17:34:39 <zzo38> Does it have carry function?
17:34:44 <CakeProphet> tswett: There's plenty of genetic diversity in humans. But more importantly, "genetic diversity" is not something you can just measure; it's a qualitive statement. Even more importantly, it is not required that all species exhibit genetic diversity for evolution to be a valid theory.
17:35:08 -!- zzo38 has quit (Remote host closed the connection).
17:35:56 <tswett> CakeProphet: you *can* measure genetic diversity, though, can't you? Grab some random people, perform some genetic tests on them, and see how diverse their genes are, compared to your mathematical model.
17:36:28 -!- Kustas has joined.
17:36:37 <CakeProphet> tswett: hmm, well, yes. You can determine it that way.
17:36:49 <CakeProphet> statistically.
17:36:56 <tswett> Yup.
17:38:48 <CakeProphet> However, you still have no metric for what is "very genetically diverse" and "not very genetically diverse", these are still fuzzy qualitive statements. You'd need to compare a number of different species, and perhaps compare between species.
17:39:09 <CakeProphet> and then you'd still probably need to assign some arbitrary scale to determine genetic diversity.
17:39:22 <tswett> Right. I have no idea what sort of analysis the people actually did, much less whether or not it was valid.
17:40:00 <CakeProphet> tswett: an admirable defense nonetheless. :)
17:41:55 <elliott> hmm, structuring this bytecode in haskell kind of sucks
17:42:00 <elliott> I suppose I want a map of labels to code
17:42:07 <cheater_> looks cool: http://www.deliantra.net/screenshots.html
17:42:07 <elliott> but it's so ugly to use like arbitrary ints for the labels
17:42:16 <elliott> I suppose I could include the relevant code directly but that would be a real pain for the code generators
17:42:53 <CakeProphet> But yes, I agree with this article that the law of thermodynamics necessarily implies slow ecological stagnation, which is an obvious precursor to the End Times. This assertion is in direct contradiction with the Fourth Law of Evolutionary Theory(tm) which states that "In order for the process of evolution to be true, everything must get better all of the time."
17:43:27 <CakeProphet> there's not refuting that, really.
17:43:29 <CakeProphet> *no
17:54:10 <CakeProphet> The main problem with most of these arguments is that they attack strawmen assertions that evolutionary theory supposedly makes.
17:54:10 <CakeProphet> but these assertions are actually just poorly worded ideas based on the principle of evolution that people make in a non-scientific context, and not the theory itself.
17:56:05 -!- Kustas has quit (Quit: quitter).
17:59:12 <pikhq_> There's actually a much more obvious rebuttle of that stupid thing.
17:59:25 <pikhq_> The Earth is not a closed system.
18:13:58 <elliott> Is there a logical argument for privacy? (self.AskReddit)
18:14:00 <elliott> REDDIT
18:14:57 -!- olsner has joined.
18:16:28 <ais523> elliott: well, obviously there is
18:16:30 <ais523> several, in fact
18:16:35 <ais523> I wonder if any will come up in the thread?
18:16:46 <elliott> ais523: I don't want to find out
18:17:03 <elliott> I'm running out of justifications to not unsubscribe from /r/AskReddit to be quite honest
18:17:12 <elliott> (The justifications are a huge long list of "I'm too lazy to".)
18:17:35 <CakeProphet> for illustration of this concept see:
18:17:42 <CakeProphet> > repeat ("I'm too lazy to")
18:17:44 <lambdabot> ["I'm too lazy to","I'm too lazy to","I'm too lazy to","I'm too lazy to","I...
18:18:23 <CakeProphet> lambdabot, expanding minds for a better tomorrow.
18:18:30 <ais523> elliott: I'm subscribed to the default set, but never (or incredibly rarely) visit the reddit homepage anyway so it doesn't matter
18:18:48 * CakeProphet has never been to reddit.
18:18:48 <ais523> > take 500 $ repeat "I'm too lazy to"
18:18:49 <lambdabot> ["I'm too lazy to","I'm too lazy to","I'm too lazy to","I'm too lazy to","I...
18:18:56 <ais523> see, now it's a huge long list, rather than an infinite list
18:18:59 <monqy> what's reddit
18:19:00 <elliott> CakeProphet: at this point, I would recommend against the experience
18:19:10 <elliott> there are a few decent subreddits, but outside of that...
18:19:18 <ais523> I read proggit for the offtopic stuff
18:19:21 <ais523> the ontopic stuff too, sometimes
18:19:29 <ais523> (I don't /submit/ offtopic stuff, though, because I'm not a monster)
18:19:40 <Sgeo> ais523, hmm?
18:19:57 <ais523> Sgeo: keeping proggit ontopic is well known to be difficult, despite the attempts of the moderators
18:20:01 <Sgeo> What's wrong with proggit that you wouldn't submit ontopic stu... oh, you said offtopic
18:20:04 <Sgeo> I misread you
18:20:04 * elliott is guilty.
18:20:21 <elliott> (In my... defence... I submitted it to proggit in a shameless karmawhoring attempt without thinking.)
18:20:26 <elliott> (Wait, that doesn't sound like a defence at all.)
18:20:37 <elliott> (Propose we drop the subject.)
18:20:51 <elliott> ais523: also, was that a snarky reference to this channel? :)
18:20:54 <ais523> no
18:20:59 <Sgeo> I've karmawhored... by submitting an ontopic link to a subreddit
18:20:59 <ais523> I'm not very good at snarky references
18:21:11 <elliott> Sgeo: you subhuman :O
18:21:16 <ais523> so if you see a snarky reference coming from me, it's either really awful, crude, and obvious, or else unintentional
18:21:27 <elliott> ais523: or, maybe it's intentional and you are just THAT
18:21:28 <elliott> SUBTLE
18:21:32 <elliott> It is possible.
18:21:35 <CakeProphet> elliott: you could incorporate this into a pronunciation based language: http://en.wikipedia.org/wiki/Duplifix
18:21:39 <CakeProphet> as a new kind of operator.
18:22:02 <ais523> elliott: part of the reason I tend to be so honest is that I'm pretty bad at lying
18:22:10 <elliott> bah, shm-reduplication shm-reduplication
18:22:28 <elliott> DO YOU SEE WHAT I DID THERE
18:23:28 <elliott> i don't think ais523 sees what i did there.
18:23:36 <elliott> i think he's quite blind to what i did there
18:23:38 <ais523> no, I Don't
18:23:40 <ais523> *don't
18:23:52 <elliott> http://en.wikipedia.org/wiki/Shm-reduplication may help :D
18:24:49 <ais523> ah, that's a rather specific thing to do
18:25:29 <CakeProphet> this would be fun to parse in a programming language: http://en.wikipedia.org/wiki/Transfix
18:25:29 <elliott> BUT DO YOU SEE WHAT HAPPENS WHEN YOU SHM-REDUPLICATE "SHM-REDUPLICATION" YOURSELF
18:25:31 <elliott> ARE YOU LAUGHING YET
18:25:47 <CakeProphet> > cycle ("haha") --cue laughter
18:25:48 <lambdabot> "hahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahaha...
18:25:59 <ais523> CakeProphet: I actually did laugh at that
18:26:02 <ais523> not at elliott's thing yet, though
18:26:11 <elliott> thing shming
18:26:13 <elliott> foo shmoo
18:26:16 <elliott> shm-reduplication shm-reduplication
18:26:21 <elliott> FUNNIEST THING
18:26:23 <monqy> > cycle "ha" -- better laughter
18:26:24 <lambdabot> "hahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahaha...
18:26:34 <elliott> yeah that laughter is just so much more... compact.
18:26:35 <ais523> surely the second should either be shm-shm-reduplication or shmeduplication?
18:26:41 <elliott> ais523: you are spoiling it :(
18:26:48 <elliott> all 0 humour in it is now dead
18:26:50 <ais523> elliott: it wasn't funny to spoil in the first place
18:26:57 <CakeProphet> elliott shmelliott
18:27:06 <elliott> CakeProphet ShmakeProphet
18:27:33 -!- elliott has set topic: #shmesoteric | Logs: http://codu.org/logs/_esoteric/ and http://tunes.org/~nef/logs/esoteric/?C=M;O=D.
18:27:40 <CakeProphet> shmake, sounds like a make utility.
18:27:52 <elliott> a terrifying one
18:29:56 <CakeProphet> I guess a?b:c would be kind of like transfix, but that doesn't really apply outside of human languages.
18:30:35 <CakeProphet> because in transfix your interspersing the affix into the stem. Programming languages don't have that concept. a, b, and c do not collectively make a "stem"
18:31:39 -!- foocraft has joined.
18:32:02 <CakeProphet> I love the examples of infix in English: hizouse for house and shiznit for shit
18:32:16 <CakeProphet> "Fucking" and "bloody" are sometimes used as expletive infixes, as in "un-fucking-believable" or "abso-bloody-lutely"
18:35:02 -!- pikhq_ has quit (Ping timeout: 252 seconds).
18:35:03 -!- pikhq has joined.
18:35:38 <CakeProphet> "A-whole-nother", in which another (an+other) is reanalyzed as a+nother.
18:35:49 <CakeProphet> I wonder what /the/ nother is.
18:37:03 <nooga> sorry i was afk
18:37:16 -!- ais523 has changed nick to scarf.
18:38:01 -!- scarf has changed nick to ais523.
18:38:27 <elliott> ais523: hi scarf
18:39:10 <ais523> elliott: we were having a discussion about alternative nicks in #nethack
18:39:17 <ais523> and a whole load of people changed to backup nicks for a bit, then back again
18:39:30 <elliott> does #nethack ever have anything worthwhile to discuss
18:40:05 <nooga> elliott: still playing Minecraft? or maybe You switched to Dwarf Fortress?
18:40:10 <ais523> yes, if you consider NetHack worthwhile
18:40:14 <ais523> it's ontopic well above 50%
18:40:17 <elliott> nooga: Elliottcraft
18:40:22 <elliott> ais523: better than us :D
18:40:49 <elliott> actually I think we're off-topic less than you'd expect, in that, I suspect if we weren't offtopic, there would instead just be huge periods of silence
18:40:56 <elliott> things tend to happen in spurts in the esoteric world
18:41:11 <ais523> yep
18:41:31 <elliott> nooga: (I still play Minecraft, but not much lately, but I won't much once Elliottcraft becomes more concrete :P)
18:41:36 -!- ralc has joined.
18:41:45 <ais523> elliott: are you making a Minecraft clone-but-better?
18:41:55 <ais523> also, I'd imagine adding more concrete to a Minecraft-alike would be quite easy
18:42:12 <nooga> ;];]
18:42:14 <elliott> ais523: I _might_ be. but actually, it takes a lot of inspiration from a lot of other things, and I'm trying to replace the central game mechanic/framing mechanism itself
18:42:21 <ais523> ah, fair enough
18:42:33 <ais523> so it's just named as a Minecraft reference to confuse/attract people?
18:42:35 <elliott> as far as the blockworld itself goes, Dwarf Fortress is a better comparison, although it's presented in the Minecraft manner
18:42:48 <elliott> ais523: I needed a throwaway name while discussing it in #esoteric-minecraft :P
18:42:50 <ais523> (confusion and attraction form a pretty powerful combo in Pokémon, but it's not recommended to actually use it)
18:43:12 <elliott> It would be amusing to actually release it as Elliottcraft though, just to see how much I get yelled at
18:43:17 <elliott> YOU STOLE "-CRAFT"
18:43:41 <ais523> putting your own name in the name of a product normally causes it to not do very well
18:43:43 <olsner> fizzie: hey, finnish person: is risto karvinen a real person?
18:43:55 <elliott> ais523: hmm, maybe
18:44:03 <elliott> ais523: there are many companies named after people that are very successful
18:44:07 <elliott> named after their founders, that is
18:44:10 <ais523> now, if /I/ called something Elliottcraft, it would be fine because I'm not called Elliott
18:44:13 <elliott> olsner: http://sv.wikipedia.org/wiki/Risto_Karvinen
18:44:15 <elliott> olsner: maybe
18:44:26 <elliott> ais523: oh, I'll call it Alexiansmithcraft then
18:44:29 <olsner> elliott: yeah, that's where I started
18:44:30 <elliott> BEST NAME FOR ANYTHING???
18:44:36 <ais523> wow that's a crazy name
18:44:42 <ais523> bonus points for me because I misparsed it to start with
18:44:43 <elliott> it is, it doesn't even parse into your name for me
18:44:48 <ais523> not for me either
18:44:51 <elliott> Alexian smithcraft??? what the hell is that
18:45:05 <olsner> like normal smithcraft but more alexian
18:45:06 <elliott> hmm, really tempted to actually use that now
18:45:16 <elliott> my regard for popularity is astonishingly low :D
18:47:31 <olsner> ... finally back in linux now, I don't understand how I could ever use windows as my main OS
18:47:41 <elliott> olsner: brr
18:47:43 <elliott> olsner: do you want a hug
18:47:48 <elliott> i know how scary it can be sometimes
18:47:54 <elliott> I get kind of nervous even just booted into OS X
18:49:09 <Sgeo> Is it conceptually simpler to have continuations accept a continuation but just ignore them, or to have them not accept a continuation?
18:49:32 <olsner> in OSX you can just start X or a terminal and it starts behaving more like normal
18:49:39 <elliott> continuations don't take continuations.
18:49:51 <elliott> (what would you apply them with?)
18:50:08 <olsner> but in windows if you happen to start cmd all that's left is to stab your eyes (and soul) out with the nearest blunt object
18:50:20 <elliott> olsner: :(
18:50:23 <elliott> olsner: im sorry for your experience
18:50:23 <ais523> elliott: well, you could take an unapplied or thunked continuation, and give it as an argument to a continuation, without any real issues
18:50:29 <elliott> yeah sometimes you can be in windows
18:50:31 <elliott> and suddenly think
18:50:34 <elliott> hey i want to bring a terminal up-
18:50:37 <elliott> and then you have a panic attack
18:50:40 <ais523> olsner: I installed djgpp, just so that if I started cmd by mistake (or deliberately) it would work vaguely like a UNIX shell
18:50:41 <elliott> and they find you dead two weeks later :(
18:50:44 <elliott> unix withdrawal
18:51:05 <CakeProphet> back when I used windows I had Cygwin.
18:51:12 <CakeProphet> which was kind of like having bash. kind of.
18:51:18 <ais523> Cygwin doesn't hijack cmd, does it?
18:51:21 <CakeProphet> no.
18:51:27 <ais523> (note that I mostly only used cmd to start bash /anyway/, but...)
18:51:33 <CakeProphet> it runs in its own little environment, but you can manipulate the entire file system with it
18:51:36 <elliott> cmd is a terrible terminal, though
18:51:54 <elliott> Cygwin has the unfortunate thing that it sucks
18:52:14 <CakeProphet> yes..
18:52:24 <elliott> its fork() call is slower than making a cup of coffee
18:52:27 <ais523> DJGPP doesn't suck, but is an insane premise in the first place
18:52:32 <elliott> and its unicode support is just... blegh
18:52:36 <elliott> improved as of recent versions but
18:52:36 <ais523> (and doesn't implement fork)
18:52:44 <elliott> oh and setup.exe is the worst excuse for a package manager ever just... augh
18:52:48 <elliott> literally painful experience to use
18:52:52 <ais523> hmm... Cygwin's implementation is not the fact that it has a slow fork
18:52:55 <ais523> but the fact that it uses it
18:52:56 <elliott> ais523: hmm, djgpp has no sh, right?
18:52:59 <ais523> elliott: it has bash
18:53:01 <elliott> or does it have a manually-supported sh?
18:53:02 <elliott> erm
18:53:03 <elliott> or does it have a manually-ported sh?
18:53:05 <elliott> to not use fork
18:53:06 <CakeProphet> ais523: do you have an entire /bin and everything in windows magically? How do you run and use bash effectively in Windows?
18:53:08 <ais523> I think it's manually ported
18:53:12 <elliott> right
18:53:15 <ais523> it can't do things that would require multiple processes to run at once
18:53:23 <elliott> CakeProphet: it's really hard; I tried to get a native environment up once
18:53:24 <elliott> tl;dr:
18:53:32 <elliott> either use djgpp for dos
18:53:33 <elliott> OR
18:53:36 <elliott> https://github.com/pclouds/busybox-w32
18:53:39 <ais523> CakeProphet: you do indeed have an entire /bin, attempts to access something in /usr/bin or /bin will rewrite the path into a directory that actually exists
18:53:41 <elliott> which is a wonderful native port of busybox
18:53:42 <elliott> for windows
18:54:00 <CakeProphet> oh wait... I have a solution to this problem.
18:54:02 <ais523> this is the reason I keep writing the wrong directory in shebang lines
18:54:04 <CakeProphet> continue not using windows.
18:54:10 <ais523> as in DJGPP, it doesn't actually matter what you put there
18:54:20 <ais523> as long as it's a directory you might vaguely expect to find binaries in
18:54:30 <ais523> #!/bin/perl means the same thing as #!/usr/bin/perl, and probably the same thing as #!/sbin/perl
18:54:54 <elliott> #!/etc/perl
18:55:01 <elliott> <ais> augh
18:55:41 <ais523> you know the reaction that makes people spit coffee onto their keyboards? I just did that, except I wasn't drinking anything so the computer is fine
18:55:54 <CakeProphet> I can tell which can of Coke is cold delicious soda and which is empty by APPEARANCE ALONE
18:56:00 * CakeProphet adds this to his list of super powers.
18:56:31 <ais523> CakeProphet: except Coca-Cola isn't a sort of soda
18:56:33 <ais523> or am I confused?
18:56:38 <olsner> if it's open and you're not currently drinking from it, then it's empty
18:56:44 <Vorpal> elliott, this was a subtle joke on /etc/rmt right?
18:56:44 <ais523> (or do you fill empty coke cans with lemonade to confuse people?)
18:56:49 <elliott> Vorpal: no.
18:56:54 <Vorpal> elliott, oh
18:56:58 <olsner> one standard can holds about one sip of drink, IME
18:56:59 <CakeProphet> ais523: uh, I think you're confused.
18:57:02 <elliott> <ais523> CakeProphet: except Coca-Cola isn't a sort of soda
18:57:04 <elliott> err, how isn't it?
18:57:10 <ais523> I'm actually wondering if it's a language barrier thing
18:57:12 <Vorpal> elliott, http://sprunge.us/BFcR
18:57:13 <elliott> soda = pop = even coke in the southern us
18:57:14 <Vorpal> quite interesting
18:57:17 <CakeProphet> is there some non-US meaning of soda that I don't know?
18:57:19 <ais523> elliott: ah, I see
18:57:23 <elliott> = ten thousand different fucking names for "sugary carbonated drink""
18:57:24 <ais523> soda would be a more specific drink in the UK
18:57:27 <Vorpal> ais523, did you know about /etc/rmt?
18:57:30 <ais523> Vorpal: no
18:57:41 <ais523> sort of like lemonade but worse
18:57:47 <elliott> #!/bin/sh
18:57:47 <elliott> #
18:57:47 <elliott> # This is not a mistake. This shell script (/etc/rmt) has been provided
18:57:47 <elliott> # for compatibility with other Unix-like systems, some of which have
18:57:47 <elliott> # utilities that expect to find (and execute) rmt in the /etc directory
18:57:48 <elliott> # on remote systems.
18:57:50 <elliott> #
18:57:54 <elliott> exec /usr/sbin/rmt
18:57:56 <elliott> how exciting
18:58:00 <elliott> (I typed /etc/rmt in chrome expecting it to google; instead it displayed the file
18:58:02 <elliott> )
18:58:04 <elliott> (which is arguably more helpful here...)
18:58:18 <CakeProphet> elliott: coke is "kind of" a generic term in the southern US, yes, but it doesn't explicitly mean that. It just works out nicely because everyone in the south drinks Coke so it usually doesn't matter what you mean. :P
18:58:20 <ais523> elliott: this is why separate address and search bars is useful
18:58:27 <elliott> ais523: are you referring to crem soda, btw?
18:58:29 <elliott> [asterisk]cream
18:58:34 <ais523> elliott: no, that's something slightly different again
18:58:37 <elliott> calling that just "soda" would be weird
18:58:42 <Vorpal> elliott, I pastebinned it above. there is no need to paste it in channel
18:58:43 <CakeProphet> ais523: soda water right?
18:58:44 <elliott> ais523: hmm, then I'm not sure what you're referring to
18:58:46 <elliott> Vorpal: I didn't see
18:58:47 <ais523> although I'm willing to accept that that's a sort of soda, given how similar they are
18:58:49 <ais523> CakeProphet: that might be it
18:58:49 <elliott> <ais523> elliott: this is why separate address and search bars is useful
18:58:54 <elliott> I usually type Ctrl+K when I want to search
18:58:58 <elliott> it automatically adds the ? prefix for search
18:58:59 <CakeProphet> ais523: "soda" is a generic term for carbonated water, yes.
18:59:01 <Vorpal> elliott, I highlighted you
18:59:02 <CakeProphet> in the states as well.
18:59:02 <elliott> I never /clicked/ the boxes, so it's equivalent
18:59:05 <ais523> I had to configure Firefox to not search when entering a typoed URL in the address bar
18:59:27 <ais523> but it tries to visit the website instead, which is still annoying when I press return early
18:59:48 <Vorpal> I hate combined search bar thingy
18:59:56 <Vorpal> it fails badly on any system on the lan
19:00:10 <Vorpal> that runs a http server
19:00:23 <elliott> I like it and dislike any browser I can't configure to work like that, whoop de doo, who cares
19:00:30 <ais523> Vorpal: are you one of the few people in the world who uses /etc/hosts for its intended purpose?
19:00:44 <CakeProphet> I usually just type my search and have absolutely no problems..
19:00:55 <ais523> CakeProphet: where do you type it?
19:00:59 <CakeProphet> but the ctrl+k thing is useful. I didn't know that.
19:01:10 <CakeProphet> ais523: in the address/search bar of Chrome.
19:01:15 <ais523> I tend to use my mouse to focus the search box, as web browsing is mouse-driven anyway
19:01:30 <elliott> <ais523> Vorpal: are you one of the few people in the world who uses /etc/hosts for its intended purpose?
19:01:33 <CakeProphet> ais523: same.
19:01:39 <elliott> ais523: routers usually handle assigning IPs to computer names, don't they?
19:01:45 <elliott> at least my router's DNS seems to, or whatever
19:01:48 <ais523> elliott: yes, or DNS
19:01:50 <elliott> that seems saner than keeping it on every system
19:01:53 <elliott> ais523: that's what I meant
19:02:04 <ais523> elliott: yes, that's why I asked Vorpal rather than you
19:02:07 <elliott> I still use my router's DNS because everything else ends up slower
19:02:09 <elliott> ais523: :-D
19:02:12 <CakeProphet> so, could I recursively mount root in my file system for great win?
19:02:24 <ais523> CakeProphet: you could use a loopback mount
19:02:33 <Vorpal> back
19:02:34 <ais523> but I'm not sure if it'd be a great win or a mild curiosity
19:02:39 <Vorpal> <ais523> Vorpal: are you one of the few people in the world who uses /etc/hosts for its intended purpose? <-- yes
19:02:50 <ais523> only time I saw a useful use for that was when we mounted / at /var/www/root on Normish
19:03:01 <CakeProphet> ais523: directory walking algorithms would rejoice and become immortal. They will bow down and worship me.
19:03:01 <ais523> and had the entire VM served to the web
19:03:13 <ais523> CakeProphet: amazingly, some of them have actually thought of that
19:03:27 <ais523> I know certain directory walking programs have flags not to change filesystems
19:03:29 <CakeProphet> what? why?
19:03:34 <CakeProphet> well, I mean
19:03:37 <CakeProphet> obviously we know why
19:03:50 <ais523> I think it's more useful to stop you directory-walking onto an NFS share
19:03:55 <ais523> in case you didn't mean to do that
19:04:01 <CakeProphet> makes sense I guess.
19:04:02 <pikhq> Why use /etc/hosts for its intended purpose? Not *that* hard to set up a DNS server.
19:04:24 <Vorpal> ais523, anyway I'm planning to switch over to running a zone on the caching dns server.
19:04:29 <ais523> pikhq: well, this explains why so few people use it that way, because there's not much of a reason
19:04:36 <pikhq> ais523: Yup.
19:04:36 <Vorpal> ais523, but I don't have many systems
19:04:39 <Vorpal> so *shrug*
19:04:42 <ais523> quite a few people use it to redirect sites they don't want to browse at localhost or 0.0.0.0 or whatever
19:05:00 <pikhq> Feh, that's what I've got Adblock for.
19:05:10 <ais523> well, it extends to not just browsing
19:05:23 <pikhq> When else would that come up?
19:05:23 <ais523> you can use it to block arbitrary Internet-capable applications from accessing certain sites by name
19:05:31 <ais523> stopping automatic updates on Windows is a semi-common use
19:05:42 <pikhq> Pretty much everywhere else, you're explicitly specifying a single host.
19:05:49 <Vorpal> ais523, you can do that in preferences
19:05:53 <elliott> also for self-control
19:05:57 <ais523> Vorpal: for the OS as a whole
19:05:59 <elliott> e.g. blacklisting away reddit.com
19:06:02 <Vorpal> ais523, hm
19:06:03 <ais523> individual programs can be nastier-behaved
19:06:07 <Vorpal> ah
19:06:19 <olsner> unless those applications include a DNS client... which would be a sensible thing to do if you want to make it a wee bit harder to work around their phone-home code
19:06:21 <ais523> on Windows everything has its own updater
19:06:40 <CakeProphet> best idea ever.
19:06:42 <ais523> many of which like sitting in the <s>system tray</s>notification area whether you're using the associated application or not, and even show a little icon to let you know they're running
19:06:43 <Vorpal> ais523, I used /etc/hosts to redirect minecraft when minecraft.net was down, so the program would time out logging in a fraction of a second instead of over a minute
19:06:54 <ais523> Vorpal: yes, that's a sensible abuse of it
19:06:59 <elliott> notification system tray area
19:07:02 <ais523> except the bit that implies you were playing minecraft
19:07:12 <elliott> ais523: eh? :P
19:07:15 <ais523> elliott: Microsoft have to go around denying that it's called the system tray
19:07:17 <elliott> Is that just an "I don't like Minecraft" comment, or?
19:07:25 <ais523> elliott: yes, it's just an I don't like Minecraft comment
19:07:33 <nooga> elliott: how advanced is Elliotcraft?
19:07:39 <elliott> nooga: I know of no such game
19:07:46 <Vorpal> ais523, anyway the best way to thwart phone home is a firewall to block that ip
19:07:56 <elliott> Elliottcraft I'm happy to talk about in #esoteric-minecraft, to avoid the wrath of ais523
19:08:00 <olsner> nooga: presumably it's a craft the like of which you have never seen
19:08:00 <ais523> because making petty jibes at things is easy to do when you're tired
19:08:08 <CakeProphet> nooga: hypothetically not as advanced as the hypothetical Cakecraft
19:08:09 <nooga> Elliottcraft*
19:08:10 <Vorpal> <ais523> except the bit that implies you were playing minecraft <-- what
19:08:14 <ais523> elliott: I don't necessarily dislike things similar to MInecraft
19:08:25 <olsner> Minecruft
19:08:31 <nooga> Yourcraft
19:08:42 <ais523> just the game itself annoys me due to being shallower than its competitors, badly-written, and attracting hordes of fanboys
19:08:45 <Vorpal> ais523, what did you mean with that phrase!?
19:08:53 <elliott> ais523: What would you consider its competitors? I'm curious.
19:09:00 <ais523> Vorpal: I would explain except that I already explained to elliott a few minutes ago
19:09:12 <elliott> ais523: just wait for his scrollback to scroll into the right place
19:09:14 <Vorpal> ah right
19:09:14 <Vorpal> there
19:09:15 <elliott> should only take a few more lines
19:09:18 <elliott> there we go
19:09:22 <Vorpal> elliott, :P
19:09:28 <Vorpal> elliott, yay now I have a valid excuse!
19:09:28 <CakeProphet> Cakecraft will support real death! and system clean up tools, which entails destroying your Windows partition.
19:09:32 <Vorpal> elliott, thank you so much
19:09:47 <ais523> elliott: in ##nomic I compared it to a game trying to do both what NetHack and Rubicon do, and doing them both really badly
19:09:52 <ais523> although it might have been a bad comparison
19:10:02 <ais523> I suppose it depends on what you want from a game
19:10:17 <elliott> ais523: while, mechanically, that may be true, I think the whole presentation and intent of a game matters greatly
19:10:20 <ais523> Sim City could be another comparison, too
19:10:24 <CakeProphet> it also serves as a sophisticated botnet! so that you can collaborate with other Cakecrafters and share computational resources, for example, to help me spam advertising for Cakecraft.
19:10:25 <Vorpal> ais523, dwarf fortress might be a better parallel, though much less intricate gameplay
19:10:28 <elliott> NetHack is, of course, a wildly different game as far as gameplay goes
19:10:41 <ais523> yep, but the premise is vaguely similar
19:10:43 <elliott> Dwarf Fortress too -- all those games have _goals_ of a sort :)
19:10:46 <ais523> even if the gameplay is very different
19:10:47 <Vorpal> of course very different game play again
19:10:56 <Vorpal> yes, minecraft is sandbox
19:11:09 <Vorpal> elliott, well, not dying could be a goal in minecraft?
19:11:12 <elliott> ais523: I agree that Minecraft is essentially not that interesting after you play it for a while, beyond some fun stuff like redstone circuits that are interesting for mainly reasons unrelated to the game itself; and Notch is obviously incompetent at practically everything
19:11:14 <ais523> I think my issue is that I don't see why a sandbox game should require you to gather the sand yourself
19:11:33 <Vorpal> elliott, I think minecraft really rocks because of SMP
19:11:38 <elliott> ais523: I think the essential presentation -- threedee world of purely blocks that you can mutate yourself creating a world with no inherent purpose -- is a really nice idea, hough.
19:11:39 <elliott> though.
19:11:51 <elliott> remember, Minecraft Classic was literally just that
19:11:53 <ais523> elliott: yep, I think that's a decent premise
19:11:58 <elliott> you could walk, jump, place blocks, and delete them (instantly)
19:12:04 <elliott> there was no health or anything, no time passing, nothing
19:12:05 <pikhq> It's a good idea, implemented by someone who's not that good at implementing these things.
19:12:10 <ais523> it's the addition of the other stuff that seems pointless, although some people seem to like it
19:12:10 <elliott> and it was still hugely popular, because that's the interesting core
19:12:15 <elliott> unfortunately, it needs to be added on to be truly interesting
19:12:17 <Vorpal> elliott, come on, have you still not got apple to fix your keyboard? How long does the warranty last
19:12:18 <elliott> and Notch stopped far too short
19:12:29 <ais523> hey, let's make a 3D Rubicon
19:12:29 <elliott> Vorpal: long enough for me to be lazy for a little while longer
19:12:32 <elliott> ais523: <ais523> it's the addition of the other stuff that seems pointless, although some people seem to like it
19:12:34 <Vorpal> elliott, ah
19:12:35 <elliott> I disagree here
19:12:38 <elliott> Classic gets boring quickly
19:12:38 <nooga> pistons
19:12:47 <elliott> once you've built a few houses, you're pretty much done
19:12:51 <ais523> elliott: well, I can imagine the addition of things to interact /with/
19:12:56 <ais523> just so long as it's optional or summonable
19:13:11 <Vorpal> ais523, like redstone?
19:13:21 <elliott> With Elliottcraft, I'm basically trying to make the world generation a lot more involved and detailed, and go from there
19:13:22 <ais523> Vorpal: I don't know what redstone is
19:13:22 <Vorpal> that 8-bit computer is really fun
19:13:24 <nooga> i've made a mod that gives you an editable ROM block
19:13:32 <elliott> majorly, I plan for there to be a lot of forces that aren't you
19:13:37 <ais523> elliott: this isn't Slaves to Armok III, is it?
19:13:38 <Vorpal> ais523, basically allows you do build logic gates in minecraft.
19:13:38 <elliott> unlike in Minecraft, where everything is either
19:13:40 <elliott> - you
19:13:46 <elliott> - idiotic and does nothing, only useful to kill
19:13:47 <pikhq> I'd say that redstone and rails where the two additions that Notch did that kept the interest up...
19:13:51 <elliott> - evil but really not that threatening
19:13:53 <elliott> ais523: It might be :)
19:14:06 <ais523> elliott: following the guidelines discussed in-channel?
19:14:09 <Vorpal> ais523, you have wire, you have power sources, and you have inverters. Someone built a simple CPU with it
19:14:10 <elliott> ais523: Not quite :P
19:14:12 <pikhq> Because it gives you more things *to actually build*, rather than "Oh, look, I can add some new blocks to my house. Whoo."
19:14:19 <elliott> ais523: Amusingly the main catalyst for this was how terrible Minecraft's network protocol is.
19:14:29 <elliott> ais523: You could literally tell it you were at any y position, and it would believe you.
19:14:32 <ais523> pikhq: I don't see why those couldn't be in minecraft classic
19:14:40 <elliott> You could even use this to fall from such a height that you _wrapped the health counter around_.
19:14:40 <pikhq> ais523: No particular reason.
19:14:45 <elliott> Making you effectively immortal.
19:14:50 <ais523> elliott: ah, is that how the warping commands worked?
19:14:55 <elliott> ais523: yep, actually
19:14:57 <ais523> I assumed it was some sort of debug feature
19:15:03 <elliott> ais523: nope, Notch is just really stupid
19:15:03 <ais523> but it's just trust-the-client?
19:15:07 <elliott> yep
19:15:11 <pikhq> ais523: Though, the mining *itself* would be interesting... If it got developed more.
19:15:13 <elliott> it was fixed recently, probably in a really terrible way
19:15:13 <nooga> Notch is stupid
19:15:14 <Vorpal> ais523, it doesn't work any more though
19:15:20 <ais523> I know the vast majority of games I've made have had some sort of teleport as a debug feature
19:15:23 <elliott> ais523: have I mentioned that client-side and server-side are two completely different codebases?
19:15:28 <elliott> two complete implementations of the same game
19:15:31 <elliott> OK, some things are shared
19:15:32 <pikhq> As it is, as soon as you have an iron pickaxe it's not that interesting, and as soon as you have diamond everything it's downright boring.
19:15:33 <ais523> elliott: that's less necessarily insane
19:15:34 <Vorpal> elliott, that said, I heard that movement being client side is quite common in many multiplayer games.
19:15:36 <ais523> depending on how it works
19:15:39 <elliott> but I think in the copy-and-paste the java files shared
19:15:42 <ais523> I wouldn't be surprised if it was insane in this case
19:15:55 <elliott> ais523: as in "there are tons of single-player and multi-player exclusive bugs that have nothing to do with the network or your hard disk"
19:15:55 <ais523> ah, they were doing the same calculations on different codebases? that's insane
19:16:01 <elliott> I don't know /how/
19:16:10 <elliott> even the most idiotic person would have a common library for this stuff
19:16:15 <elliott> Vorpal: yeah
19:16:22 <ais523> (I can see a plausible client-side = rendering and UI, server-side = logic split that wouldn't require common codebases)
19:16:37 <elliott> ais523: that's what I'm doing for Elliottcraft, basically
19:16:45 <Vorpal> elliott, so, notch wasn't that stupid when teleport worked. Just as stupid as most other
19:16:54 <ais523> it's what most sensible multiplayer games do unless it doesn't work for performance reasons
19:16:59 <elliott> ais523: you just connect to a local server, except it's changed slightly, in that it's made to share the map data between the srever and client in memory
19:17:04 <elliott> and it communicates directly rather than through a socket
19:17:07 <ais523> ah
19:17:13 <ais523> can it do sockets too, for multiplayer play?
19:17:15 <elliott> that's the plan, anyway
19:17:17 <elliott> ais523: yes, of course
19:17:21 <pikhq> This is something that IndustrialCraft gets right — there is a massive, massive tech tree to go through, rather than "3 days in and you're done".
19:17:38 <ais523> pikhq: so it's "finish the tech tree and you're done" instead?
19:17:39 <pikhq> (IndustrialCraft is a poorly documented but gigantic mod for Minecraft)
19:17:41 <elliott> ais523: I figure if I get all the hard problems of not trusting the client, synchronisation, timing blah blah blah right /once/, then the overhead should be sufficiently low that I can just use the same locally
19:17:55 <ais523> yep, agreed
19:18:04 <CakeProphet> Cakecraft = amazing physics playground that will never be made.
19:18:05 <pikhq> ais523: That would be on par with building your own 64 bit computer in Minecraft.
19:18:13 <pikhq> Sure, you *could*, but holy fuck it would take a long time.
19:18:23 <elliott> but really, the real reason minecraft sucks is because it has a tiny finite y dimension :(
19:18:33 <Vorpal> pikhq, I'm not sure I enjoy such a tech tree. I mostly play on a creative (free /give) server these days. With movecraft of course.
19:18:42 <ais523> well, in that case, it's like Pokémon where you don't go through the game with all 693 of them as you'd get bored past about 30 or 40
19:18:59 <Vorpal> (well, free /give apart from bedrock)
19:19:02 <elliott> I think the key with these sorts of games
19:19:04 <elliott> is
19:19:05 <pikhq> Though, disclaimer, I tend to play in a modded-up creative mode.
19:19:06 <elliott> make the player have enough fun
19:19:10 <elliott> that they don't realise there's no actual point to the game
19:19:12 <Vorpal> pikhq, ah
19:19:13 <elliott> or goal, or anything
19:19:18 <ais523> Vorpal: any command to unbedrock a square? it seems a plausible thing to add to a creative mod
19:19:24 <elliott> make that wait until they're talking on irc about it
19:19:29 <CakeProphet> elliott: it would be interesting if, instead of bedrock, there was a point where you reached the other side of the planet, and gravity inverted. :)
19:19:30 <elliott> hope they forget by the time they play again
19:19:32 <ais523> elliott: there doesn't have to be a goal if the game is generally fun, though
19:19:43 <ais523> a goal is something that can help to make games fun
19:19:45 <elliott> GUYS WHAT IS THE GOAL OF TETRIS???????
19:19:48 <ais523> if they're fun anyway, though, you don't need one
19:20:00 <Vorpal> ais523, well the server has worldedit (a plugin that adds an in game map editor basically) for the admins, that lets them break bedrock. Which can't normally be done.
19:20:01 <elliott> i have been playing for a year but i have still not won
19:20:18 <ais523> elliott: aim to reach the killscreen
19:20:24 <Vorpal> ais523, generally things work out nicely though, small group of players, whitelisted server
19:20:40 <Vorpal> ais523, killscreen?
19:20:53 <ais523> hmm, in a platformer I'm vaguely planning, I'll have a bedrock-equivalent called unobtanium
19:20:54 <Vorpal> tetris, what an utterly boring game
19:21:01 <Vorpal> I never liked that sort of arcade style
19:21:06 <ais523> as the name suits the way it behaves really well
19:21:09 <elliott> tetris is great
19:21:17 <elliott> until you stop playing
19:21:21 <CakeProphet> tetris is, in fact, fucking awesome.
19:21:22 <elliott> and realise how worthless that was
19:21:24 <Vorpal> elliott, I know some people like it. Good for them. I don't.
19:21:33 <elliott> but then you read a bullshit study about how it helps your brain to be the smarts
19:21:34 <ais523> Vorpal: in a computer game, a killscreen is a screen you reach where you've got so far in the game that the level you're on is completely impossible because it glitches out
19:21:34 <elliott> and you feel better
19:21:55 <Vorpal> elliott, I never manage to get past more than one or two of the levels. I think my record in gnome's tetris clone is level 4 or so
19:21:55 <elliott> ais523: pah, pacman doesn't have one of THOSE
19:21:56 <ais523> it's most famous in Pac-Man, where level 256 overwraps something or other and half the screen glitches out, meaning that the level can no longer be completed
19:21:59 <elliott> it just has a super-difficult last level
19:22:02 <elliott> ais523: it can, actually
19:22:03 <Vorpal> ais523, ah
19:22:03 <elliott> it's just a huge pain
19:22:23 <ais523> elliott: no, even if you collect every thing-it-thinks-is-a-dot, it still doesn't go to the next level
19:22:28 <elliott> hmm, really?
19:22:29 <elliott> fair enough then
19:22:31 <ais523> so although it's theoretically "completable", there's no reward for doing so
19:22:42 <Vorpal> not well tested eh
19:22:46 <ais523> best you can do is die and complete the level again, repeating until you're out of lives
19:22:53 <ais523> Vorpal: well, I doubt they expected anyone to reach level 256
19:23:03 <Vorpal> ais523, well, they were wrong
19:23:10 <elliott> Vorpal: not well-tested?
19:23:11 <ais523> after level 9 or so (I forget the last number), the same level just repeats over and over anyway, getting slightly faster each time
19:23:14 <elliott> it took /decades/ for anyone to reach that far
19:23:17 <Vorpal> elliott, ah
19:23:24 <ais523> and that was by memorising the RNG sequence
19:23:29 <ais523> (Pac-Man's RNG is very simpel)
19:23:30 <ais523> *simple
19:23:34 <ais523> and the sequence of inputs required to win
19:23:38 <Vorpal> heh
19:23:41 <elliott> in fact, it took much more time than it took for someone to find out that minecraft's terrain is actually way smaller than it claims to be :P
19:23:46 <elliott> (admittedly, that was by "cheating")
19:23:55 <Vorpal> yeah
19:24:29 <Vorpal> elliott, if people hadn't cheated, then it wouldn't have been found out in the next handful of years at least
19:24:36 <elliott> sure it would
19:24:46 <elliott> put stack of coins on return key and forward key
19:24:50 <elliott> leave for a month
19:24:55 <Vorpal> elliott, return?
19:24:56 -!- oerjan has joined.
19:24:57 <elliott> return to find the game crashed :D
19:24:59 <Vorpal> you mean space?
19:25:01 <elliott> Vorpal: er right
19:25:08 <Vorpal> <elliott> return to find the game crashed :D <-- come on, it does that anyway
19:25:28 <Vorpal> elliott, what ACTUALLY would have happened would be that you had fallen into a deep pit and now stood jumping against the wall
19:25:39 <Vorpal> or even 2 high blocks
19:25:47 <elliott> yeah yeah :P
19:26:00 <elliott> you could script it, though whether you consider that "cheating"...
19:26:01 <elliott> but who cares
19:26:10 <elliott> you can't cheat at a sandbox game
19:26:13 <Vorpal> true
19:26:23 <ais523> something I realised last night: radix sort is actually O(n log n), and people have been misrepresenting it all this time
19:26:31 <Vorpal> elliott, what about SMP survival servers, you could probably "cheat" there
19:26:40 <ais523> comparison sorts use comparisons, which take the same length of time for the first and last comparisons
19:26:46 <ais523> but radix sort increments bin counts
19:26:48 <elliott> Vorpal: only 'cuz notch sucks
19:26:53 <ais523> and adding 1 to a number is O(log n)
19:27:10 <elliott> ais523: arithmetic is considered to be O(1) in big-O analysis usually
19:27:13 <ais523> what does SMP stand for, btw? something multiplayer?
19:27:14 <Vorpal> elliott, speaking of which, the "flying detection" in bukkit is really buggy. It thought I was flying when I went down a ladder, removing it under me
19:27:17 <ais523> elliott: that's cheating!
19:27:19 <elliott> ais523: no it isn't
19:27:25 <elliott> ais523: who said we had to go by the laws of real-life computers?
19:27:28 <elliott> that's arbitrary
19:27:39 <elliott> picking something nice and simple like arithmetic to be O(1) is perfectly reasonable
19:27:41 <ais523> elliott: well, the number takes O(log n) space to represent
19:27:46 <ais523> and time complexity >= space complexity
19:28:18 <Vorpal> ais523, you could do a large adder as a combinatorial circuit maybe
19:28:23 <Vorpal> in theory you could
19:28:27 <ais523> Vorpal: but that puts a limit
19:28:33 <ais523> on the size of the numbers added
19:28:42 <ais523> so it's O(infinity) with optimizations for small n
19:28:42 <oerjan> <ais523> and adding 1 to a number is O(log n)
19:28:44 <Vorpal> ais523, why don't people use something like double-adders or such
19:29:04 <Vorpal> ais523, that is half the number of carries
19:29:08 <oerjan> i don't think that's right with ...damn tip of tongue...
19:29:18 <elliott> oerjan: capitalism?
19:29:27 <Vorpal> oerjan, incrementing?
19:29:32 <elliott> oerjan: dodecahedron
19:29:35 <elliott> oerjan: brontosaurus
19:29:37 <elliott> oerjan: oligarchy
19:29:38 <Vorpal> oerjan, crocodile
19:29:41 <oerjan> no, that thing they use to describe functional data structures
19:29:41 <elliott> oerjan: rocks
19:29:44 <ais523> Vorpal: well, for very wide additions, there's often separate circuitry to calculate the carries at midpoints, etc
19:29:45 <elliott> oerjan: fortuitousness
19:29:53 <ais523> oerjan: some sort of zipper?
19:29:54 <Vorpal> oerjan, definitely crocodile then
19:29:57 <oerjan> i think it starts with a
19:29:59 <elliott> oerjan: infelicity
19:30:04 <elliott> oerjan: rhombus
19:30:04 <Vorpal> oerjan, aardvark
19:30:10 <oerjan> ais523: those creeps are not helping :D
19:30:12 <elliott> oerjan: cartographing
19:30:16 <elliott> oerjan: Istanbul
19:30:16 <Vorpal> ais523, you mean carry-lookahead?
19:30:19 <elliott> oerjan: cashmere
19:30:22 <CakeProphet> oerjan: abstract data type?
19:30:25 <elliott> oerjan: pastiche
19:30:26 <ais523> Vorpal: yes
19:30:28 <oerjan> no, about their complexity
19:30:32 <elliott> oerjan: fanned
19:30:35 <Vorpal> oerjan, Big O notation?
19:30:35 <elliott> am i helping
19:30:39 <oerjan> no!
19:30:40 <elliott> Vorpal: that isn't a word, moron
19:30:45 <Vorpal> elliott, oh true
19:30:51 <Vorpal> elliott, he said it started with a.
19:30:54 <elliott> oh
19:30:59 <elliott> oerjan: affluency
19:31:03 <elliott> oerjan: apex
19:31:05 <elliott> oerjan: aperture
19:31:08 <elliott> oerjan: axiomata
19:31:11 <elliott> oerjan: all
19:31:13 <Vorpal> elliott, I already did aardvark btw
19:31:14 <elliott> oerjan: able
19:31:16 <oerjan> i'm not _sure_ it starts with an a
19:31:19 <elliott> oerjan: acrimonious
19:31:26 <Vorpal> oerjan, oh. Hm array?
19:31:29 <elliott> oerjan: astigmatism
19:31:40 <elliott> oerjan: arachnophobe
19:31:45 <oerjan> YOU WON'T GUESS IT IF YOU HAVEN'T HEARD IT
19:31:45 <elliott> oerjan: alter
19:31:52 <elliott> oerjan: annals
19:31:56 <elliott> AM I HELPING YET
19:31:59 <Vorpal> elliott, altar, you forgot that
19:32:04 <elliott> Vorpal: that's not a word silly.
19:32:05 <oerjan> it's about the complexity of functional data structures
19:32:06 <ais523> elliott: it'd help more if the words were vaguely related to the field
19:32:13 <ais523> oerjan: amortization?
19:32:14 <elliott> ais523: I'm just trying to be thorough
19:32:14 <Vorpal> elliott, isn't "altar" a word?
19:32:20 <oerjan> ais523: THANK GOD
19:32:25 <elliott> oerjan: should I leaf through my copy of Purely Functional Data Struc- oh
19:32:25 <Vorpal> aww
19:32:27 <elliott> well I could have guessed that
19:32:32 <ais523> elliott: see, it takes you all those guesses and I only took two
19:32:35 <elliott> why didn't you SAY that was the word you were looking for
19:32:36 <Vorpal> elliott, sooner or later yes
19:32:49 * oerjan swats elliott -----###
19:33:05 <ais523> I still don't think it's O(1) with amortization, but I'm not sure
19:33:07 <ais523> maybe O(log log n)
19:33:11 <Vorpal> ais523, come on elliott was being intentionally silly. (More so than me)
19:33:13 <oerjan> ais523: basically if you are counting stuff, the _average_ bin addition only takes O(1)
19:33:22 <oerjan> *bin increment
19:33:27 <elliott> Vorpal: I was actually seeing how well I could generate random words, too
19:33:29 <elliott> turns out: pretty well
19:33:42 <Vorpal> ais523, hm come up with something that is O(log_{log n} n)
19:33:48 <ais523> Vorpal: why?
19:33:57 <oerjan> 1/2 take 1, 1/4 take 2, 1/8 take 3
19:33:57 <Vorpal> ais523, because I can't think of something like that
19:34:11 <oerjan> ais523: ok maybe slightly more than O(1) but not O(log n)
19:34:27 <ais523> oerjan: ah, so it averages out at 2
19:34:28 <ais523> yep, I agree with you now
19:34:39 <Vorpal> ais523, if you are just adding these together, couldn't you do a partial sum thingy and add the carry in at the end?
19:34:55 <ais523> oerjan: O(2) I think
19:34:56 * ais523 runs
19:35:00 <oerjan> XD
19:35:06 <Vorpal> ais523, as in this http://en.wikipedia.org/wiki/Carry_save_adder
19:35:21 <ais523> Vorpal: we're talking about the asymptotic behaviour of repeated increments
19:35:56 <CakeProphet> My goal in life: implement constant time list search using acquired magical abilities.
19:36:06 <Vorpal> ais523, yes and I say you could do it in O(1) per addition even for repeated arbitrary additions. Using carry save
19:36:28 <elliott> *Sylladex.VM> runVM (ExcCtx test Map.empty) (snd (head test)) []
19:36:28 <elliott> [VInt 1999]
19:36:31 <elliott> thats not rite
19:36:56 <elliott> Oh wait
19:37:03 <ais523> Vorpal: that requires O(n log n) /space/
19:37:06 <elliott> Wait WHAT
19:37:08 <Vorpal> ais523, true
19:37:10 <ais523> because your numbers have to have arbitrary digits in
19:37:22 <ais523> that's kind-of much worse than O(1) or even O(log n)
19:37:51 <elliott> the best complexity is O(log log log log log log n)
19:37:52 <elliott> and NO less
19:38:01 <ais523> incidentally, my Slashdot sig (the shortest known INTERCAL adder) is basically iterated carry-save
19:38:10 <ais523> (without using the standard library, that is)
19:38:12 <Vorpal> ais523, hm wait, it just needs 2* the space of the number in bits
19:38:13 <elliott> Do a distributed search for a shorter adder. :p
19:38:19 <elliott> It'll be like protein folding, only even more worthwhile.
19:38:22 <CakeProphet> ais523: in fact, it's n log n - log n worse
19:38:38 <elliott> INTERCAL@home
19:38:44 <ais523> CakeProphet: I don't think computational classes add/subtract like that
19:38:52 <elliott> AND YOU THOUGHT YOU COULD KEEP IT CONFINED TO YOUR WORKPLCAE
19:38:54 <elliott> [asterisk]PLACE
19:38:56 <CakeProphet> they do for purposes of comparison. :D
19:39:08 <ais523> elliott: I've expended quite a lot of thought to getting an adder in a single expression, but I haven't found a way to do it that isn't really really long
19:39:20 <ais523> I think I managed something like a one-expression increment that was only a few hundred characters long
19:39:36 <Vorpal> `addquote <ais523> I think I managed something like a one-expression increment that was only a few hundred characters long
19:39:37 <HackEgo> ​442) <ais523> I think I managed something like a one-expression increment that was only a few hundred characters long
19:39:51 <elliott> that was funny?
19:39:58 <Vorpal> elliott, yes, more so out of context
19:40:21 <Vorpal> elliott, imagine this without context. Then it sounds fun
19:40:24 <nooga> that's weird
19:40:30 <elliott> it
19:40:31 <elliott> doesn't
19:40:36 <oerjan> 21:37 elliott> the best complexity is O(log log log log log log n)
19:40:36 <oerjan> 21:37 elliott> and NO less
19:40:47 <nooga> windows 7 uses 100% cpu with no process to blame
19:40:53 <oerjan> so you don't approve of that inverse ackermann thing for union find?
19:40:58 <elliott> oerjan: i'm sorry who has the phd here.
19:41:00 <elliott> exactly.
19:41:04 <elliott> stop questioning things i say.
19:41:05 <elliott> take them at face value.
19:41:06 <nooga> the cpu is 100% bussy constantly and i don't know why
19:41:51 <Vorpal> <oerjan> so you don't approve of that inverse ackermann thing for union find? <-- wait what
19:42:08 <elliott> DAMMIT RUNVM
19:42:10 <elliott> THIS MAKES NO SENSE
19:42:11 <elliott> I HATE YOU
19:42:14 <elliott> AND ALL YOUR GUTS
19:42:18 <Vorpal> elliott, what is runvm?
19:42:32 <elliott> a function
19:42:33 <elliott> OH WIAT
19:42:34 <elliott> duh
19:42:43 <elliott> ugh wow this is going to be so ugly
19:42:52 <oerjan> Vorpal: there's this algorithm called union find that works in time O(n + inverse of ackermann)
19:42:54 -!- adam__ has joined.
19:42:55 <elliott> wow uh can i even
19:42:56 <elliott> jesus
19:43:00 <elliott> ok wait what if i
19:43:01 <elliott> augh
19:43:08 <elliott> TIME TO NEST THE LIST MORE LOL
19:43:11 <elliott> oh god wait no i can't do that
19:43:17 <oerjan> hm i guess that's higher than O(log log ... n) actually, because of the O(n)
19:43:22 <elliott> hey guys
19:43:27 <elliott> how do i represent some machine code in haskell :(
19:43:28 <ais523> oerjan: wouldn't that just be equivalent to O(n)?
19:43:36 <elliott> [(Label,[Ins])] sucks
19:43:36 <oerjan> i may misremember stuff, i only saw it mentioned again yesterday on godel's lost letter
19:43:41 <elliott> because implementing the fall-through to the next label
19:43:42 <elliott> is a pain
19:43:45 <ais523> just like O(n + log n) is equivalent to O(n)?
19:43:48 <elliott> in the evaluation function
19:43:48 <elliott> halp
19:43:52 <oerjan> ais523: um maybe it was O(1+inverse ackermann)
19:43:54 <Vorpal> oerjan, what is union find for?
19:43:58 <ais523> that would make more sense
19:44:08 <oerjan> lemme look it up
19:44:15 <ais523> elliott: I'm on the point of inventing a new language to solve that sort of problem
19:44:21 <oerjan> oh wait it was something about mazes, not GLL
19:44:26 <elliott> ais523: ugh
19:44:27 <ais523> so far it only has a few basic ideas and a name that doesn't really fit but that I'll use anyway
19:44:36 <elliott> hmm, I suppose I could like
19:44:53 <elliott> [(0,all:the:instructions:xs), (1,xs)]
19:44:54 <elliott> i.e.
19:45:01 <elliott> each label actually includes a pointer to all the code following it too
19:45:03 <elliott> by consing it on
19:45:04 <elliott> but uh
19:45:05 <elliott> ew
19:45:52 <oerjan> Vorpal: http://www.algorithmist.com/index.php/Union_Find
19:45:53 <elliott> have i mentioned that the only reason i'm writing this function is to serve as a reference implementation
19:45:57 <Vorpal> oerjan, ah
19:46:27 -!- CakeProphet has quit (Ping timeout: 276 seconds).
19:46:29 <Vorpal> oerjan, cool
19:46:47 <elliott> i wonder if that's like
19:46:54 <elliott> the fastest above-constant complexity
19:46:59 <elliott> for something that actually doe s something of interest
19:47:08 <Vorpal> elliott, it probably comes pretty close
19:47:23 <Vorpal> elliott, of course O(log ackinv(n)) would be even better
19:47:49 <elliott> yes but is there any algorithm that does anything of interest that has that complexity?
19:47:58 <Vorpal> not that I know of
19:48:47 <ais523> hmm, Union Find seems to be similar to implementing a dialog of Prolog where you had nothing but variables and =
19:48:57 <ais523> e.g. A = B, A = C, D = E, etc
19:49:04 <ais523> and the question was if two of them were unified at any given point or not
19:49:38 <oerjan> <elliott> [(Label,[Ins])] sucks <-- maybe just make Label an element of Ins, then?
19:49:52 <elliott> oerjan: that makes jumping to a label really slow
19:49:57 <elliott> you have to linearly scan all the code up to it
19:50:09 <elliott> ok that's like
19:50:15 <elliott> only a multiplicative factor of what you have to do anywya
19:50:18 <elliott> [asterisk]anyway
19:50:19 <elliott> but ew come on
19:50:31 <elliott> btw this structure actually works fairly decently for the actual compilers? just not for an interpreter
19:50:38 <elliott> so I don't want to make it worse on the actual compilers? even though that wouldn't but
19:50:42 <Vorpal> elliott, keep track of labels in a AVL tree with pointers to the relevant code line/node/whatevere?
19:50:43 <elliott> basically what i am saying is
19:50:45 <elliott> that is kind of ew oerjan.
19:50:45 <Vorpal> whatever*
19:51:09 <pikhq> elliott: I don't think you got the memo, but I think I could port util-linux to musl in a couple of hours.
19:51:17 <oerjan> <Vorpal> elliott, of course O(log ackinv(n)) would be even better <-- that may be indistinguishable from ackinv(n) by mortals :P
19:51:18 <elliott> pikhq: do it
19:51:27 <Vorpal> oerjan, there is that yes
19:51:28 <pikhq> elliott: The only really non-trivial bit would be implementing error().
19:51:48 <pikhq> elliott: Everything else, near as I can tell, is a matter of unincluded bits.
19:52:07 <pikhq> Darned easy to fix includes.
19:52:17 <elliott> what does error do again
19:52:44 <oerjan> elliott: you can make a Map for jumping to labels even if you put the labels in the code. hm actually if you do that you don't need to include the labels in the code again
19:53:24 <oerjan> elliott: you can use knot tying to only calculate this once, i think
19:53:32 <elliott> oerjan: knot tying...scares me.........
19:53:59 <pikhq> elliott: void error(int status, int errnum, const char *format, ...);. Prints the program name, a colon, and a space, then the format string, then strerror(errnum) if errnum != 0, then exit(status) if status != 0.
19:54:21 <oerjan> elliott was once tied up by function pedobear
19:54:25 <oerjan> *functional
19:54:49 <elliott> pikhq: that's
19:54:50 <elliott> difficult?
19:54:50 <oerjan> my theory that muphry's law applies to any sufficiently cheesy joke seems to hold
19:54:56 <elliott> because of the program name part?
19:55:32 <pikhq> elliott: The reason I said "2 hours" is because there's a hell of a lot of misincluding. :P
19:56:14 <oerjan> ais523: the place i saw this was about implementing mazes by starting with a grid and removing random walls between rooms that had no connection already, this needs union find to check for connectedness
19:56:38 <ais523> oerjan: ah, that's another application for much the same thing
19:56:57 <ais523> I tend not to end up using standard algorithms that much beyond dijkstra/A*/priority queues/sorts
19:57:30 <ais523> although recently for my work, I had to find a list of strongly connected components in a partial preorder (like tsort, except focusing on the error condition rather than the success condition)
19:57:34 <elliott> the best algorithms are ones that involve spinning around a lot
19:58:17 <ais523> luckily, I found one on Wikipedia, and implemented it, even if I'm not entirely sure on how it works
19:59:24 <oerjan> ais523: i wonder if there would be advantages to a prolog implementation using union find for unification
19:59:53 <ais523> oerjan: the major issue is that you probably want to be able to free things again when they go out of scope
19:59:56 <elliott> [PDF] Optimal Union-Find in Constraint Handling Rules
19:59:56 <elliott> File Format: PDF/Adobe Acrobat - Quick View
19:59:56 <elliott> by T Schrijvers - Cited by 65 - Related articles
19:59:56 <elliott> possible to write the classic union-find algorithm and variants in CHR. ... For example, one often hears the argument that in Prolog some graph algorithms .... to combine the existing CHR solvers for term unification with our union- ...
19:59:57 <elliott> citeseer.ist.psu.edu/viewdoc/download;jsessionid...?doi=10.1.1...
19:59:58 <oerjan> yeah
19:59:59 <ais523> and that's going to be slower than the actual unification
19:59:59 <elliott> i guess that's an implementation though
20:00:02 <elliott> rather than using it as a technique
20:02:01 <pikhq> elliott: So far, 21 files that don't build right, and several more stupid warnings.
20:02:30 <ais523> <Maharba> as always, replying to ehird
20:02:54 <elliott> :D
20:03:14 <elliott> ais523: this is why you make your spec perfect the _first_ time round
20:04:11 <oerjan> ais523: hm that rank comparison thing in that wiki article i linked should be applicable to unification while still allowing easy freeing. i think that's essentially a way to prevent too long chains of unified variables, no?
20:04:51 <ais523> oerjan: yep, but the issue is you need reverse pointers to free something
20:05:06 <ais523> because if one of your variables happens to be a root, there's no way you can free it without fixing up everything pointing to it
20:05:13 <oerjan> well yeah but you need that for unification anyway?
20:05:30 <ais523> oerjan: Union-Find doesn't let you know everything in the same set as something
20:05:32 <ais523> just if two things are in the same set
20:05:45 <oerjan> ais523: i'm just saying this rank thing is a way to be careful _which way_ you identify
20:06:56 <elliott> oerjan: did you figure out a better data structure for the asm :D
20:07:03 -!- augur has quit (Remote host closed the connection).
20:07:33 <oerjan> elliott: um my idea now is to simply have a list for the whole code from start to finish, and represent the labels by pointers into that
20:07:52 <elliott> oerjan: ah
20:08:01 <elliott> oerjan: I would quite like there to be integers too, although I suppose I could just make
20:08:04 <elliott> type Label = (Int,Prog)
20:08:19 <oerjan> elliott: or put differently, approximately your [(Label,[Ins])] except you _don't_ stop the [Ins] list before the next label
20:08:50 <elliott> oerjan: I see a fairly major issue -- it will make Show practically impossible
20:08:56 <elliott> because the structure will be effectively infinite
20:09:00 <oerjan> hm
20:09:37 <oerjan> always an issue
20:09:47 <Phantom_Hoover> ineiros why is your server OUTDATES
20:09:47 <lambdabot> Phantom_Hoover: You have 12 new messages. '/msg lambdabot @messages' to read them.
20:09:52 <Phantom_Hoover> elliott, FFS.
20:09:56 <Phantom_Hoover> I was online!
20:10:26 <elliott> That's... that's a good point.
20:10:31 <Phantom_Hoover> elliott, you broke it again. Congratulations.
20:10:34 <elliott> Nice.
20:11:00 <oerjan> elliott: ok then, have your original [(Label,[Ins])] but make a second variant which doesn't end, for easy fall through
20:11:17 <elliott> oerjan: what do you mean by a second variant?
20:11:39 <elliott> oerjan: I'm really tempted just to roll in the labels into the actual Ins like you said
20:11:47 <elliott> the linear scan for interpretation is not that big a deal, the interpreter is just like
20:11:49 <elliott> to be reference semantics
20:14:08 <oerjan> > let f = zip . scanr1 (++) . unzip in f [(1,"ab"), (2,"cde"), (3,"f")]
20:14:09 <lambdabot> Couldn't match expected type `[a]'
20:14:09 <lambdabot> against inferred type `([a1], [b...
20:14:18 <elliott> i'm just doing it in a simple way instead >_>
20:14:19 <oerjan> fnord
20:14:21 <elliott> whups
20:14:43 <oerjan> > let f = zip . second (scanr1 (++)) . unzip in f [(1,"ab"), (2,"cde"), (3,"f")]
20:14:43 <lambdabot> Couldn't match expected type `[a]'
20:14:44 <lambdabot> against inferred type `(d, [a1])'
20:15:36 <oerjan> :t zip . second (scanr1 (++)) . unzip
20:15:37 <lambdabot> Couldn't match expected type `[a]'
20:15:37 <lambdabot> against inferred type `(d, [a1])'
20:15:37 <lambdabot> In the first argument of `(.)', namely `second (scanr1 (++))'
20:15:46 <oerjan> :t scanr1 (++)
20:15:47 <lambdabot> forall a. (Monoid a) => [a] -> [a]
20:16:02 <oerjan> bloody caleskell :P
20:16:18 <oerjan> :t second (scanr1 (++))
20:16:19 <lambdabot> forall a d. (Monoid a) => (d, [a]) -> (d, [a])
20:16:25 <oerjan> :t second (scanr1 (++)) . unzip
20:16:25 <lambdabot> forall a a1. (Monoid a) => [(a1, a)] -> ([a1], [a])
20:16:44 <oerjan> :t zip . second (scanr1 (++)) . unzip
20:16:44 <lambdabot> Couldn't match expected type `[a]'
20:16:45 <lambdabot> against inferred type `(d, [a1])'
20:16:45 <lambdabot> In the first argument of `(.)', namely `second (scanr1 (++))'
20:16:55 <oerjan> :t zip
20:16:56 <lambdabot> forall a b. [a] -> [b] -> [(a, b)]
20:16:58 <oerjan> oh hm
20:17:03 <elliott> runVM ctx ((_, IPush x : is):iss) xs = runVM ctx (is:iss) (x:xs)
20:17:05 <elliott> look at dat ugliness
20:17:13 <oerjan> > let f = curry zip . second (scanr1 (++)) . unzip in f [(1,"ab"), (2,"cde"), (3,"f")]
20:17:14 <lambdabot> Couldn't match expected type `(a, b)' against inferred type `[a1]'
20:17:23 <oerjan> NOW WHAT
20:17:30 <oerjan> :t curry zip . second (scanr1 (++)) . unzip
20:17:31 <lambdabot> Couldn't match expected type `(a, b)' against inferred type `[a1]'
20:17:31 <lambdabot> In the first argument of `curry', namely `zip'
20:17:31 <lambdabot> In the first argument of `(.)', namely `curry zip'
20:17:46 <oerjan> :t curry zip
20:17:47 <lambdabot> Couldn't match expected type `(a, b)' against inferred type `[a1]'
20:17:47 <lambdabot> In the first argument of `curry', namely `zip'
20:17:47 <lambdabot> In the expression: curry zip
20:18:03 <oerjan> wtf
20:18:18 <oerjan> :t uncurry zip
20:18:19 <lambdabot> forall a b. ([a], [b]) -> [(a, b)]
20:18:26 <oerjan> > let f = uncurry zip . second (scanr1 (++)) . unzip in f [(1,"ab"), (2,"cde"), (3,"f")]
20:18:27 <lambdabot> [(1,"abcdef"),(2,"cdef"),(3,"f")]
20:18:39 <elliott> oh wait argh
20:18:40 <elliott> this is even uglier
20:18:52 <oerjan> i always get curry and uncurry mixed up
20:18:59 <oerjan> elliott: ^
20:19:05 <elliott> oerjan: nice
20:19:11 <elliott> oerjan: unfortunately i'll end up recomputing that a ton
20:19:15 <elliott> unless i do something really ugly
20:19:17 <elliott> which i guess i could
20:19:46 <oerjan> um why? unless the language is self-modifying
20:20:01 <elliott> no just as in
20:20:02 <elliott> jhfhjg
20:20:07 <elliott> its fine thank you
20:20:15 <oerjan> you mean not caching? :P
20:21:06 <elliott> ya
20:24:16 * oerjan wonders how lazy scanr is
20:24:47 <oerjan> > map (take 5) . take 5 . scanr1 (++) $ [1..]
20:24:48 <lambdabot> No instances for (GHC.Num.Num [a], GHC.Enum.Enum [a])
20:24:49 <lambdabot> arising from a use...
20:24:55 <oerjan> erm
20:25:31 <oerjan> > map (take 5) . take 5 . scanr1 (++) $ map show [1..]
20:25:33 <lambdabot> ["12345","23456","34567","45678","56789"]
20:25:51 <oerjan> lazy enough, it seems :P
20:26:42 <ais523> :t scanr
20:26:43 <lambdabot> forall a b. (a -> b -> b) -> b -> [a] -> [b]
20:26:52 <ais523> hmm, what is scanr doing?
20:27:07 <oerjan> ais523: otoh that path compression thing is something i've pondered as useful for both FORTE and Reaper (although neither actually _implemented_...)
20:27:23 <ais523> > scanr (\a.\b.a+b) 4 [1,2,3,4,5,6]
20:27:24 <lambdabot> <no location info>: parse error on input `.\'
20:27:31 <ais523> > scanr (\a -> \b -> a+b) 4 [1,2,3,4,5,6]
20:27:32 <pikhq> Hmm. Should I just try to do a reimplementation of error(), or should I just replace all mentions of it?
20:27:32 <lambdabot> [25,24,22,19,15,10,4]
20:27:42 <oerjan> > scanr f x [a,b,c,d] :: Expr
20:27:43 <lambdabot> Couldn't match expected type `SimpleReflect.Expr'
20:27:43 <lambdabot> against inferred ...
20:27:48 <ais523> ah, it's doing a cumulative sum
20:27:49 <oerjan> dammit
20:28:10 <ais523> so a scan is basically a fold that saves intermediate results?
20:28:16 <oerjan> yeah
20:28:27 <oerjan> > scanl1 (*) [1..]
20:28:28 <lambdabot> [1,2,6,24,120,720,5040,40320,362880,3628800,39916800,479001600,6227020800,8...
20:29:05 -!- ais523 has quit (Remote host closed the connection).
20:29:05 <copumpkin> > scanl1 (+) [1,3..]
20:29:06 <lambdabot> [1,4,9,16,25,36,49,64,81,100,121,144,169,196,225,256,289,324,361,400,441,48...
20:29:08 <elliott> it would be nice to have a programming language that actually made you feel strongly physically uncomfortable when you tried to programi n it
20:29:13 <elliott> it would be a real step forward in esoteric programming
20:29:47 <oerjan> elliott: so that means you really appreciate Snack, then? >:P
20:29:54 <elliott> :D
20:30:23 <elliott> god dammit Maharba, adding new operations to syl :(
20:31:15 <oerjan> look at the positive of it, you have to learn how to program in a highly modular and modifiable way :P
20:31:46 <elliott> :D
20:31:58 * elliott waits for the inevitable talk page comment
20:32:03 <oerjan> :t scanr f x [a,b,c,d]
20:32:03 <lambdabot> [Expr]
20:32:08 <oerjan> oh duh
20:32:15 <oerjan> > scanr f x [a,b,c,d] :: [Expr]
20:32:16 <lambdabot> [f a (f b (f c (f d x))),f b (f c (f d x)),f c (f d x),f d x,x]
20:32:30 <oerjan> sadly ais523 left
20:33:03 <elliott> left us bleeding
20:36:30 <Vorpal> <elliott> god dammit Maharba, adding new operations to syl :( <-- implement syl version whatever
20:37:44 <Vorpal> :t f
20:37:45 <lambdabot> forall a. (SimpleReflect.FromExpr a) => a
20:37:50 <Vorpal> huh?
20:37:56 <Vorpal> :t
20:37:59 <Vorpal> :t SimpleReflect.FromExpr
20:37:59 <lambdabot> Not in scope: data constructor `SimpleReflect.FromExpr'
20:38:06 <elliott> :info SimpleReflect.FromExp
20:38:06 <Vorpal> :i SimpleReflect.FromExpr
20:38:06 <elliott> :info SimpleReflect.FromExpr
20:38:10 <elliott> ?src SimpleReflect.FromExpr
20:38:10 <lambdabot> Source not found. I feel much better now.
20:38:12 <elliott> ?src FromExpr
20:38:12 <lambdabot> Source not found. stty: unknown mode: doofus
20:38:13 <Vorpal> :info SimpleReflect.FromExpr
20:38:21 <elliott> ?hoogle simplereflect
20:38:21 <lambdabot> No results found
20:38:22 <elliott> ?google simplereflect
20:38:24 <elliott> oh where is it
20:38:26 <lambdabot> http://hackage.haskell.org/package/simple-reflect
20:38:26 <lambdabot> Title: HackageDB: simple-reflect-0.2
20:38:39 <elliott> there
20:38:46 <Vorpal> :t a
20:38:47 <lambdabot> Expr
20:38:49 <Vorpal> hm
20:39:13 <Vorpal> :t hasd
20:39:13 <lambdabot> Not in scope: `hasd'
20:39:17 <Vorpal> okay
20:39:46 <oerjan> they made all single letters be Expr, except f g h which have an overloaded type which can be used for functions
20:39:46 <Vorpal> :t g
20:39:47 <lambdabot> forall a. (SimpleReflect.FromExpr a) => a
20:39:52 <Vorpal> ah
20:40:55 <Phantom_Hoover> OK what is the deal with the weak force.
20:41:12 <Phantom_Hoover> Why do people call it a force.
20:41:13 <Phantom_Hoover> It isn't.
20:41:20 <Phantom_Hoover> It's not even all that weak.
20:41:24 <oerjan> > sum [a,b,c,d]
20:41:25 <lambdabot> 0 + a + b + c + d
20:41:30 <Vorpal> Phantom_Hoover, it is weak compared to the strong force iirc?
20:41:40 <oerjan> the Num instance is _really_ primitive
20:42:12 <elliott> howso
20:42:32 <oerjan> it doesn't even simplify 0 + away :P
20:42:44 <Phantom_Hoover> Vorpal, yes, but it's not that much weaker, and I think both electromagnetism and gravity are weaker still.
20:42:47 <oerjan> > scanr1 (+) [a,b,c,d]
20:42:47 <lambdabot> [a + (b + (c + d)),b + (c + d),c + d,d]
20:42:51 <oerjan> er
20:42:56 <oerjan> > foldr1 (+) [a,b,c,d]
20:42:57 <lambdabot> a + (b + (c + d))
20:42:59 <Vorpal> Phantom_Hoover, gravity certainly is
20:43:03 <pikhq> I'll be damned, there's actually something that's not sufficiently supported in musl.
20:43:10 <pikhq> musl does not have wcsdup.
20:43:18 <pikhq> The wchar_t analogue of strdup.
20:43:28 <elliott> that's like
20:43:28 <Vorpal> pikhq, easy to implement yourself
20:43:30 <oerjan> Phantom_Hoover: i think they used to be called weak and strong _nuclear_ force
20:43:32 <elliott> a whole three lines to implement ZOMG :D
20:43:41 <oerjan> somewhere that word got dropped
20:43:55 <elliott> Phantom_Hoover: what's the strongest weak force you know of in't
20:44:00 <Phantom_Hoover> oerjan, which is half right, but it still doesn't actually behave as a force.
20:44:12 <Vorpal> Phantom_Hoover, oh?
20:44:39 -!- augur has joined.
20:44:50 <Phantom_Hoover> Vorpal, the only example of its effects that anyone who isn't a particle physicist knows about is beta decay.
20:45:03 <Phantom_Hoover> Which is... a decay, not a force in the conventional sense.
20:45:05 <Vorpal> Phantom_Hoover, ah
20:45:16 <Vorpal> Phantom_Hoover, but for those who are particle physicists?
20:45:57 <pikhq> *For now*, I'll just tell the build system that there's no wide character support.
20:46:16 <pikhq> But later, I'll actually add a wcsdup.
20:46:20 <oerjan> Phantom_Hoover: well presumably that decay can happen because there is a weak force between neutrinos and quarks?
20:46:25 <Phantom_Hoover> There are some more neutrino/nucleon interactions it's involved with, although they still don't work that forcily.
20:47:02 <Phantom_Hoover> oerjan, it's more like a down quark spontaneously emits a W- boson which then decays into an electron and an antineutrino.
20:47:34 <oerjan> Phantom_Hoover: you could say all electromagnetism is is decay of excited charged particles into non-excited particles and photons :P
20:47:35 <elliott> your mom is a quark end of discussion
20:48:02 <Phantom_Hoover> oerjan, you don't have <particle> → <different particle>, though.
20:48:04 <oerjan> (i _think_)
20:48:44 <Phantom_Hoover> There does seem to be a normal stuff-flies-apart-or-moves-together interaction between nucleons and neutrinos, though.
20:48:50 <oerjan> well i've seen the word "interaction" used instead of force, i think
20:49:03 <oerjan> presumably for this kind of reason
20:49:07 <Phantom_Hoover> Yes, that's a much better name.
20:51:40 <pikhq> FUCK YOUR UNPORTABLE USE OF sys/types.h.
20:52:00 <Phantom_Hoover> The sudden switch to lowercase there makes it look quite amusing.
20:52:04 <pikhq> "quad_t" is a BSD-ism, dammit. What you want is int64_t.
20:52:20 <elliott> oerjan: I'm just going to inline labels inside
20:52:22 <Phantom_Hoover> Like you were yelling at someone and suddenly composed yourself and said "sys slash types dot h".
20:52:27 <elliott> since the actual backends will have no problem with it... I think
20:55:30 <Vorpal> is travelling salesman NP-complete or NP-hard?
20:55:34 <Vorpal> oerjan, ^
20:56:04 <Vorpal> (of course if it is the former it is also the latter
20:59:18 * pikhq beats head against wall
20:59:28 <Vorpal> pikhq, hm?
20:59:34 <oerjan> Vorpal: the decision version is NP-complete
20:59:37 <pikhq> It *literally* has a part that requires inb and outb.
20:59:41 <Vorpal> oh, of course
20:59:49 <Vorpal> pikhq, what part? hwclock?
20:59:53 <pikhq> Yup.
20:59:56 <pikhq> I was unaware that was permitted outside of ring 0.
21:00:08 <pikhq> Guess where that comes from?
21:00:10 <pikhq> glibc!
21:00:10 <Vorpal> pikhq, uh you need CAP_SOMETHING for it
21:00:24 <pikhq> Because Linux stopped exporting those, because THAT IS FUCKING STUPID.
21:00:32 <Vorpal> CAP_SYS_RAWIO
21:00:42 <pikhq> FUCKING. STUPID.
21:00:43 <Sgeo> Which sort of parser is easier for a newbie at writing parsers to write?
21:00:44 <Vorpal> pikhq, so you can't do it then?
21:00:55 <Vorpal> pikhq, how does glibc do it then
21:00:56 <pikhq> I refuse to.
21:01:06 <pikhq> glibc has embedded ASM.
21:01:08 <Vorpal> pikhq, anyway doesn't hwclock use /dev/rtc these days?
21:01:10 <pikhq> In the header.
21:01:15 <coppro> pikhq: you can't copy glibc anyways
21:01:45 <elliott> thank you painfully-obvious license laeyer
21:01:46 <elliott> lawyer
21:02:07 <pikhq> coppro: Why not? LGPL 2.1+ is entirely compatible with LGPL 2.1+.
21:02:24 <pikhq> However, I refuse to because GOD NO.
21:02:37 <pikhq> This is not something that belongs in a libc. At all.
21:03:52 <coppro> pikhq: oh, I didn't realize glibc was still on 2.1
21:03:56 <Sgeo> Top down parsers can't accomodate all context-free grammars, iiuc
21:04:07 <Sgeo> I have no idea if my language even is context-free :/
21:04:27 -!- aloril has quit (Ping timeout: 250 seconds).
21:04:51 <Sgeo> My lambda syntax is flawed, there's no way to specify return type
21:05:14 <Sgeo> Well, could always type-infer
21:05:41 <Vorpal> Sgeo, so change the language then
21:05:45 <oerjan> if you have enough backtracking, i'm pretty sure top down can do anything CF... but perhaps not always efficiently
21:06:01 <pikhq> Oh, yeah, and the header was once asm/io.h, from Linux
21:06:08 * Phantom_Hoover notes that Sgeo is talking about grammars, mentally blocks him.
21:06:14 <Vorpal> pikhq, so copy it from there?
21:06:22 <Vorpal> pikhq, how does it do it btw?
21:06:50 <Sgeo> I guess context-free would make my life much easier?
21:07:02 <Vorpal> of course
21:07:25 <oerjan> context-free unambiguous LR(1)
21:07:33 <Vorpal> oerjan, no LL(1)
21:07:36 <pikhq> So, hwclock is the *one thing* stopping me from having util-linux building.
21:07:44 <Sgeo> I don't know what LL(1) means
21:07:45 <oerjan> well yeah that's even easier
21:08:03 <oerjan> Sgeo: LL(1) are essentially languages for which top-down is ridiculously easy
21:08:15 <Sgeo> Hey, I'm not committed to top-down
21:08:15 <Vorpal> pikhq, well then why use hwclock. Aren't modern kernels able to do the job themselves?
21:08:30 <oerjan> also, s/top-down/recursive descent/ iirc
21:08:30 <Vorpal> Sgeo, python is LL(1)
21:08:52 <Vorpal> olsner, what about LL(0)
21:08:54 <Vorpal> err
21:08:55 <Vorpal> oerjan, ^
21:09:00 <oerjan> Sgeo: well everything other than recursive descent is relatively unfeasible to write by _hand_
21:09:05 <oerjan> iirc
21:09:10 <Phantom_Hoover> augur, there?
21:09:14 <Sgeo> I do want the syntax to be vaguey LSL-like
21:09:22 <oerjan> you need a parser generator
21:09:24 <Vorpal> Sgeo, WHY
21:09:28 <pikhq> Hmm. Well, I can do a *nasty* hack to get it to build.
21:09:33 <oerjan> for L(AL)R(1) stuff
21:09:38 <Vorpal> pikhq, what is that hack
21:09:48 <pikhq> I can replace its "#include <asm/io.h>" with #undef __i386__
21:09:54 <Sgeo> Vorpal, to make things easy for others who I will convince to use my language
21:10:21 <Sgeo> Are there good parser generators that output parsers in Javascript?
21:10:23 <pikhq> (asm/io.h is conditionally included if the system doesn't have sys/io.h. Incidentally, asm/io.h should not exist anywhere, as it's not a header the kernel *intends* to export.)
21:10:34 <monqy> what if the syntax ends up making the language harder for everyone
21:10:49 <monqy> it's not like it's hard to pick up a new syntax
21:10:51 <oerjan> Sgeo: unless your syntax is completely insane, it can probably at least be refactored to be mostly LR(1).
21:10:51 <pikhq> By doing this, hwclock will not be able to access the BIOS clock directly, and will have to function through alternate means.
21:10:55 <monqy> unless second life people are dumb
21:11:34 <Vorpal> pikhq, or you could just remove the code for the BIOS clock completely
21:11:43 <oerjan> Sgeo: the technical requirement for LL(1) is that which subrule to use for parsing a token always is determined by the first terminal token you see
21:11:44 <Sgeo> Considering that my language _will_ make race conditions more of a possibility than they are in LSL, maybe I should hope SL people aren't dumb
21:11:44 <elliott> oerjan: Humour for Haskell programmers: http://solog.co/47/10-scala-one-liners-to-impress-your-friends/
21:11:50 <elliott> 1
21:11:50 <elliott> (1 to 10) map { _ * 2 }
21:11:52 <elliott> WOOOOOOOOOOOOOOOOOOOOOOOOOOOOOW
21:11:59 <Vorpal> <monqy> unless second life people are dumb <-- spot on
21:12:24 <oerjan> elliott: iirc there was a haskell version posted (which showed the author obviously didn't know much haskell)
21:12:50 <elliott> Boring people should stop having blogs :P
21:12:57 <Deewiant> ( http://blog.fogus.me/2011/06/03/10-haskell-one-liners-to-impress-your-friends/ )
21:13:06 <monqy> map (* 2) [1 .. 10] -- alternatively, [1, 2 .. 10], right?
21:13:10 <elliott> oerjan: the author of the solog thing post or fogus?
21:13:13 <Phantom_Hoover> elliott, I like the way they're completely oblivious that their programs are half boilerplate.
21:13:27 <oerjan> Sgeo: as long as your grammar mainly has that property, it is easy to parse top-down/with recursive descent
21:13:50 <oerjan> elliott: ok so maybe it isn't the same author
21:14:05 <Phantom_Hoover> oerjan, you mean the one in /r/Haskell?
21:14:09 <monqy> ime it's easier to write compilers when you know what you're doing
21:14:10 <oerjan> yeah
21:14:15 <elliott> Deewiant: I wonder how long I could convince someone that you're a bot
21:14:15 <pikhq> Okay, then. I can hack util-linux into building with musl.
21:14:18 <Sgeo> oerjan, quick example?
21:14:25 <Phantom_Hoover> Wait, that is the one in /r/Haskell.
21:14:32 <Deewiant> elliott: fnord
21:14:40 <elliott> Indefinitely, then
21:14:41 <Vorpal> pikhq, remember wide string stuff
21:14:41 <augur> Phantom_Hoover: pong
21:14:52 <elliott> <Deewiant> ( See also: Deewiant human is not a bot. )
21:14:59 <elliott> <person> haha who added that factoid
21:15:03 <oerjan> Sgeo: well Pascal is sort of a star example of this. nearly every declaration starts with a keyword identifying what kind it is, e.g. Var X : Integer;
21:15:06 <Phantom_Hoover> augur, are there actually any linguistics questions on /r/AskScience.
21:15:14 <augur> Phantom_Hoover: occasionally!
21:15:16 <elliott> Phantom_Hoover: its not a real science so no :trollface:
21:15:31 <oerjan> it was designed to be easy to parse. as i think are all wirth languages.
21:15:35 <augur> Phantom_Hoover: why do you ask?
21:15:46 <pikhq> http://sprunge.us/TBhV
21:15:50 <Sgeo> monqy, how hard could it be once I have the AST? Just turn expressions into function calls and lambdas, then convert to CPS, then convert to bytecode
21:15:56 <Sgeo> "byte"code
21:16:02 <pikhq> Vorpal: Yes, I do still need to add that to musl.
21:16:05 <Phantom_Hoover> augur, dunno, just saw you were a panellist.
21:16:07 <elliott> oerjan: very few languages are LL(1), you should note :P
21:16:13 <augur> Phantom_Hoover: anyone can be a panelist :P
21:16:14 <elliott> e.g. you can't have both "x = y" and "f(x)"
21:16:18 <elliott> because both start with an identifier
21:16:19 <Vorpal> pikhq, it is POSIX 2008 it seems yeah
21:16:25 <Phantom_Hoover> elliott, it's a real science, in the same way as anthropology is a 'science'.
21:16:34 <elliott> Phantom_Hoover: Or computer science.
21:16:36 <monqy> Sgeo: but do you know how to do those
21:16:38 <oerjan> Sgeo: C on the other hand is not LL(1)
21:16:38 <Phantom_Hoover> The interesting bits are mathematics AFAIK.
21:16:45 <elliott> Or physics.
21:16:47 <monqy> Sgeo: also do you know how to write a parser
21:16:48 <Sgeo> monqy, how hard could it be?
21:16:49 <augur> Phantom_Hoover: its even more real than that! we have an MEG machine and an MRI machine!
21:16:52 <elliott> Or biology.
21:16:52 <augur> SCIENCE! \o/
21:16:53 <myndzi> ¦
21:16:53 <myndzi> ´¸¨
21:16:53 <oerjan> elliott: well you can fix that example with a little refactoring
21:16:57 <Phantom_Hoover> elliott, study of actual human languages is a science-as-in-physics-science.
21:16:58 <augur> thank you myndzi
21:17:00 <augur> ive missed you
21:17:01 <Sgeo> monqy, not the foggiest idea (ok, a somewhat foggy idea)
21:17:04 <elliott> `addquote <monqy> Sgeo: also do you know how to write a parser <Sgeo> monqy, how hard could it be?
21:17:05 <HackEgo> ​443) <monqy> Sgeo: also do you know how to write a parser <Sgeo> monqy, how hard could it be?
21:17:20 <Sgeo> What?
21:17:21 <augur> Phantom_Hoover: i wouldnt go so far as to say that
21:17:31 <oerjan> elliott: x = y and f(x) are both ok as long as they don't parse to different nonterminal tokens
21:17:33 <Sgeo> "How hard could it be" should NOT go with "parser"
21:17:35 <monqy> parsers are actually easy if you know what you're doing
21:17:35 <pikhq> Build with --disable-shared --disable-libmount --disable-schedutils, and comment out the HAVE_WIDECHAR.
21:17:36 <augur> i think its more akin to logic and some aspects of computer science
21:17:38 <Sgeo> It was meant to go with the other stuff
21:17:43 <pikhq> in config.h
21:17:46 <elliott> oerjan: right
21:17:49 <Vorpal> pikhq, "--- util-linux-2.19.1/text-utils/#display.c#1969-12-31 17:00:00.000000000 -0700"
21:17:53 <Vorpal> pikhq, patch fail
21:18:02 <Phantom_Hoover> augur, yes, but is some amount of linguistics attempting to model human communication?
21:18:11 <Sgeo> This is what I saw:
21:18:14 <Sgeo> <Sgeo> monqy, how hard could it be?
21:18:14 <Sgeo> <monqy> Sgeo: also do you know how to write a parser
21:18:21 -!- aloril has joined.
21:18:30 <augur> Phantom_Hoover: maybe a handful of people
21:18:35 <Phantom_Hoover> Sgeo, it's what I saw too.
21:18:37 <pikhq> Vorpal: Argh, fuck emacs.
21:18:41 <elliott> I saw it the way I added it.
21:18:47 <monqy> the "how hard could it be" was directed towards program transformation
21:18:48 <elliott> Complaints will be ignored; humour comes above accuracy.
21:18:57 <elliott> This is not an invitation to add me saying "lol im a fag".
21:19:24 * elliott awaits the inevitable
21:19:27 <Phantom_Hoover> `addquote <elliott> This is [...] me saying "lol im a fag".
21:19:28 <HackEgo> ​444) <elliott> This is [...] me saying "lol im a fag".
21:19:34 <elliott> `delquote ​444
21:19:35 <HackEgo> No output.
21:19:38 <monqy> program transformation is a lot more interesting than parsing, at least
21:19:39 <elliott> Oh the power I wield.
21:19:41 <Phantom_Hoover> `addquote <elliott> This is [...] me saying "lol im a fag".
21:19:42 <HackEgo> ​445) <elliott> This is [...] me saying "lol im a fag".
21:19:49 <Phantom_Hoover> Yeah, I meant to fix that error.
21:19:55 <monqy> `quote 444
21:19:56 <HackEgo> ​444) <elliott> This is [...] me saying "lol im a fag".
21:19:56 <elliott> ugh delquote is still broken
21:20:04 <elliott> monqy: sgeo should learn compiler-writing from sylladex
21:20:07 <Vorpal> pikhq, what is schedutils?
21:20:12 <Vorpal> and libmount?
21:20:21 <Sgeo> sylladex?
21:20:34 * Phantom_Hoover awaits elliott's inevitable facepalm.
21:20:53 <pikhq> Vorpal: schedutils lets you change the realtime priority of processes; relies on some POSIX 2008 features that musl doesn't support.
21:20:53 <Sgeo> I just Googled, first hits were what I thought you weren't referring to
21:21:05 <Vorpal> pikhq, ah
21:21:09 <elliott> monqy: its got everything, full parser, optimiser, stack-based VM intermediate language, assembly backend...
21:21:15 <elliott> incremental compilation...
21:21:16 <Vorpal> pikhq, and libmount?
21:21:17 <pikhq> Vorpal: libmount is an experimental mounting library that seems buggy that's unnecessary, that I didn't want to fuck with.
21:21:22 <Vorpal> ah
21:21:25 <monqy> elliott: all for SyL?
21:21:31 <elliott> monqy: yes.
21:21:41 <pikhq> So, this gets you a *pretty much* complete util-linux.
21:21:50 <monqy> a serious language for serious business
21:21:58 <elliott> monqy: you don't KNOW how sleek it will be to compile the gtk+ ffi example.
21:21:58 <Vorpal> pikhq, *oh* is it schedtool?
21:22:00 <Vorpal> if so I use it
21:22:01 <pikhq> Yes.
21:22:02 <elliott> you just don't know.
21:22:10 <Sgeo> I hope type inference isn't difficult
21:22:19 <elliott> `addquote <Sgeo> I hope type inference isn't difficult
21:22:20 <pikhq> There's nothing *wrong* with it at all, it just uses some interfaces musl doesn't have yet.
21:22:20 <HackEgo> ​446) <Sgeo> I hope type inference isn't difficult
21:22:32 <Vorpal> pikhq, I run hdapsd with real time privs it seems
21:22:38 <Phantom_Hoover> So wait, what's wrong with delquote?
21:22:39 <Vorpal> well the init script does
21:22:45 <elliott> Phantom_Hoover: its broken in some way that i dont know how
21:22:49 <Vorpal> pikhq, which is very sensible
21:22:54 <pikhq> Whereas just about everything I patched in util-linux is *actual fucking bugs*.
21:22:59 <pikhq> That musl happened to trigger.
21:23:10 <Vorpal> pikhq, send those patches upstream
21:23:19 <pikhq> I intend to.
21:23:22 <monqy> one time I learned how to do type inference
21:23:25 <monqy> it was pretty cool
21:23:27 <monqy> 100% forgotten
21:24:20 <Sgeo> Look at lifetime of variable. If it has two incompatible types, fail typechecking. If type of variable is omitted at one location, no big deal.
21:24:24 <Sgeo> Sounds easy
21:24:35 <Sgeo> It's probably more complicated than that.
21:24:52 <Vorpal> <elliott> Phantom_Hoover: its broken in some way that i dont know how <-- do a binary search over the revisions to find it?
21:24:55 <elliott> i was going to say that one day Sgeo will look back on these logs and ... but then i realised
21:24:58 <elliott> he probably won't
21:25:02 <monqy> hehehehehheheheheheh
21:25:21 <Phantom_Hoover> Vorpal, I invite you to fix it.
21:25:32 <Vorpal> Phantom_Hoover, why me
21:25:43 <Phantom_Hoover> You seem like a man who knows what he's doing.
21:25:48 <elliott> Vorpal: if you fix it i'll give you minecraft.
21:25:54 <Vorpal> ...
21:25:55 <Vorpal> `run url $(type delquote)
21:25:55 <elliott> YOUR DECISION
21:25:56 <HackEgo> ​http://codu.org/projects/hackbot/fshg/index.cgi/raw-file/tip/delquote
21:26:26 <Vorpal> error: delquote@6875624d657a: not found in manifest
21:26:28 <Vorpal> well fu
21:26:31 <elliott> clap
21:26:32 <elliott> clap
21:26:32 <elliott> clap
21:26:34 <elliott> clap
21:26:36 <Vorpal> elliott, what
21:26:41 <elliott> `run ls delquote
21:26:42 <HackEgo> No output.
21:26:42 <elliott> `run ls bin/delquote
21:26:43 <HackEgo> ​bin/delquote
21:26:50 <Vorpal> elliott, I did use type dammit
21:26:50 <oerjan> <Sgeo> I hope type inference isn't difficult <-- ok now you are in _way_ over your head
21:26:54 <Vorpal> `run type delquote
21:26:55 <HackEgo> ​delquote is /tmp/hackenv.30916/bin/delquote
21:26:58 <Vorpal> oh right
21:26:59 <Vorpal> damn
21:27:06 <elliott> oerjan: sadly, I think he was way in over his head as soon as he went from lexing to parsing.
21:27:22 <monqy> sgeo did lexing?
21:27:39 <elliott> monqy: he... ostensibly knows what lexing is.
21:27:42 <elliott> probably.
21:27:50 <monqy> I'm so proud
21:27:57 <Vorpal> lexing isn't really hard
21:28:01 <Vorpal> parsing can be
21:28:08 <oerjan> elliott: well i was deducing from the fact he finds parsing tricky
21:28:11 <monqy> Sgeo: as I said earlier, writing a compiler is easier when you know what you're doing
21:28:33 <oerjan> which means type inference will be completely impenetrable
21:28:56 <Vorpal> hm, how *does* type inference work?
21:29:07 <pikhq> Hmm. Lemme just check that it builds with glibc still. *Should*, but hey.
21:29:09 <Vorpal> I have no idea, but I bet I could learn
21:29:28 <elliott> Vorpal: depends if you mean like C[hash] style or full Hindley-Milner or even beyond that
21:29:45 <elliott> the former is ridiculously simple.
21:29:50 <Vorpal> elliott, lets start with the simplest one and work upwards from there :P
21:30:04 <elliott> the middle isn't simple, but it's not hard to get a hang of.
21:30:07 <elliott> the latter gets a bit gnarly.
21:30:10 <pikhq> Nope, it doesn't.
21:30:16 <Vorpal> elliott, ah, how does the middle one work then.
21:30:16 <elliott> Vorpal: well the first one is like a totally different breed to the latter
21:30:19 <elliott> all you have to do is know the types of literals
21:30:20 <pikhq> bits/user.h DNE...
21:30:21 <elliott> and like
21:30:23 <elliott> what types functions return
21:30:24 <Vorpal> elliott, ah right
21:30:24 <elliott> and you're done
21:30:27 <Vorpal> yep
21:30:29 <Vorpal> makes sense
21:30:36 <Vorpal> elliott, since functions in C# can't return var
21:30:42 <elliott> the middle one works like ... http://en.wikipedia.org/wiki/Type_inference#Hindley.E2.80.93Milner_type_inference_algorithm
21:30:50 <elliott> to be perfectly honest, I couldn't describe H-M without having the description in front of me
21:31:04 <Vorpal> elliott, the last one I don't even know what it is
21:31:07 <elliott> Vorpal: haskell
21:31:11 <monqy> I think I learned H-M when I learened type inference
21:31:18 <Vorpal> elliott, doesn't haskell use H-M?
21:31:21 <elliott> haskell with one or two extensions gives you the absolute most you can fully infer, basically
21:31:25 <elliott> Vorpal: it uses H-M with extensions
21:31:31 <Vorpal> elliott, what extensions?
21:31:37 <elliott> typeclasses f.e.
21:31:48 <elliott> but "fancy" haskell stuff isn't fully inferrable.
21:31:55 <elliott> so just like haskell ninetyeight is.
21:31:57 <elliott> plus a bit extra.
21:32:05 <Vorpal> hm
21:32:34 <oerjan> Vorpal: for ghc, heaps of them. basically if someone invents a new type idea that is mostly inferable, it'll probably end up in ghc :P
21:32:37 <pikhq> Okay, there is no good place for pulling __WORDSIZE.
21:32:46 <elliott> oerjan: and even if it isn't
21:32:48 <Vorpal> oerjan, hah
21:33:34 <elliott> oerjan i was reading that talk page and you had a comment so i clicked on your contribs and
21:33:38 <elliott> do you have [[7 (number)]] on your watchlist
21:33:39 <elliott> and why
21:33:44 <oerjan> wat
21:34:00 <oerjan> no, lemme check why i edited that
21:34:06 <elliott> 10:22, 20 January 2011 (diff | hist) 7 (number) ‎ (Undid revision 408789001 by 84.252.249.235 (talk) (1+1 is not a composite number))
21:34:07 <elliott> 05:46, 12 January 2011 (diff | hist) m 7 (number) ‎ (fix spelling)
21:34:11 <elliott> TWICE, oerjan, TWICE :D
21:34:14 <elliott> is it your synchronicity number
21:34:17 <oerjan> elliott: i _do_ however have Type Inference on my watchlist
21:34:31 <elliott> i guessed, and probably [[esoteric programming language]] too
21:34:37 <elliott> you've said you watch [[look-and-say sequence]] in here before
21:34:37 <elliott> wow
21:34:43 <elliott> why do i know so much about what wp pages you watchlist
21:34:49 <oerjan> elliott: oh. i have a policy of following an article's changes for about a week after i've edited it
21:34:50 * elliott crisis of introspection
21:35:19 <oerjan> so since those are 8 days apart, it falls under that
21:35:37 <oerjan> elliott: correct on [[esoteric programming language]] :P
21:38:14 <Phantom_Hoover> OK IWC's new poll is hurting my brain.
21:38:25 <Phantom_Hoover> I really really hope DMM isn't going to go all pretentious on it.
21:38:26 <oerjan> Phantom_Hoover: heh
21:39:17 <oklopol> mji
21:39:31 <pikhq> Okay, best way of faking __WORDSIZE (which, realistically, is meaningless) is CHAR_BIT*sizeof(void*)...
21:39:40 <oerjan> Phantom_Hoover: last time DMM removed the old poll without putting up a new one. someone joked about it by making up options on the forum. i recognize several of them in the newest one.
21:40:28 <elliott> random mouse-waving and clicking picks baarle-nassau for me
21:40:36 <oerjan> so i think this is one is based on forum ideas
21:41:06 <oerjan> elliott: i picked those spheres as they were the only thing i hadn't heard about before
21:44:37 <oerjan> and there was an interesting wikipedia article on them
21:45:06 <oerjan> baarle-nassau is a good choice though :P
21:46:16 <elliott> what is the thing with baarle-nassau
21:46:19 <elliott> is it because it has complicated borders
21:46:21 <elliott> lol pediawiki
21:46:22 <oerjan> yes
21:46:24 <elliott> ok right border
21:47:33 <pikhq> Seems the patch is *much* shorter on a git checkout.
21:47:58 <elliott> i come from land
21:47:59 <elliott> ojias
21:48:27 <olsner> pikhq: the patch? is shorter?
21:48:37 <elliott> the patch? is shorter?
21:48:40 <elliott> ojias
21:48:41 <elliott> the patch? is shorter?
21:48:50 <oerjan> @let shm = unwords . sequence [id, ("shm"++).dropWhile(`notElem`"aeiou")] in shm "elliott"
21:48:51 <lambdabot> Parse error: in
21:48:54 <oerjan> er
21:48:59 <oerjan> > let shm = unwords . sequence [id, ("shm"++).dropWhile(`notElem`"aeiou")] in shm "elliott"
21:49:01 <lambdabot> "elliott shmelliott"
21:49:07 <elliott> ooh ooh ooh
21:49:21 <oerjan> @let shm = unwords . sequence [id, ("shm"++).dropWhile(`notElem`"aeiou")]
21:49:22 <lambdabot> Defined.
21:49:31 <elliott> > let thanks = ("Th"++) . dropWhile (`notElem` "aeiou") in thanks "elliott"
21:49:32 <lambdabot> "Thelliott"
21:49:45 <oerjan> wat
21:49:52 <oerjan> > shm "thanks"
21:49:54 <lambdabot> "thanks shmanks"
21:49:59 <elliott> > let thanks xs = (("Thanks, " ++ xs ++ ". Th") ++) . dropWhile (`notElem` "aeiou") in thanks "elliott"
21:50:00 <lambdabot> Overlapping instances for GHC.Show.Show
21:50:00 <lambdabot> ([GHC....
21:50:09 <elliott> > let thanks xs = (("Thanks, " ++ xs ++ ". Th") ++) . dropWhile (`notElem` "aeiou") $ xs in thanks "elliott"
21:50:11 <lambdabot> "Thanks, elliott. Thelliott"
21:50:16 <elliott> :t toLowerCase
21:50:17 <lambdabot> Not in scope: `toLowerCase'
21:50:20 <elliott> ?hoogle lower
21:50:20 <lambdabot> Text.Parsec.Char lower :: Stream s m Char => ParsecT s u m Char
21:50:20 <lambdabot> Text.ParserCombinators.Parsec.Char lower :: Stream s m Char => ParsecT s u m Char
21:50:20 <lambdabot> Data.Char LowercaseLetter :: GeneralCategory
21:50:24 <elliott> ?hoogle lowercase
21:50:25 <lambdabot> Data.Char LowercaseLetter :: GeneralCategory
21:50:26 <elliott> ?hoogle downcase
21:50:26 <lambdabot> No results found
21:50:28 <elliott> :(
21:50:28 <oerjan> :t toLower
21:50:29 <lambdabot> Char -> Char
21:50:39 <elliott> > let thanks xs = (("Thanks, " ++ xs ++ ". Th") ++) . dropWhile ((`notElem` "aeiou") . toLower) $ xs in thanks "ants"
21:50:40 <pikhq> olsner: The patch to get util-linux to build with musl.
21:50:40 <lambdabot> "Thanks, ants. Thants"
21:50:46 <Deewiant> > shm "wyrd"
21:50:47 <lambdabot> "wyrd shm"
21:50:48 <elliott> > let thanks xs = (++ ".") . (("Thanks, " ++ xs ++ ". Th") ++) . dropWhile ((`notElem` "aeiou") . toLower) $ xs in thanks "ants"
21:50:50 <lambdabot> "Thanks, ants. Thants."
21:50:51 <elliott> > let thanks xs = (++ ".") . (("Thanks, " ++ xs ++ ". Th") ++) . dropWhile ((`notElem` "aeiou") . toLower) $ xs in thanks "Elliott"
21:50:53 <lambdabot> "Thanks, Elliott. ThElliott."
21:50:55 <elliott> :t isVowel
21:50:56 <lambdabot> Not in scope: `isVowel'
21:50:58 <elliott> darn
21:51:02 <elliott> was hoping there'd be a fancy Unicode thing for it
21:51:11 <elliott> ?let thanks xs = (++ ".") . (("Thanks, " ++ xs ++ ". Th") ++) . dropWhile ((`notElem` "aeiou") . toLower) $ xs
21:51:12 <lambdabot> Defined.
21:51:12 <Deewiant> There's no fancy Unicode stuff in base
21:51:14 <elliott> > thanks "lambdabot"
21:51:15 <lambdabot> "Thanks, lambdabot. Thambdabot."
21:51:22 <elliott> ?let thanks xs = text . (++ ".") . (("Thanks, " ++ xs ++ ". Th") ++) . dropWhile ((`notElem` "aeiou") . toLower) $ xs
21:51:22 <lambdabot> <local>:6:12:
21:51:23 <lambdabot> Couldn't match expected type `[Char]' against inferred ty...
21:51:26 <elliott> ?unlet thanks
21:51:26 <lambdabot> TemplateHaskell is not enabled
21:51:27 <elliott> ugh
21:51:32 <elliott> how do you redefine
21:51:53 <elliott> ?undef
21:51:56 <elliott> ?undefine
21:52:00 <elliott> ?let thanks xs = text . (++ ".") . (("Thanks, " ++ xs ++ ". Th") ++) . dropWhile ((`notElem` "aeiou") . toLower) $ xs
21:52:00 <lambdabot> Defined.
21:52:04 <elliott> > thanks "Deewiant"
21:52:06 <lambdabot> Thanks, Deewiant. Theewiant.
21:52:09 <elliott> excellent
21:52:21 <Deewiant> > thanks "wyrd"
21:52:23 <lambdabot> Thanks, wyrd. Th.
21:52:44 <elliott> X-D
21:52:51 <elliott> ?undefine
21:52:54 <elliott> :t any
21:52:55 <lambdabot> forall a. (a -> Bool) -> [a] -> Bool
21:53:06 <monqy> > thanks "QUEEN"
21:53:07 <lambdabot> Not in scope: `thanks'
21:53:10 <oerjan> <elliott> was hoping there'd be a fancy Unicode thing for it <-- you realize languages don't agree on which letters are vowels, right? :P
21:53:15 <elliott> ?let thanks xs = if any ((`notElem` "aeiou") . toLower) then text . (++ ".") . (("Thanks, " ++ xs ++ ". Th") ++) . dropWhile ((`notElem` "aeiou") . toLower) $ xs else text "What are you, Welsh?"
21:53:16 <lambdabot> <local>:1:15:
21:53:16 <lambdabot> Couldn't match expected type `Bool'
21:53:16 <lambdabot> against i...
21:53:21 <elliott> ?let thanks xs = if any ((`notElem` "aeiou") . toLower) xs then text . (++ ".") . (("Thanks, " ++ xs ++ ". Th") ++) . dropWhile ((`notElem` "aeiou") . toLower) $ xs else text "What are you, Welsh?"
21:53:22 <lambdabot> Defined.
21:53:25 <elliott> > thanks "wyrd"
21:53:26 <lambdabot> Thanks, wyrd. Th.
21:53:29 <elliott> o_O
21:53:38 <elliott> ???
21:53:41 <monqy> > thanks "QUEEN"
21:53:42 <lambdabot> Thanks, QUEEN. ThUEEN.
21:53:45 <Deewiant> > 'w' `notElem` "aeiou"
21:53:46 <lambdabot> True
21:53:49 <elliott> oh
21:53:55 <elliott> ?undefine
21:54:00 <elliott> ?let thanks xs = if any ((`elem` "aeiou") . toLower) xs then text . (++ ".") . (("Thanks, " ++ xs ++ ". Th") ++) . dropWhile ((`notElem` "aeiou") . toLower) $ xs else text "What are you, Welsh?"
21:54:00 <lambdabot> Defined.
21:54:02 <elliott> > thanks "wyrd"
21:54:03 <lambdabot> What are you, Welsh?
21:54:07 <elliott> > thanks "Deewiant"
21:54:08 <lambdabot> Thanks, Deewiant. Theewiant.
21:54:13 <elliott> PERFECT.
21:54:39 <olsner> > thanks "cymru"
21:54:40 <lambdabot> Thanks, cymru. Thu.
21:54:51 <elliott> > thanks "antidisestablishmentarianism"
21:54:53 <lambdabot> Thanks, antidisestablishmentarianism. Thantidisestablishmentarianism.
21:54:53 <olsner> haha, missed that one :/
21:54:58 <elliott> olsner: nothing wrong with Thu
21:55:04 <elliott> > thanks "Tchaikovsky"
21:55:05 <lambdabot> Thanks, Tchaikovsky. Thaikovsky.
21:55:07 <elliott> good
21:55:10 <monqy> > thanks "why"
21:55:11 <Deewiant> > thanks "thanks"
21:55:11 <lambdabot> What are you, Welsh?
21:55:13 <lambdabot> Thanks, thanks. Thanks.
21:55:29 <elliott> does anyone actually realise what this is from :P
21:55:32 <elliott> > thanks "thunks"
21:55:34 <lambdabot> Thanks, thunks. Thunks.
21:55:36 <oerjan> NO
21:55:39 <olsner> > fix thanks
21:55:40 <lambdabot> Couldn't match expected type `[GHC.Types.Char]'
21:55:40 <lambdabot> against inferred ty...
21:55:41 <elliott> > thanks "sknaht"
21:55:43 <lambdabot> Thanks, sknaht. Thaht.
21:55:54 <elliott> oerjan: http://www.youtube.com/watch?v=9jtU9BbReQk
21:56:00 <elliott> (forty seconds)
21:56:19 <olsner> oh, it uses weird shenanigans to print text
21:56:37 <olsner> can you get a string from that somehow, so that it works with fix?
21:56:40 <Deewiant> > iterate (show . thanks) "thanks"
21:56:41 <lambdabot> ["thanks","Thanks, thanks. Thanks.","Thanks, Thanks, thanks. Thanks.. Thank...
21:56:48 <elliott> > let thanks' xs = (++ ".") . (("Thanks, " ++ xs ++ ". Th") ++) . dropWhile ((`notElem` "aeiou") . toLower) $ xs in fix thanks'
21:56:50 <lambdabot> "Thanks, Thanks, Thanks, Thanks, Thanks, Thanks, Thanks, Thanks, Thanks, Th...
21:57:00 <elliott> > thanks "Kant"
21:57:02 <lambdabot> Thanks, Kant. Thant.
21:57:14 <elliott> > thanks "smorgasbord"
21:57:16 <lambdabot> Thanks, smorgasbord. Thorgasbord.
21:57:20 <elliott> thorgasbord
21:57:34 <Vorpal> elliott, presumably quite electric?
21:57:41 <elliott> > thanks "Knuth"
21:57:42 <lambdabot> Thanks, Knuth. Thuth.
21:57:50 <elliott> > thanks "William Blake"
21:57:52 <lambdabot> Thanks, William Blake. Thilliam Blake.
21:58:05 <olsner> > thanks "västkustskt"
21:58:06 <lambdabot> Thanks, v
21:58:07 <Vorpal> > thanks "lambdabot"
21:58:08 <lambdabot> Thanks, lambdabot. Thambdabot.
21:58:10 <elliott> > thanks "Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch"
21:58:12 <lambdabot> Thanks, Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch. Thanfai...
21:58:15 <elliott> :D
21:58:31 <Vorpal> elliott, your definition fails as olsner showed
21:58:42 <elliott> Vorpal: give me a perfect vowel function
21:58:46 <elliott> i suspect lambdabot fails at encoding itself
21:58:47 <elliott> or text does
21:58:50 <elliott> so i could not fix it anyway
21:58:54 <elliott> > thanks "fucking"
21:58:56 <lambdabot> Thanks, fucking. Thucking.
21:59:02 <olsner> I think both/all fail at encoding
21:59:09 <elliott> > thanks "oobleck"
21:59:11 <lambdabot> Thanks, oobleck. Thoobleck.
21:59:12 <olsner> I mean that's how it usually goes
21:59:13 <elliott> heheehehehehehe
21:59:24 <Vorpal> elliott, perfect vowel can't be done. y is not a vowel in English is it?
21:59:25 <elliott> > thanks "Istanbul"
21:59:27 <lambdabot> Thanks, Istanbul. ThIstanbul.
21:59:27 <Vorpal> it is in Swedish
21:59:30 <elliott> Vorpal: sometimes it is :P
21:59:32 <elliott> > thanks "istanbul"
21:59:33 <lambdabot> Thanks, istanbul. Thistanbul.
21:59:40 <elliott> > thanks "Mercury"
21:59:41 <lambdabot> Thanks, Mercury. Thercury.
22:00:37 <elliott> > thanks (fix show)
22:00:41 <lambdabot> mueval-core: Time limit exceeded
22:00:43 <elliott> aww
22:00:46 <Phantom_Hoover> > thanks ants
22:00:47 <lambdabot> Not in scope: `ants'
22:00:51 <elliott> > thanks "mueval-core: Time limit exceeded"
22:00:52 <lambdabot> Thanks, mueval-core: Time limit exceeded. Thueval-core: Time limit exceeded.
22:00:55 <Phantom_Hoover> > thanks "ants"
22:00:56 <lambdabot> Thanks, ants. Thants.
22:01:04 <Phantom_Hoover> > thanks "Hanks"
22:01:05 <lambdabot> Thanks, Hanks. Thanks.
22:01:07 <Vorpal> :t fix
22:01:08 <lambdabot> forall a. (a -> a) -> a
22:01:09 <olsner> Thueval Core
22:01:13 <Vorpal> what is fix?
22:01:19 <elliott> seriously?
22:01:32 <Vorpal> hm
22:01:36 <Phantom_Hoover> That's not even Vorpal.
22:01:41 <Phantom_Hoover> That's just plain stupidity.
22:01:46 <Vorpal> I'm tried
22:01:54 <elliott> i'm tried
22:02:06 <monqy> http://en.wikipedia.org/wiki/Fixed_point_combinator
22:02:10 <Phantom_Hoover> `addquote <Vorpal> I'm tried
22:02:11 <Vorpal> oh right
22:02:11 <HackEgo> ​447) <Vorpal> I'm tried
22:02:17 <Vorpal> oops
22:02:19 <Phantom_Hoover> monqy, why'd you ruin the fun?
22:02:20 <Vorpal> Phantom_Hoover, tired*
22:02:26 <monqy> I'm bad at not ruining the fun
22:02:29 <elliott> > thanks "but no thanks"
22:02:30 <lambdabot> Thanks, but no thanks. Thut no thanks.
22:02:39 <oerjan> > fix show
22:02:40 <lambdabot> "\"\\\"\\\\\\\"\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"\\\\\\\\\\\\...
22:02:45 <elliott> > thanks "archaeopteryx"
22:02:47 <lambdabot> Thanks, archaeopteryx. Tharchaeopteryx.
22:02:50 <elliott> Tharchaeopteryx
22:02:58 <Phantom_Hoover> Vorpal, yes, but I'm trying to get you to fix delquote.
22:03:03 <Phantom_Hoover> Through MANIPULATION.
22:03:06 <Vorpal> Phantom_Hoover, meh
22:03:07 <elliott> just apply delquote to itself, infinite times
22:03:11 <elliott> sorry oerjan stole ur wind
22:03:13 <Vorpal> tail quotes
22:03:16 <elliott> > thanks "combine"
22:03:17 <Vorpal> `tail quotes
22:03:18 <lambdabot> Thanks, combine. Thombine.
22:03:18 <HackEgo> ​<zzo38> Fiddle. It makes a big difference, you know. \ <oklopol> but touchscreens should feel like poking a boob \ <oklopol> are there boobs you wack and squeeze around to move the mouse? [...] <oklopol> like those little nipples in laptop keyboards, but they'd be full-blown boobies \ [after a long string of Lymia getting
22:03:23 <elliott> > thanks "tapestry"
22:03:25 <lambdabot> Thanks, tapestry. Thapestry.
22:03:25 <Vorpal> `tail -n1 quotes
22:03:26 <elliott> > thanks "oligarchy"
22:03:26 <HackEgo> No output.
22:03:27 <lambdabot> Thanks, oligarchy. Tholigarchy.
22:03:31 <Vorpal> `run tail -n1 quotes
22:03:32 <HackEgo> ​<Vorpal> I'm tried
22:03:43 <Vorpal> `run wc -l quotes
22:03:43 <elliott> `addquote <Vorpal> `run tail -n1 quotes
22:03:44 <HackEgo> ​447 quotes
22:03:44 <HackEgo> ​448) <Vorpal> `run tail -n1 quotes
22:04:00 <Phantom_Hoover> `addquote <Vorpal> I CANNOT REMOVE A LINE FROM A FILE
22:04:01 <HackEgo> ​449) <Vorpal> I CANNOT REMOVE A LINE FROM A FILE
22:04:08 <Phantom_Hoover> `addquote <Vorpal> ALSO I SMELL FUNNY
22:04:08 <elliott> `addquote lets just leave all these in
22:04:09 <HackEgo> ​450) <Vorpal> ALSO I SMELL FUNNY
22:04:10 <HackEgo> ​450) lets just leave all these in
22:04:13 <elliott> `addquote lets just leave all these in
22:04:14 <HackEgo> ​451) lets just leave all these in
22:04:18 <elliott> `addquote someone in the future will be really confused
22:04:19 <HackEgo> ​459) someone in the future will be really confused
22:04:20 <Vorpal> `run head -n 446 quotes > t; mv t quotes
22:04:20 <Phantom_Hoover> `quote 450
22:04:21 <HackEgo> No output.
22:04:22 <HackEgo> ​450) <<<<<<< /tmp/hackenv.1231/quotes
22:04:24 <elliott> um
22:04:26 <Phantom_Hoover> `quote 450
22:04:26 <elliott> lol
22:04:27 <HackEgo> ​450) <Vorpal> `run tail -n1 quotes
22:04:30 <elliott> someone
22:04:32 <elliott> needs to do
22:04:33 <elliott> manual surgery
22:04:35 <elliott> on the file
22:04:38 <Phantom_Hoover> `quote 450
22:04:40 <HackEgo> ​450) <Vorpal> `run tail -n1 quotes
22:04:42 <Vorpal> up to you guys
22:04:47 <Vorpal> I'm going to bed.
22:04:51 <elliott> Vorpal: if you want the slander there forevr...
22:05:03 <Vorpal> `help
22:05:04 <HackEgo> Runs arbitrary code in GNU/Linux. Type "`<command>", or "`run <command>" for full shell commands. "`fetch <URL>" downloads files. Files saved to $PWD are persistent, and $PWD/bin is in $PATH. $PWD is a mercurial repository, "`revert <rev>" can be used to revert to a revision. See http://codu.org/projects/hackbot/fshg/
22:05:21 <Phantom_Hoover> `addquote <Vorpal> I kick puppies for sport!
22:05:22 <HackEgo> ​463) <Vorpal> I kick puppies for sport!
22:05:29 <Vorpal> `revert 389
22:05:31 <HackEgo> Done.
22:05:40 <elliott> oh he doesn't like that one
22:05:50 <Vorpal> elliott, I simply fixed it
22:05:51 <elliott> `addquote <Vorpal> I kick puppies for sport[AN EXCLAMATION MARK APPEARED HERE IN REALITY]
22:05:52 <HackEgo> ​447) <Vorpal> I kick puppies for sport[AN EXCLAMATION MARK APPEARED HERE IN REALITY]
22:05:55 <Vorpal> `revert 389
22:05:56 <HackEgo> Done.
22:05:58 <elliott> `addquote <Vorpal> I kick puppies for sport[AN EXCLAMATION MARK APPEARED HERE IN REALITY]
22:05:59 <HackEgo> ​447) <Vorpal> I kick puppies for sport[AN EXCLAMATION MARK APPEARED HERE IN REALITY]
22:06:19 <elliott> Vorpal: you didn't fix delquote though
22:06:26 <Vorpal> `addquote <elliott> Nice, fucking this corpse.
22:06:27 <HackEgo> ​448) <elliott> Nice, fucking this corpse.
22:06:38 <Vorpal> elliott, I can be nasty too
22:06:45 <Vorpal> :P
22:06:57 <Vorpal> now I'm closing the lid, will time out soon
22:06:59 <Vorpal> night →
22:07:07 <Phantom_Hoover> It's such a Vorpal thing to add.
22:07:51 <elliott> `addquote <Vorpal> You know what's better than three dead babies? I'll tell you what's better than three dead babies. The only thing, on this Earth, or not on this Earth, that could possibly be said to be dead babies, is as follows: Dead babies, i.e. two of them, are excellent, but there is one thing that is superior to them in every aspect, and that thing I am now going to detail to you. The only thing better than four dead babies is: about to b
22:07:52 <elliott> e revealed. I shall reveal it now. The only thing better than nine dead babies is four dead babies, but that is a lie, because there is only one thing better than three dead babies, and it is this:
22:07:52 <HackEgo> ​449) <Vorpal> You know what's better than three dead babies? I'll tell you what's better than three dead babies. The only thing, on this Earth, or not on this Earth, that could possibly be said to be dead babies, is as follows: Dead babies, i.e. two of them, are excellent, but there is one thing that is superior to them in
22:07:59 <elliott> Oh, it got cut off.
22:08:04 <elliott> I guess we will just have to leave it at that.
22:08:22 <Phantom_Hoover> `addquote <Vorpal> Also I kick puppies.
22:08:23 <HackEgo> ​450) <Vorpal> Also I kick puppies.
22:09:00 <elliott> `addquote <oerjan> im ban you for puppy kick
22:09:01 <HackEgo> ​451) <oerjan> im ban you for puppy kick
22:09:17 <elliott> `revert 390
22:09:18 <HackEgo> Done.
22:09:24 <elliott> `quote ​449
22:09:25 <HackEgo> No output.
22:09:27 <elliott> `quote ​44​448
22:09:28 <HackEgo> No output.
22:09:29 <elliott> `quote ​44​48
22:09:30 <HackEgo> No output.
22:09:32 <elliott> `quote ​44​8
22:09:33 <HackEgo> No output.
22:09:36 <elliott> wtf
22:09:37 <elliott> oh well
22:09:45 <monqy> `quote 447
22:09:46 <HackEgo> ​447) <Vorpal> I'm tried
22:09:56 <oerjan> elliott: YOU AM PLAY GODS
22:10:06 <elliott> oerjan: im ban you for puppy kick
22:10:15 <elliott> Nice, fucking this corpse.
22:10:37 * Phantom_Hoover → sleep.
22:11:10 -!- Phantom_Hoover has quit (Quit: Leaving).
22:12:03 -!- Vorpal has quit (Ping timeout: 268 seconds).
22:12:16 <olsner> ... you make me tried
22:12:49 <elliott> Nice, fucking this corpse.
22:13:04 <elliott> `addquote <olsner> ... you make me tried <elliott> Nice, fucking this corpse.
22:13:05 <HackEgo> ​448) <olsner> ... you make me tried <elliott> Nice, fucking this corpse.
22:16:52 -!- foocraft_ has joined.
22:16:53 -!- foocraft has quit (Ping timeout: 252 seconds).
22:22:27 <nooga> K :> L
22:23:10 <elliott> ionnonoinoinoino
22:23:15 <elliott> Nice, fucking this corpse.
22:24:34 <nooga> fucking nice corpse
22:24:35 -!- wareya has quit (Read error: Connection reset by peer).
22:25:43 -!- wareya has joined.
22:29:01 <oerjan> :t var
22:29:01 <lambdabot> forall a. String -> Sym a
22:29:16 <oerjan> huh
22:29:22 <oerjan> :t fun
22:29:23 <lambdabot> forall a. (SimpleReflect.FromExpr a) => String -> a
22:29:30 -!- sebbu has quit (Ping timeout: 260 seconds).
22:29:39 <oerjan> > var "hm..."
22:29:39 <lambdabot> hm...
22:29:57 <oerjan> > var $ repeat 'a'
22:29:58 <lambdabot> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa...
22:30:30 <oerjan> > var "a" + var "b"
22:30:31 <lambdabot> a+b
22:30:33 <oerjan> > var "a" + var "a"
22:30:34 <lambdabot> a+a
22:30:43 <oerjan> :t a
22:30:43 <lambdabot> Expr
22:30:45 -!- sebbu has joined.
22:30:45 -!- sebbu has quit (Changing host).
22:30:45 -!- sebbu has joined.
22:31:18 <oerjan> :t var "a" == a
22:31:18 <lambdabot> Couldn't match expected type `Sym a' against inferred type `Expr'
22:31:19 <lambdabot> In the second argument of `(==)', namely `a'
22:31:19 <lambdabot> In the expression: var "a" == a
22:31:31 <oerjan> wtf is Sym
22:31:34 <oerjan> @hoogle Sym
22:31:34 <lambdabot> Text.Read Symbol :: String -> Lexeme
22:31:35 <lambdabot> Text.Read.Lex Symbol :: String -> Lexeme
22:31:35 <lambdabot> Text.Parsec.Token symbol :: GenTokenParser s u m -> String -> ParsecT s u m String
22:31:42 <oerjan> @hoogle var
22:31:43 <lambdabot> Language.Haskell.TH VarE :: Name -> Exp
22:31:43 <lambdabot> Language.Haskell.TH.Syntax VarE :: Name -> Exp
22:31:43 <lambdabot> Language.Haskell.TH varE :: Name -> ExpQ
22:32:19 -!- elliott has quit (Ping timeout: 244 seconds).
22:32:52 <oerjan> @let var = "hm"
22:32:53 <lambdabot> Defined.
22:32:57 <oerjan> > var
22:32:57 <lambdabot> Ambiguous occurrence `var'
22:32:58 <lambdabot> It could refer to either `L.var', defined at <l...
22:33:06 <oerjan> dammit
22:33:39 <oerjan> Data.Number.Symbolic
22:33:55 <oerjan> (longer message in priv)
22:35:29 -!- pikhq_ has joined.
22:35:30 -!- pikhq has quit (Ping timeout: 258 seconds).
22:45:14 -!- MigoMipo has quit (Read error: Connection reset by peer).
22:54:46 <pikhq_> Mmmkay, patches pushed upstream.
22:56:49 <pikhq_> Which feels kinda weird, TBH.
23:05:13 -!- ralc has quit (Read error: Operation timed out).
23:16:45 -!- nooga has quit (Ping timeout: 260 seconds).
23:16:54 -!- ralc has joined.
23:22:08 <pikhq_> Yeah. Still feels bloody weird having patches upstream.
23:27:07 <coppro> lol
23:29:17 <pikhq_> Oh, bloody hell, there's more stuff breaking now.
23:29:23 <olsner> pushing it upstream, sounds like physical work is being done pushing those patches
23:29:57 <pikhq_> http://www.spinics.net/lists/util-linux-ng/msg04536.html This patch bork it.
23:31:14 <pikhq_> TTYDEF_SPEED is defined in ttydefaults.h, which is very much a BSD-ism.
23:31:19 <coppro> lol
23:31:25 <olsner> funny, in this message: http://www.spinics.net/lists/util-linux-ng/msg04557.html he's *Dr* Werner Fink
23:31:34 <olsner> recently acquired his doctorate?
23:33:07 <pikhq_> --disable-agetty and hope that is less stupid?
23:37:08 <olsner> now that you have patches in the upstream it's only a matter of time until you find some excessively stupid piece of code and find that it came from one of your patches
23:39:01 <pikhq_> Okay, so. Musl is missing wcsdup and wcstok.
23:39:38 <olsner> of course it is, why would you want to have those?
23:41:01 <pikhq_> XD
23:45:50 <olsner> ubuntu has an upgrade for an "Advanced version control system", apparently that refers to the 'subversion' package :(
23:48:01 <olsner> I think subversion is advanced in approximately as many ways as CVS or RCS is not retarded
23:58:41 * oerjan is wondering if there might be a way to define k in unlambda using ` s and c
←2011-06-07 2011-06-08 2011-06-09→ ↑2011 ↑all