< 1271462404 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :mwahaha < 1271462715 0 :tombom!unknown@unknown.invalid QUIT :Quit: Leaving < 1271463007 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Which is worse, T-Mobile, or AT&T < 1271463132 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :T-Mobile has not-so-good 3G coverage; AT&T hates its customers and blames them using its service for its extremely subpar performance. < 1271463133 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :AT&T. < 1271463195 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Looking at the maps < 1271463196 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :hey, it's not AT&T's fault it gets all the hoarders < 1271463210 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :I looked at AT&T map the other day, my area had 3G coverage < 1271463247 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :T-Mobile has "Fast Mobile Web" [as opposed to Very Fast Mobile Web, or Mobile Web] in most, but not all, of my area < 1271463373 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Well, let me tell you that as someone who doesn't have a 3G phone -- only EDGE -- I don't really miss it. < 1271463379 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Maybe if you wanted to watch YouTube a lot when nowhere near WiFi. < 1271463553 0 :Gracenotes!~person@wikipedia/Gracenotes JOIN :#esoteric < 1271463588 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Also, my dad wants me to hide this from my step-mother and her mother < 1271463601 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Meaning no nice free calls with Google Voice to/from them < 1271463616 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Among other annoyances < 1271464572 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Your family sounds nice and well-adjusted. :) < 1271464577 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :lol < 1271465888 0 :alise_!~alise@212.183.140.32 JOIN :#esoteric < 1271465947 0 :alise!unknown@unknown.invalid QUIT :Ping timeout: 258 seconds < 1271466212 0 :augur!unknown@unknown.invalid QUIT :Remote host closed the connection < 1271466278 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :holy shit < 1271466280 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :google redesigned < 1271466283 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :new logo < 1271466285 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :new interface < 1271466287 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :everything < 1271466365 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Nice joke. < 1271466370 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Joke? < 1271466372 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :It's no joke. < 1271466376 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Make sure you're on .com. < 1271466387 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :The logo /is/ redesigned, and the UI /is/ significantly different. < 1271466398 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Yup, still the normal Google. < 1271466408 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Got the text-fadein-thing of a few months ago and everything. < 1271466435 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Yes, but http://www.google.com/intl/en_ALL/images/srpr/logo1w.png is definitely new. < 1271466446 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :As is the redesigned sidebar on a search results page. < 1271466453 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Yeah, that's not what I'm seeing. < 1271466457 0 :augur!~augur@216-164-33-76.c3-0.slvr-ubr1.lnh-slvr.md.cable.rcn.com JOIN :#esoteric < 1271466465 0 :BeholdMyGlory!unknown@unknown.invalid QUIT :Remote host closed the connection < 1271466469 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Want some screenshots? < 1271466471 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :http://www.google.com/intl/en_ALL/images/logo.gif <-- This is what I get. < 1271466482 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Are you on google.com? Clear cache, mayhaps. < 1271466482 0 :FireFly!unknown@unknown.invalid QUIT :Quit: Leaving < 1271466483 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Sure. < 1271466490 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Yes, google.com < 1271466559 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Okay, uploading images now < 1271466635 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: http://imgur.com/5k9XF.png, http://imgur.com/ymPSq.png, http://imgur.com/FaxDX.png < 1271466680 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :It's an improvement, mind you; looks cleaner. But still, Google changing their logo? That's only happened onfce. < 1271466682 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :*once < 1271466683 0 :Asztal!unknown@unknown.invalid QUIT :Ping timeout: 276 seconds < 1271466698 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :alise_: Holy fudgsicles < 1271466729 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :My path to Google is less cached than yo-ou, my path to Google is less cached than yo-ou! < 1271466734 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Na na na na na, na na na na na!# < 1271466735 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :*! < 1271466840 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Katamari Damacy! < 1271466850 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :（塊魂！） < 1271466854 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Katamari Democracy. < 1271466885 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :塊住民？ < 1271466931 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :Naaaaaaaaaaa na na na na na naa naa na naa naa nana naaaaaaaa < 1271466947 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Erm, sorry. 塊民主主義. < 1271467022 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :"Katamari minshushugi" just sounds less awesome than "Katamari damashii". XD < 1271467070 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Not to mention a bizarre concept. < 1271467074 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :"Clump democracy"? < 1271467271 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric ::-D < 1271467307 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :"Naaaaaaaaaaaa na na na na na na katamari minshushugi...." < 1271467462 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :the political system you feel attached to < 1271467475 0 :fhoahf38771!~Gla@200-55-110-251.dsl.prima.net.ar JOIN :#esoteric < 1271467475 0 :fhoahf38771!unknown@unknown.invalid PART #esoteric :? < 1271467939 0 :jcp!~jw@bzflag/contributor/javawizard2539 JOIN :#esoteric < 1271468009 0 :MizardX!unknown@unknown.invalid QUIT :Ping timeout: 276 seconds < 1271468136 0 :MizardX!~MizardX@unaffiliated/mizardx JOIN :#esoteric < 1271468444 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :WHY IS ECLIPSE SO DAMN SLOW? < 1271468482 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Java < 1271468485 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :gui < 1271468485 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :libs < 1271468490 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :& sucky coding. < 1271468492 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Use Emacs or something. < 1271468512 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Emacs doesn't have an Android Developer Tools plugin < 1271468525 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :ADT even has a Glade-like thing < 1271468567 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Write out boring XML by hand, or use Eclipse.. hm < 1271468632 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :lava or liquid helium, that's the question < 1271468634 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :*waits 5 minutes to switch to the xml file for the layout < 1271468693 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :algorithms are the best things ever < 1271468732 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :FINALLY < 1271468740 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :al-gore-isms < 1271468748 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :algae-rhythms < 1271468753 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :if you disagree consider that i just replaced your mother with an algorithm < 1271468761 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :er that wasn't intended specifically at either of the two people talking < 1271468763 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :...awkward < 1271468820 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :awkward-isms < 1271468857 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :algae rhythms is a nice term < 1271468956 0 :zzo38!~zzo38@h24-207-48-53.dlt.dccnet.com JOIN :#esoteric < 1271469004 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :hi zzo38 < 1271469007 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :got my algorithm yet :P < 1271469032 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :algarve swims < 1271469061 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :No < 1271469066 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :WHYEVER NOT < 1271469076 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :i'll have you fired for this :P < 1271469077 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :Have you ever used pointer to pointer to pointer, in C programming? How many level of pointers have you used < 1271469113 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :algae bra < 1271469123 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :zzo38: three-star programmer! < 1271469143 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :http://c2.com/cgi-bin/wiki?ThreeStarProgrammer < 1271469167 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :I have that page already open in my browser, before you posted it < 1271469172 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :zzo38: I'm an n-star programmer, my code is so abstract that the depth of nested pointers depends fundamentally on the subtle properties of the algorithm I'm metaimplementing < 1271469180 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :(I wish) < 1271469207 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :If I ever get beyond 2, I add more types. < 1271469217 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :I have used three stars at most, I think. < 1271469217 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :Even a struct with only one member will clear things up extraordinarily. < 1271469234 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :A struct with only one member? Jesus weeps. < 1271469239 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :If I ever get beyond 2, I rethink my design. < 1271469250 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :And I wrote the three star code today, in fact, as part of a command-line argument parsing program < 1271469277 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :I have created structs that are completely unused, in fact. And there is a reason for that. < 1271469280 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Generally I just try and avoid using languages that have the anti-abstraction of pointers. < 1271469285 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :alise_: A struct with only one member is a way of forcing C to have more types. :) < 1271469286 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Or mutation. < 1271469298 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Also. Pointers, an abstraction? < 1271469308 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I said antiabstraction. < 1271469310 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :If they are, they're the thinnest possible abstractions. < 1271469321 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :They deabstract memory; they make it more concrete than it needs be. < 1271469323 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Mmkay. < 1271469355 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :alise_: I disagree. I think they need to deabstract a bit more things to make C useful in some ways, too < 1271469371 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :zzo38: I'm just a mathematical weenie, though. < 1271469372 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :They *do* make things like "moving objects" a royal pain. And lord help you if you want a compacting GC. < 1271469391 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I don't really care about stupid machines. Everything's graph reduction, or high-school algebra. :) < 1271469405 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :(it's possible... If you force all dereferencing through your GC.) < 1271469429 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :If you want a lot of abstraction in that kind of way, perhaps you can use a different program language for your project < 1271469455 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :alise loves his abstractions. < 1271469464 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :*her < 1271469468 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Get the confusing pronouns correct! < 1271469469 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :C allows precious few. < 1271469474 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :alise_: 'er < 1271469474 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I /will/ demolish English! < 1271469496 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Unless you want me to start using Japanese pronouns. < 1271469506 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :http://c2.com/cgi-bin/wiki?YouMightBeaThreeStarProgrammer < 1271469532 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :zzo38: Technically I'm in favour of low-level programming: just low-level programming on a decent machine; something like the Reduceron that does symbolic reduction, not a silly peeking-and-poking 70s BASIC machine like we all use today. < 1271469536 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Actually. Kochira know what? Ware think ware'm going to. :P < 1271469541 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Throw it all out and start again; then everything will be perfect. < 1271469619 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :(note: all pronouns in use are completely and utterly *bizzare* to use in normal Japanese, if valid. Koretachi are somewhat difficult to map into English otherwise. :P) < 1271469679 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :2b \/ ~2b, obviously multiplication on the booleans is just mod-2, so this is 0*b = false, so we have false \/ ~false, i.e. false \/ true < 1271469685 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :shakespeare, it's true. < 1271469689 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :thought you might like to know. < 1271469714 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Hah. Nanji wouldst do such a thing. < 1271469725 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :Some of the things listed in the YouMightBeaThreeStarProgrammer are I have used, but some I don't. < 1271469732 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: Who, what, where, why, when? < 1271469793 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :I don't write code which intentionally depends on undefined/unspecified behavior when writing in C, because C is supposed to be cross-platform. But I sometimes *do* intentionally undefined/unspecified behavior when writing in a lower-level program language such as plain machine-codes, but not always. It depends on circumstances. < 1271469804 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Dare, nani, doko, naze, nan no toki? < 1271469855 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :("nanji" not used for where to avoid confusion with "nanji" for thou) < 1271469879 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :"You have ever wished you could set a breakpoint within an expression." Yes, I have wanted this. In C, but also in other programming languages too < 1271469890 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :Have you? < 1271469904 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :zzo38: The difference between expressions and statements is just silly. < 1271469921 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Erm. Distinction, is nani ware meant. < 1271469933 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :so guys, judy arrays < 1271469935 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :cool things huh < 1271469990 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: Yes, it is a bit. In Forth there is no difference between expressions and statements. But in C some statement must be used not inside of a expression < 1271470005 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :(Although GNU C allows code-blocks inside of expressions) < 1271470032 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :alise_: So, nani anata are saying is that ware should use kore for Fungespace? < 1271470045 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: It may be an idea. < 1271470046 0 :augur!unknown@unknown.invalid QUIT :Remote host closed the connection < 1271470048 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I was considering it. < 1271470051 0 :augur!~augur@216-164-33-76.c3-0.slvr-ubr1.lnh-slvr.md.cable.rcn.com JOIN :#esoteric < 1271470052 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: Either that, or quadtrees. < 1271470069 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :And I'm going to stop the silliness with pronouns. < 1271470074 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :But, you know, http://judy.sourceforge.net/ is all pre-made and well-engineered for you. < 1271470079 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Except for 君, alise_. < 1271470083 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1271470099 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :And it has a nice API. < 1271470100 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :alise_: Yeah. < 1271470150 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: You might also, if you care about performance, want to add a static array of maybe a megabyte in size somewhere near (0,0) to handle "most" accesses. < 1271470175 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :"You have bitshifted the result of a boolean expression and used it as an array index..." Yes, I have, both in C and in BASIC and others. I have done this to fix a bug in MegaZeux so that the spiders can travel on their proper kind of web < 1271470206 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :(Or even outside of a web, as the case may be) < 1271470309 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Multiple times I day I get very pissed off at how immature software engineering is. < 1271470327 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :We've been doing this gig since about the 50s, and we still haven't figured out how to code properly. < 1271470329 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Or even acceptably. < 1271470393 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :It is true, some people can't program neatly at all. Many examples on http://thedailywtf.com/Series/CodeSOD.aspx < 1271470480 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :alise_: I was actually thinking of doing something like precomputing the ray of execution into a single thread, and just interpreting from that. And cacing precomputed threads. < 1271470491 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: Not sure what you mean by that. < 1271470495 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :zzo38: Indeed, but even good programmers are bad. < 1271470498 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :(thread in the "threaded programming" since) < 1271470502 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :s/since/sense/ < 1271470510 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: That makes p/g harder. < 1271470520 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: Also, remember to test Mycology regularly. Also, exact bounds. < 1271470522 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :You need exact bounds. < 1271470532 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :Yes, I have written codes that later I thought was TRWTF (but some of the codes that other people don't like that I wrote, I find to be perfectly OK, but not always) < 1271470537 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :For y, you need to be able to determine the exact maximum and minimum (x,y) coordinates of inhabited fungespace. < 1271470560 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Yes, it requires that I *either* keep track of the cells in each thread so I can invalidate them on modification, or just chuck out the entire cache upon modification. < 1271470592 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :And yes, I have every intent of keeping track of exact bounds. < 1271470623 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :How is pikhq storing Fungespace? < 1271470629 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Well, I'd say you are, in all likelihood (I haven't seen a piece of complex code by you), a very competent software engineer. And I can't think of any problems with your scheme. < 1271470632 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Judy array, it seems. < 1271470632 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :So go for it. < 1271470636 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: Well, I've suggested Judy arrays. < 1271470654 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :alise_: I shall after this weekend. < 1271470656 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: You'll want to lightly spec some sort of abstract fungespace interface so you can swap it out later, of course; in case, say, quadtrees are significantly faster. < 1271470670 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Of course. < 1271470670 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Language is plain C, I assume? Maybe GNU C. < 1271470674 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :89 or 99? < 1271470680 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :GNU C 99. < 1271470704 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Alright. < 1271470711 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :I make a lot of use of C99 features by habit, and my "compiling into threads" bit requires computed goto. < 1271470720 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I look forward to seeing your progress over the coming weekends; and hopefully soon enough weekdays too. < 1271470734 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Which, amusingly, clang handles much more efficiently than GCC. < 1271470748 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :I guess in AndFunge-98, I'd use the NDK to access the Judy array stuff? < 1271470761 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Stop calling it AndFunge; just makes me think of Avid NorlanDer. < 1271470771 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :And I'd just implement it all in Java. < 1271470773 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Do quadtrees. < 1271470776 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :They're fast. < 1271470798 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :It's still a long way off, ofc < 1271470812 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I keep feeling an urge to do some object-oriented programming in a language like Java. < 1271470829 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :uorygl: You're just longing for the platonic realisation of the hype. < 1271470832 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :I have another question: Have you ever used __attribute__((unused)) in GNU C? < 1271470837 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :A brief session coding in such a language should dispel any illusion. < 1271470839 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :*illusions < 1271470843 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :zzo38: No. < 1271470843 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I never feel like doing anything in particular; I keep just wanting to use it. < 1271470846 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :zzo38: No, I haven't. < 1271470863 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I avoid __attribute__ because I like to let the compiler think about optimisations rather than making half of my program instructions to the optimiser. :P < 1271470865 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :Have you ever used *any* __attribute__ in GNU C? And if so, which ones? < 1271470877 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I've used noreturn, when doing fiddly Scheme compilation stuff. < 1271470881 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :I'm only using Java because Android uses, well, not the JVM, but something that JVM bytecode gets compiled into < 1271470889 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :And probably printf-checking attributes, for error reporting functions that do printf-formatting. < 1271470909 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: Considered Jython/JRuby/Scala/etc? < 1271470930 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :alise_, I want to get up-to-speed with the basics of Android dev first < 1271470931 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :You could still use the GUI APIs that way; or if there's some actually-Java-specific thing, write the GUI in Java and interface to the actual interp. < 1271470956 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :alise_: I like to tune optimizations myself and stuff, but I just do more of that "RealProgrammer" stuff that is generally not preferred in modern programming, sometimes < 1271470978 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :I have used __attribute__((hot)) and even __attribute__((unused)) and more < 1271471014 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Currently, Eclipse is getting in my way more than Java is < 1271471043 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :Why is there a "Do Not Click" button? < 1271471055 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I tried Android extremely briefly today. < 1271471066 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :It seemed to have more features, less well implemented, than the iPhone. < 1271471142 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :uorygl: Did you try Android 2? < 1271471147 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Android 1 was very unpolished. < 1271471156 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Also, Android really suffered on slower CPUs. < 1271471163 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I have no idea what I tried. It was in a store. < 1271471177 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Okay. < 1271471183 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Well, there are quite a few not-so-good Android phones out there. < 1271471195 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I tried two or three. < 1271471198 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :But the Nexus One and the HTC Desire, say, are almost certainly as good as the iPhone, or at least very near it. < 1271471217 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :And, you know, they're unlike the iPhone in that they don't completely disallow any non-Objective-C language to be used, even pre-compiled, in their legal documents. < 1271471225 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Which is sort of a big deal. < 1271471304 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :while(pc) (***++pc)(); < 1271471319 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :zzo38: Ouch :( < 1271471322 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :Is it possible to make a coprocessor for ARM which adds an instruction to quickly execute that? < 1271471333 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I don't see why not. < 1271471337 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :I would find such an instruction useful directly in machine code < 1271471351 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :What does that do? I don't speak C. < 1271471359 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :Or, actually I mean just: (***+pc)(); < 1271471362 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :At least, not C with ***++ in it. < 1271471375 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :The while(pc) part would be a separate instruction < 1271471381 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :Sorry, I meant (***++pc)(); < 1271471385 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :(I forgot a plus sign) < 1271471394 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :uorygl: Copy the value of pc to pc1. Increment pc. Dereference pc1 into pc1*. Dereference pc1* into pc1**. Dereference pc1** into pc1***. < 1271471403 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pc1*** is some code; execute it. < 1271471408 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Repeat while pc is not zero. < 1271471418 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Whoa. < 1271471427 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :alise_, no < 1271471434 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :that would be ***pc++ < 1271471440 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :(with parens?) < 1271471446 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Er, right. < 1271471450 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :There could be one register (or the command could work with multiple registers) that would be the "pc" in this example and it would execute (***++pc)() < 1271471459 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :uorygl: Increment pc. Dereference pc into pc*. Dereference pc* into pc**. Dereference pc** into pc***. < 1271471463 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pc*** is some code; execute it. < 1271471467 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Repeat while pc is not zero. < 1271471471 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :When would this be useful? < 1271471478 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :uorygl: So, basically, pc is a pointer-to-a-pointer-to-a-function-pointer. < 1271471494 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :So a function-pointer is basically a passable-'round bit of mutable executable code. < 1271471494 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :When you have indirection. < 1271471502 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :So pointer-to-pointer-to-koed. < 1271471515 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :zzo38: I've used __attribute__((malloc)), because it sometimes lets the compiler generate better code. < 1271471537 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :(all that that does is state that any non-NULL pointers returned don't alias anything else) < 1271471609 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :I haven't use all the __attribute__ but I have read all of them and might use all of them if I have the use for them. What I would also like is the ability to use __attribute__ for blocks inside of a function instead of only for the entire function < 1271471748 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: http://mazonka.com/subleq/hsq.html A compiler from a reasonably competent C-esque language into Subleq. < 1271471756 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :It can also do bignums. < 1271471762 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Mazonka is as crazy as he is cool. < 1271471765 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :I have written ARGOPT today and I used three stars so that is why I tried to comment it < 1271471807 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: Subleq, in case you've had a case of amnesia, is "subtract and branch if less than or equal to 0". < 1271471819 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :alise_: Fun language. < 1271471819 0 :zzo38!unknown@unknown.invalid PRIVMSG #esoteric :I plan to use ARGOPT when I write a new GNU/Linux distribution (although with a lot of differences in both GNU and in Linux) < 1271471819 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :So compiling that... into that... yowzers. < 1271471833 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Fairly impressive that he did that, though. < 1271471845 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :http://esoteric.voxelperfect.net/wiki/Higher_Subleq It even compiles to a sort of twisted assembly beforehand. < 1271471866 0 :zzo38!unknown@unknown.invalid PART #esoteric :? < 1271471882 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Impressive. < 1271471886 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: He even implemented printf. < 1271471890 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Inside the language. < 1271471891 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :My dad doesn't want me carrying a charger nor a spare battery around < 1271471891 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Is Esolang's User:Oleg the same Oleg as the famous Haskell Oleg? < 1271471905 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :uorygl: No; I don't believe so. < 1271471911 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I checked once, iirc. < 1271471916 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: Why... not? < 1271471927 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :alise_: Dang. < 1271471929 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Not sure < 1271471944 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: Ignore him? < 1271471946 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :I applaud this guy. < 1271471948 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Personally, I'd rather not, but willing too if battery life is too short < 1271471959 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :*to < 1271471994 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I know alise already asked, and you already responded, but why not? < 1271472045 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :uorygl: I gather, from recent things he's said, that his father is rather apprehensive about chipping money into a new phone and seems to be dictating things purely for the sake of it. < 1271472063 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :He was reportedly earlier making baseless assertions about the quality of PDFs on phones, so... who knows. < 1271472072 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :THE WAYS OF ADULTS ARE NOT TO BE KNOWN < 1271472123 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I feel like making my own OISC now. < 1271472152 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :alise_: Do it in Funge! < 1271472154 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :hmm; with a bignum machine we only need one parameter to the instruction because we have N^n -> N mapping < 1271472163 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :but can we have a fixed-bit-size OISC that only has one operand? < 1271472197 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :alise_, if you want to give up TC, yes < 1271472209 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Take A, subtract B, divide by C, NAND with D, if greater than E, branch to F. < 1271472219 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :[Note that I make no statement about whether it's possible to do it and still be TC] < 1271472220 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: No shit, sherlock. :P < 1271472234 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :uorygl: Note: That is actually six-operand. < 1271472250 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I was just making my own OISC. < 1271472264 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :uorygl: Now prove it touring-complete. < 1271472277 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Done. < 1271472289 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Present the proof. < 1271472307 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Q.E.D. < 1271472377 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :quit endless doubting < 1271472386 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Anyway, how about RSSB? < 1271472418 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Quite Easily Demonstrated, I think uorygl meant. < 1271472423 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :He was leaving it as an exercise to the hearer. < 1271472424 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Of course. < 1271472493 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Fucking topologists. < 1271472543 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :http://www.facebook.com/group.php?gid=2410064537 o_O < 1271472544 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i sense a slight annoyance in your phrasing < 1271472588 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Oh, no, topologists are awesome. < 1271472594 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :uorygl: Oh, yeah, RSSB works. < 1271472610 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Hmm, can the two registers in RSSB be moved into memory? < 1271472628 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I think the spec says they are. < 1271472648 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Location 0 is IP, 1 is accumulator, 2 is always 0, 3 is input, 4 is output. < 1271472657 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Ah, right. < 1271472682 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :It might be better if those were locations -1 through -5, but oh well. < 1271472697 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I wonder if there are other, simpler single-operand OISCs. < 1271472706 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Reverse-subtract-and-skip-if-borrow is not the simplest semantics. < 1271472716 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Compare, e.g. subtract-and-branch-if-negative. < 1271472744 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I'd say they're approximately equally simple. < 1271472762 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Well, maybe. < 1271472781 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I dunno. < 1271472782 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I'd just like something ridiculously simple. :-) < 1271472804 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :It'd nice to have the core of the assembly code just be a list of names (defined to memory locations) and literals. < 1271472809 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :(Plus sugar on top for more complex things). < 1271472903 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :pretty please < 1271472922 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :har har har < 1271473302 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: when starting the emulator i just see < 1271473304 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :A N D R O I D < 1271473305 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :and a cursor < 1271473311 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :on a bios-style text field < 1271473313 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :alise_, be patient < 1271473314 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :am i meant to do something? < 1271473315 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :ok < 1271473343 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Note: If you had to restart the emulator every time you compiled an app, there would be no 3rd-party Android apps < 1271473352 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :*compiled and wanted to test < 1271473357 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :heh < 1271473366 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :five years later... < 1271473422 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :yay it started < 1271473429 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :i'm not missing much by not having sound am I :P < 1271473437 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :like are there amazing WHOOSH sounds!! < 1271473452 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :this thing is a bit sluggish < 1271473486 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :I still have yet to get sound working on the emulator to the PC, although it might be just me < 1271473521 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Although maybe I simply haven't tried any apps that use sound < 1271473534 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :how do you do multitasking? < 1271473571 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :and why does it think i'm japanese? < 1271473589 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :alise_, press the Home button < 1271473593 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION dials 999. let's hope this doesn't actually work
< 1271473595 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: oh that's it? < 1271473599 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Yes < 1271473608 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :is it always this sluggish? < 1271473610 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Then when you go back into the app, it should be where you left off < 1271473676 0 :oerjan!unknown@unknown.invalid QUIT :Quit: Good night < 1271473696 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :no but seriously why is it trying to compose kanji < 1271473771 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :There's some setting you can change to fix that < 1271473776 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :I'm not sure why it does that < 1271473776 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :yeah i did < 1271473794 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :this interface is pretty damn polished < 1271473806 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :It's not quite the Nexus One interface < 1271473861 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :i don't see why not < 1271473864 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :nexus one = stock google stuff < 1271473866 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :it's from google after all < 1271473885 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :That thing containing all the apps works differently on the Nexus One < 1271473895 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :The Nexus One has that pretty Live Wallpaper < 1271473908 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :The Nexus One has the Android Market, but that's not a UI thing < 1271473916 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pretty & battery-consuming < 1271474006 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Wow, the Droid (and the Nexus One although slightly less so) has really ridiculously high resolution. < 1271474014 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Although with the Nexus One it's PenTile so it's not reaaally the resolution. < 1271474021 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :But bah, Droid sucks in other ways. < 1271474057 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Oh how I *love* segfaults that make no sense. < 1271474075 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: Maybe you shouldn't use C. < 1271474091 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :alise_: But but lowlevel tricks and also pain and agony! < 1271474116 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :*Much* pain and agony! < 1271474128 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: Sometimes I consider using C++ and restricting myself to only using namespaces and references of the C++ features. < 1271474139 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :And no pointers, or at least as few as possible. < 1271474262 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: Make a device with skin WVGA854. < 1271474265 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Gawp at the resolution. < 1271474282 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :That's actually what Droid has. But, again, the Droid has numerous flaws; the Nexus One is far better. < 1271474286 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :And the Nexus One is pretty darn close anyhoo. < 1271474304 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :The default is nicer for me than the real Nexus One, since I can display the whole thing without the "real size" gimmick < 1271474311 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :yeah < 1271474353 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I wonder if anyone's done a sparse array by having all arrays be of length two, and using the bitstring representation. < 1271474359 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :(with a fixed size for the bitstrings) < 1271474370 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :of course, that requires 5 billion dereferences for even small indices < 1271474431 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :alise_, anohter multitasking thing [try it with the phone]: Some apps put things in the notification area < 1271474437 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :That you can use to switch to them < 1271474449 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Use the notification area by dragging the top bar down < 1271474900 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION lols at setText(getText(...))
< 1271474995 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Apparently, that doesn't quite work either < 1271475006 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION decides that the right way is too difficult
< 1271475092 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Actually, Eclipse makes it easy to turn the wrong way into the right way < 1271475096 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :It's actually very, very nice < 1271475109 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Well, not Eclipse, but the Android Development Tools for Eclipse < 1271475246 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :ADT is really, really, really nice < 1271475259 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :It's more than worth dealing with Eclipse < 1271475471 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :My trivial app finally worked! < 1271475801 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :3:42 am; sleep soon I probably should. < 1271475895 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I wonder whether it's actually a good idea to take out my anger on pens. < 1271475915 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Sometimes, when I'm angry, I'll grab one and snap it in two. < 1271475928 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I would rathest I just not be angry. < 1271476439 0 :jcp!unknown@unknown.invalid QUIT :Quit: I will do anything (almost) for a new router. < 1271476507 0 :jcp!~jw@bzflag/contributor/javawizard2539 JOIN :#esoteric < 1271476964 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :i love algorithms so much :| < 1271477014 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Hmm, it turns out that when you snap a pen in just the right way, it will send ink flying everywhere. < 1271477020 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Like onto our hardwood floor. < 1271477032 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :And since that's a porous surface, it now has ink stains. < 1271477669 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :4:14 am; I really should sleep soon. < 1271477671 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :uorygl: congrats < 1271477711 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Thank you. < 1271477712 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION kicks alise_
< 1271477718 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Who owns this channel? < 1271477725 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :me < 1271477730 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Anyone else? < 1271477735 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Not me, actually. < 1271477738 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :But, uh, andreou is the founder. < 1271477747 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :fizzie, lament and oerjan are the active ops. < 1271477748 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :It's owned by lament, if the portion of this sentence before the comma is true. < 1271477753 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :They effectively run the place. < 1271477757 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :But why do you ask? < 1271477762 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Well, oerjan doesn't do anything; and lament just does things to troll us. < 1271477767 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :And fizzie only does things with extreme hesitance. < 1271477770 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Because one of them needs to kickban alise_ so e'll go to sleep < 1271477772 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :So we're very close to total anarchy here. < 1271477774 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION nods.
< 1271477778 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: Eh, but why? < 1271477783 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I don't need to be up at a certain time until Monday. < 1271477795 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :And this is more enjoyable. < 1271477801 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :alise_, health < 1271477811 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Eh? Staying up late isn't going to damage my health. < 1271477812 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I suppose health is a good reason for anything. < 1271477813 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :And to make it easier to wake up at that point < 1271477823 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :It does kind of seem to damage health. < 1271477836 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I have a rather nasty infection, not a huge requirement for sleep. < 1271477844 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :uorygl: It makes me dumber, sure, and it makes me more tired if I don't sleep enough. < 1271477851 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :But I'm happy enough right now, and I'll sleep in. < 1271478057 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :sgeocomet < 1271478057 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric : < 1271478057 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :#ZodiacFacts The stars that make up the constellation #Taurus are, for the most part, undergoing nuclear fusion. < 1271478076 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :That's ... nice to know. < 1271478094 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :At least it's accurate, unlike most of the stuff in #ZodiacFacts < 1271478101 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :BadAstronomer's are funnier though < 1271478158 0 :mycroftiv!unknown@unknown.invalid QUIT :Read error: Operation timed out < 1271480481 0 :alise_!unknown@unknown.invalid QUIT :Remote host closed the connection < 1271480784 0 :mycroftiv!~ircguy@h69-128-47-242.mdsnwi.dedicated.static.tds.net JOIN :#esoteric < 1271481235 0 :Oranjer!unknown@unknown.invalid PART #esoteric :? < 1271481300 0 :Alex3012_!~chatzilla@ool-18b989d3.dyn.optonline.net JOIN :#esoteric < 1271481402 0 :Alex3012!unknown@unknown.invalid QUIT :Ping timeout: 265 seconds < 1271481410 0 :Alex3012_!unknown@unknown.invalid NICK :Alex3012 < 1271489455 0 :lament!~lament@S0106002312fa554a.vc.shawcable.net JOIN :#esoteric < 1271490813 0 :lament!unknown@unknown.invalid QUIT :Quit: lament < 1271491033 0 :coppro!unknown@unknown.invalid QUIT :Ping timeout: 276 seconds < 1271491102 0 :coppro!~coppro@unaffiliated/coppro JOIN :#esoteric < 1271491199 0 :clog!unknown@unknown.invalid QUIT :ended < 1271491200 0 :clog!unknown@unknown.invalid JOIN :#esoteric < 1271493904 0 :kar8nga!~kar8nga@jol13-1-82-66-176-74.fbx.proxad.net JOIN :#esoteric < 1271494352 0 :augur!unknown@unknown.invalid QUIT :Remote host closed the connection < 1271494360 0 :augur!~augur@216-164-33-76.c3-0.slvr-ubr1.lnh-slvr.md.cable.rcn.com JOIN :#esoteric < 1271496496 0 :augur!unknown@unknown.invalid QUIT :Remote host closed the connection < 1271496501 0 :augur!~augur@216-164-33-76.c3-0.slvr-ubr1.lnh-slvr.md.cable.rcn.com JOIN :#esoteric < 1271499156 0 :tombom!tombom@wikipedia/Tombomp JOIN :#esoteric < 1271501205 0 :MigoMipo!~MigoMipo@84-217-1-141.tn.glocalnet.net JOIN :#esoteric < 1271501584 0 :FireFly!~firefly@unaffiliated/firefly JOIN :#esoteric < 1271503334 0 :oerjan!~oerjan@hagbart.nvg.ntnu.no JOIN :#esoteric < 1271503700 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric : Hmm, it turns out that when you snap a pen in just the right way, it will send ink flying everywhere. < 1271503710 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i guess that answer your previous question, then < 1271503720 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :*s < 1271506141 0 :kar8nga!unknown@unknown.invalid QUIT :Remote host closed the connection < 1271506635 0 :BeholdMyGlory!~behold@unaffiliated/beholdmyglory JOIN :#esoteric < 1271506721 0 :Alex3012_!~chatzilla@ool-18b989d3.dyn.optonline.net JOIN :#esoteric < 1271506930 0 :Alex3012!unknown@unknown.invalid QUIT :Ping timeout: 245 seconds < 1271506935 0 :Alex3012_!unknown@unknown.invalid NICK :Alex3012 < 1271507054 0 :oerjan!unknown@unknown.invalid QUIT :Quit: leaving < 1271507828 0 :ENKI-][!unknown@unknown.invalid QUIT :Ping timeout: 276 seconds < 1271508204 0 :tombom!unknown@unknown.invalid QUIT :Quit: Leaving < 1271508291 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric : i guess that answer your previous question, then <-- what was that question? < 1271509572 0 :ENKI-][!~john@c-24-63-206-22.hsd1.ct.comcast.net JOIN :#esoteric < 1271510278 0 :Asztal!~asztal@host86-158-80-62.range86-158.btcentralplus.com JOIN :#esoteric < 1271511520 0 :kar8nga!~kar8nga@jol13-1-82-66-176-74.fbx.proxad.net JOIN :#esoteric < 1271511874 0 :BeholdMyGlory!unknown@unknown.invalid QUIT :Remote host closed the connection < 1271511937 0 :mycroftiv!unknown@unknown.invalid QUIT :Ping timeout: 240 seconds < 1271512084 0 :alise!~alise@212.183.140.23 JOIN :#esoteric < 1271512516 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :An illegality of jazz. < 1271513041 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :http://retroforth.org/ Are the Forthers trying to be post-hip-modernist-minimalist? < 1271513079 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :What, they've implemented their VM in Javascript. < 1271513120 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :http://retroforth.org/demos/demos/listener/index.html < 1271513218 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Hmm. < 1271513227 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :In RSSB, does the subtraction /have/ to be reverse? < 1271513236 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Or would SSB work fine? < 1271513359 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Hmm, and http://esolangs.org/wiki/TOGA_computer's using of bits is interesting. < 1271513385 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I wonder if TSZ (toggle and skip next instruction if result is 0) would be TC? < 1271513423 0 :mycroftiv!~ircguy@h69-128-47-242.mdsnwi.dedicated.static.tds.net JOIN :#esoteric < 1271513452 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :hi mycroftiv < 1271513584 0 :mycroftiv!unknown@unknown.invalid QUIT :Read error: Operation timed out < 1271513761 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Of course a toggle-style instruction set makes IO harder. < 1271514300 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I wish http://eigenratios.blogspot.com/ still posted. < 1271514392 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :ok, [[User:Oleg]] is mazonka.com < 1271514402 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :case closed < 1271514851 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :"8. Why in the mirror the left swaps with the right, but the top does not swap with the bottom?" < 1271514853 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :"# 8. This is very difficult question. I do not know its answer." < 1271514859 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :--Oleg Mazonka on his "mathematical puzzles" page < 1271514936 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :O_O < 1271514969 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :It's obviously a joke. < 1271514988 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :(The simple answer, of course, is that mirrors rotate in the fourth dimension.*) < 1271514991 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :*I find this fact extremely awesome < 1271515001 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :lol < 1271515012 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Hey, it is true. < 1271515095 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I mean, obviously they don't literally pop into the fourth dimension for some rotating action... but that's the transformation they do to what you see. < 1271515149 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :So, I'm still trying to figure out a simpler one-operand OISC than RSSB. < 1271515275 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Hmm, I feel like making a fast Brainfuck interpreter. Like a snack, only programming. < 1271515429 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Gregor: Do you know if malloc( sizeof somestruct - sizeof int ) is valid, where the last member of somestruct is an int? < 1271515447 0 :kar8nga!unknown@unknown.invalid QUIT :Read error: Connection reset by peer < 1271515504 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :alise: Depends on your definition of "valid" and the particulars of the system. It won't give wonky results unless the only member is an int. In most but not all cases the int will be inaccessible of course. < 1271515543 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Right; I was just checking it wasn't U.B. < 1271515546 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Not that I care much. < 1271515561 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :"U.B."? < 1271515576 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Gregor: And I'm gonna go out on a limb here and guess that putting computed goto &&pointers into a static array for use later, when the function has been exited and re-entered, is not such a guaranteed-to-work idea. < 1271515580 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Undefined behaviour. < 1271515596 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Actually this is irritating, since computed gotos are just right for what I want. < 1271515598 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Although, wait. < 1271515607 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :A switch with defined values will likely be faster than dereferencing the goto pointer, won't it? < 1271515612 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :Actually that has perfectly well-defined semantics and people (including me) use it all the time. < 1271515619 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I was going to use this: < 1271515621 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :typedef struct { < 1271515621 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :alise: Could go either way. < 1271515621 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : void *kind; /* computed-goto pointer to a blueprint */ < 1271515621 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : intptr_t val; < 1271515621 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :} INS; < 1271515624 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :for a BF instruction < 1271515628 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :and have kind be one of the elements of this: < 1271515631 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :static void *blueprints[6]; /* move, change, output, input, [, ] */ < 1271515640 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :but it'll be quicker just to switch over a char, won't it? < 1271515643 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :since the range is predefined < 1271515648 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :and it doesn't involve dereferencing a pointer < 1271515649 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :It could be, but not likely. < 1271515652 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :That's three jumps. < 1271515666 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :(Instead of 1) < 1271515688 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Eh? < 1271515691 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Hmm, right. < 1271515694 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :So the computed goto is better? < 1271515697 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I guess so. < 1271515702 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :Probably, but not always :P < 1271515722 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :That's called a threaded interpreter. Look it up. And don't get confused with the meaning of "threading" that real people use. < 1271515749 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Yeah, I know that. < 1271515752 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I've read JonesForth, you know. :P < 1271515760 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I was just thinking that in this case the number of instructions is very small. < 1271515763 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :void interp(char setup) { < 1271515763 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : blueprints = {&&move, &&change, &&output, &&input, &&loop, &&next}; < 1271515763 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : if (setup) return; < 1271515763 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : ... < 1271515763 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :} < 1271515767 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :lulz < 1271515805 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :#define MOVE blueprints[0] < 1271515806 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :#define CHANGE blueprints[1] < 1271515806 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :(etc) < 1271515810 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :You're still going to have while (1) { switch (foo) { a: break; b: break; c: break; } } < 1271515813 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :That's three jumps. < 1271515818 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I'm not. < 1271515826 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :I mean if you use a switch and not computed gotos. < 1271515829 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Ah. < 1271515830 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Right. < 1271515844 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Hmm, I wonder which is better: < 1271515862 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :while (1) { goto *ins->kind; foo: ...; continue; bar: ...; continue; ... } < 1271515863 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :or < 1271515880 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :LOOP: goto *ins->kind; next ins < 1271515883 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :foo: ...; goto LOOP; < 1271515886 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :bar: ...; goto LOOP; < 1271515891 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I guess they will be compiled into much the same code. < 1271515899 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :Probably. Both are pretty awful :P < 1271515924 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Gregor: Got any better suggestions? < 1271515938 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :#define NEXT ins++; goto *ins->kind; < 1271515945 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :Then put NEXT at the end of every instruction. < 1271515952 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Oh, of course. < 1271515956 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I really should re-read JonesForth. < 1271515960 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1271515961 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION renames the NEXT instruction to avoid clashing
< 1271516063 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Hmm, if I want to beat http://mozaika.com.au/oleg/brainf/bff4.c fairly, I need a dynamically-allocated tape. < 1271516069 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Eh, I'll do that later. < 1271516123 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Gregor, you mean he doesn't know this? < 1271516125 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :wth < 1271516138 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Just because I haven't written a threaded interpreter in a while... < 1271516152 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I left C and ages for months to mess around with mathematical languages. < 1271516160 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :Whereas I've been TAing a class in which half the class are writing them :P < 1271516171 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Gregor, "TA"= < 1271516174 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Gregor: He won't get the context; he has me on ignore. < 1271516174 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :s/=/?/ < 1271516179 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: Teaching Assistant < 1271516181 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :It's not like many people outside of Forth write threaded interps in practice anyhow. < 1271516182 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah < 1271516195 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :alise: That's not true at all. < 1271516207 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Well, okay, but it certainly isn't the most common method of implementation. < 1271516209 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :alise: Most half-decent bytecode interpreters are threaded nowadays. < 1271516217 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Python wasn't until recently. < 1271516217 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :alise: (Before JITing of course) < 1271516225 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Then again, GvR is a retard. < 1271516231 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :alise: Nowadays = this year, basically, it's all the rage :P < 1271516248 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION wonders whether
< 1271516251 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric : alise: Most half-decent bytecode interpreters are threaded nowadays. <-- yes, I'm surprised if he didn't know that... < 1271516261 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION wonders whether
< 1271516264 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :input: if ((c = getchar()) == EOF) *tape = 0; else *tape = c; < 1271516264 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :or < 1271516265 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :input: if ((*tape = getchar()) == EOF) *tape = 0; < 1271516268 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :is more micro-efficient < 1271516270 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I suspect the latter < 1271516271 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :Being the intermediary in a half-blocked conversation is amusing :P < 1271516272 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :since EOF is an edge-case < 1271516281 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Gregor, I can imagine < 1271516292 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :alise: I would guess the latter as well. < 1271516297 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Gregor: I like how you're mostly half-agreeing with me when I clarify things and AnMaster thinks him and you are dissing me into Retard Hell :P < 1271516311 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :alise: Yup :P < 1271516347 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I think I'm finally managing to think like AnMaster. "Hey, I have a lot of ->s in this code. I could pre-dereference the struct beforehand..." < 1271516464 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION realises he has a potential "goto NULL" situation
< 1271516470 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :No problem; one more blueprint entry for STOP. < 1271516474 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :Call that "exit" :P < 1271516474 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :The most famous of all brainfuck instructions. < 1271516479 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :The program will definitely exit :P < 1271516488 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :But it also stops! < 1271516493 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Oh, NULL < 1271516494 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :xD < 1271516498 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :Yeah :P < 1271516562 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Gregor, any new music recently? < 1271516587 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I wonder if gcc will be happy with a 10485760-length static array. < 1271516588 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: No, I'm currently in wrist splints for carpal tunnel :( < 1271516595 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :For all those ten-megabyte brainfuck programs. < 1271516605 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :gcc usually has an internal error when you allocate a static array big enough. < 1271516609 0 :mycroftiv!~ircguy@h69-128-47-242.mdsnwi.dedicated.static.tds.net JOIN :#esoteric < 1271516612 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Gregor, ouch < 1271516658 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I think I've realised that most of my C coding is designed around avoiding to have to use malloc at all. < 1271516662 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Or, especially realloc. < 1271516717 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :op ip[5242880]; /* do not make a program longer than five megabytes i will be sad */ < 1271516722 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Truer words have never been spoken. < 1271516728 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :lawl < 1271516737 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :alise: Use my buffer.h :P < 1271516742 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :You know you want to. < 1271516752 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Linky me up < 1271516765 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :If it does anything to slow down the main interpreter loop, no way :P < 1271516781 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :http://codu.org/projects/stuff/hg/index.cgi/file/tip/buffer.h < 1271516787 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :You would just use it to easily load in the file. < 1271516798 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Not expanding the tape? < 1271516805 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :char tape[65536] = {0}; /* I wonder if I should just rely on this working */ < 1271516807 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :Oh, you could do that too if you wanted to use it for the tape. < 1271516817 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :But you'd have to do bounds-checking for that. < 1271516819 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Gregor: Hmm, not for the tape; too much overhead. < 1271516823 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :I was just thinking loading in files :P < 1271516833 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I was just going to embed the program source at first... < 1271516842 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :This is just bf1.c, there is plenty of time for polish in bf137 :P < 1271516843 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :INIT_BUFFER(buf); fopen etc; READ_FILE_BUFFER(buf, filehandle); /* hooray */ < 1271516849 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Gregor, idea: use stat() to figure out in advance how large that buffer needs to be < 1271516865 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: That would be a sensible thing for me to do >_> < 1271516878 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Gregor, yeah, is that a bad thing? < 1271516900 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: Except that buffer.h works on "all" C systems, not just Unix. IIRC there's no very good stdio equivalent, but maybe I just don't recall it. < 1271516900 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Yes it is. < 1271516902 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Race condition. < 1271516904 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :For one. < 1271516918 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Gregor, well true, so do #ifdef PURE_C or some such < 1271516929 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :alise: It would just be for guessing the initial buffer size. < 1271516937 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :It turns out that intensive use of #ifdefs is not the way to write correct code. < 1271516937 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :alise: Just preallocation. < 1271516950 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Unless you like reading half a page of preprocessor directives for every actual meaty line of code. < 1271516963 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Gregor: consider trigging pathological behaviour by making a 0-length file then immediately overwriting it with a 5gb one < 1271516968 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :it would certainly readuce reallocation, and also mean you would know at initial allocation if you had enough memory < 1271516989 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Gregor, why macros and not inline functions? < 1271517025 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :You can rely on a macro being inlined perfectly. < 1271517031 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Also, you don't need to write a separate .c file. < 1271517040 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Gregor, or do you with "all C" mean C90 too? Not just C99? < 1271517053 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :That also. < 1271517063 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: I mean I can compile it for 16-bit DOS with outdated Watcom compilers :P < 1271517072 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric ::DE < 1271517073 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric ::D* < 1271517093 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Gregor, still some #ifdef to for *nix might be a good idea < 1271517103 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :alise: Your pathological behavior is an edge case that could be detected. a 1-length file would be a nonissue. < 1271517133 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Gregor: Fair enough. < 1271517168 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Also, I'd just like to throw out a strong vote against #ifdef fuckery. If you really want uber-ridiculous-speed, make them actual separate .c files compiled differently depending on the OS (in e.g. your build system) < 1271517173 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Or at least do < 1271517175 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :#ifdef FOO < 1271517182 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :#include "ricer_speed_buf.h" < 1271517182 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :#else < 1271517186 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :#include "i_am_sane.h" < 1271517187 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :#endif < 1271517200 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :I haven't changed buffer.h in significant ways (except for adding totally new macros) basically since its inception :P < 1271517204 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :So *eh* < 1271517212 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :I once met a programmer who didn't know you could put function bodies in headers... After all it is just included. static inline in a header works fine. < 1271517228 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: So long as your compiler supports static ;) < 1271517235 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :And inline < 1271517245 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :You know, sometimes there is a good reason for .h and .c to be separate. < 1271517246 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant, well sure < 1271517246 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Just saying. < 1271517255 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :alise: CRAZY < 1271517266 0 :mycroftiv!unknown@unknown.invalid QUIT :Ping timeout: 276 seconds < 1271517274 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :You can always #define inline away, but if you #define static away you'll get multiply-defined errors. < 1271517284 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Gregor, you do? < 1271517285 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : op *stk[65536]; /* also if you use more than 65536 nested loops i will be sad too */ < 1271517294 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: consider separate compilation. < 1271517299 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: That's ... the whole idea of static X_X < 1271517300 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :oh you mean like that < 1271517300 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :right < 1271517301 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :multiple definitions in separate objects < 1271517307 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :WOW ANMASTER DIDN'T KNOW THAT? < 1271517310 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :MUST BE PRETTY DUMB HUH < 1271517311 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :alise: :P < 1271517316 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :RIGHT GREGOR :P < 1271517319 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Gregor, but it will work on some platforms anyway iirc < 1271517326 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: Sure, depends on the linker. < 1271517329 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Gregor, anyway I don't know of a compiler that lacks static < 1271517336 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :char tape[65536] = {0}; <-- Please tell me that some compiler, somewhere, supports this :-) < 1271517342 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: I'll go dig up a pre-ANSI one for PDP-11 ;) < 1271517352 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Gregor, I don't care about pre-ANSI < 1271517411 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :static for file-local is rather strange btw < 1271517414 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :I mean as a keyword < 1271517452 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: C's use of "static" is a bit schizophrenic :P < 1271517461 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Gregor, exactly my point < 1271517466 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Gregor: also I'm not sure buffer would work so well as I want to "compile"/parse as I go < 1271517470 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :maybe I should read just a bit at a time < 1271517473 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :or maybe not, maybe this is better < 1271517475 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Gregor, it makes a whole lot of sense for the "persists between calls < 1271517477 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :" < 1271517486 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :No it doesn't < 1271517493 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :That's the most confusing sense < 1271517499 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :possibly they were out of keywords and didn't want to mess up with anyone who had a variable called "local" < 1271517499 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :alise: Up to you, I've just found I always like my buffers :P < 1271517503 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :or function called it < 1271517511 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :or type for that matter < 1271517522 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Gregor: Well if I were optimising for happiness and laughter I would use some language other than C but I'm going for mega performancebucks here :P < 1271517668 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :with intptr_t -- which I've never used before; I'm a radical kind of freewheeling fellow as far as integers and pointers go -- do you need to cast when assigning pointers to it, or when assigning integers? < 1271517696 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :Never used it :P < 1271517708 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Right, well, clearly you know best; bye-bye intptr_t. < 1271517807 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Gregor: Hmm, I'm not sure doing what I said I'd do -- and what you said would work -- with computed gotos /will/ work. < 1271517809 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Oh, wait < 1271517812 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I just have to preinitialise the array < 1271517852 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :er, or rather, just not assign it as a literal < 1271518028 0 :mycroftiv!~ircguy@h69-128-47-242.mdsnwi.dedicated.static.tds.net JOIN :#esoteric < 1271518032 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :bf1.c:41: warning: cast from pointer to integer of different size < 1271518033 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :bf1.c:42: warning: cast from pointer to integer of different size < 1271518033 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :wuteva. < 1271518071 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :size_t? < 1271518097 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :just void * < 1271518098 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1271518110 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :$ echo abc | ./bf1 < 1271518111 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :$ < 1271518112 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :It almost echoes! < 1271518127 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :it appears to read one character in, then exit < 1271518133 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :15:15:12 char tape[65536] = {0}; <-- Please tell me that some compiler, somewhere, supports this :-) < 1271518140 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :you mean 0-init the whole array? < 1271518164 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :yeah, i know it does work < 1271518169 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :but still, it's such a weird feature < 1271518184 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :i _think_ that arrays are 0-inited by default, if specified outside of a fucntion < 1271518188 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :function* < 1271518194 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :yeah i think so too < 1271518195 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :still < 1271518201 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :so char tape[65536]; should do it as well < 1271518215 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :yeah, i just get twitches whenever i see a decl without initialiser in c < 1271518218 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :for obvious reasons < 1271518218 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :it's only if you have to malloc() the array that it's random < 1271518219 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :Uhhhh < 1271518225 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :obvious reasons? < 1271518231 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :int *x; < 1271518232 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :*x < 1271518233 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :aaaah < 1271518234 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :On MOST systems arrays outside a function are in BSS, but that's NOT guaranteed by C. < 1271518247 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :fuck yeah, standards fight < 1271518262 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :Gregor: i'm going by memory of K&R < 1271518303 0 :Gregor!unknown@unknown.invalid PRIVMSG #esoteric :I'm going by memory of your FACE. < 1271518326 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :sorry honey, i don't recognise you < 1271518328 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Gregor, static ones are going to be zero at start < 1271518341 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :not sure about non-static ones < 1271518368 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :your MOM are going to be zero at start < 1271518383 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION declares a bunch of stuff static for moar speed
< 1271518391 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :moar speed in my broken program < 1271518410 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1271518415 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :move: tape += (int)p.val; NEXT; < 1271518415 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :change: *tape += (int)p.val; NEXT; < 1271518416 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :output: putchar(*tape); NEXT; < 1271518416 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :input: if ((*tape = getchar()) == EOF) *tape = 0; < 1271518416 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :loop: if (!*tape) ip = p.val; < 1271518416 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :end: if (*tape) ip = p.val; < 1271518418 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :stop: return; < 1271518420 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :spot the issue < 1271518443 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :sweet, EOF generates a segfault < 1271518453 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :even normal progam termination does < 1271518456 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1271518459 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I forgot to add the stop instruction < 1271518460 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :heh < 1271518477 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Well, cat works. < 1271518484 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION tries mandelbrot.b
< 1271518496 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :brainfuck? < 1271518542 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :15:03:54 I think I've realised that most of my C coding is designed around avoiding to have to use malloc at all. - any reason why? < 1271518552 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: Well, malloc's not so bad. < 1271518555 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :But realloc is tedium personified < 1271518577 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :(and I'm not just some shitty PHP coder who doesn't "get" C -- I've used lower level languages than it, and loved C for ages, and I've used languages all the way up the spectrum too) < 1271518584 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :shouldn't it be unsigned char for bf? < 1271518596 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Doesn't make any difference, does it? < 1271518614 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :i think it does for integer wraparound < 1271518625 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :nope < 1271518632 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :oh, right < 1271518636 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :only for bit shifting < 1271518689 0 :olsner!unknown@unknown.invalid PRIVMSG #esoteric :if you write C, signed-integer overflow is undefined :) < 1271518710 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Oh. Okay then. < 1271518722 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Hey, mandelbrot.b works. < 1271518731 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I only made one mistake in writing the entire program. < 1271518771 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Slowly, mind, but not nearly as slowly as you'd expect from a relatively naive first draft. < 1271518828 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :$ time ./bf1 > /dev/null < 1271518828 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :real 0m44.460s < 1271518829 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :user 0m43.255s < 1271518829 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :sys 0m0.108s < 1271518853 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :So, I need to make "parsing" smarter -- combine moves and modifies. < 1271518878 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Then I need to shift moves and the like into the other instructions. < 1271518885 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Then I need to do linear-loop optimisation. < 1271518901 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : char *prog = < 1271518901 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :#include "mandelbrot.h" < 1271518902 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : ; < 1271518938 0 :olsner!unknown@unknown.invalid PRIVMSG #esoteric :and implement reading a program from file perhaps? < 1271519075 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :yes, well, later. < 1271519114 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION writes bf2.c
< 1271519447 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION benchmarks bf1 vs bf2
< 1271519458 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I imagine around bf10 might be faster than bff4 with linear loop optimisation < 1271519467 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :incremental development is a blast < 1271519529 0 :cheater3!~cheater@ip-80-226-238-88.vodafone-net.de JOIN :#esoteric < 1271519589 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Hmm, I do wonder if indexing into my static tape array with an integer might not help the compiler figure out more than using just an opaque pointer. < 1271519597 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :$ ./bf1 > /dev/null; time ./bf1 >/dev/null; ./bf2 >/dev/null; time ./bf2 >/dev/null < 1271519597 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :real 0m45.774s < 1271519597 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :user 0m43.171s < 1271519597 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :sys 0m0.080s < 1271519597 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :real 0m20.209s < 1271519598 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :user 0m18.277s < 1271519600 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :sys 0m0.096s < 1271519603 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Only change was combining multiple <>, +- instructions. < 1271519611 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Low hanging fruit right there. < 1271519617 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :(Well, and I changed the type to int, not void *.) < 1271519623 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :(It should probably be long.) < 1271519708 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Changing to long only varies mandelbrot.b's time from 20.209s to 20.635s < 1271519711 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :So that's good. < 1271519714 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION tries -m32
< 1271519725 0 :cheater2!unknown@unknown.invalid QUIT :Ping timeout: 260 seconds < 1271519762 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :eh, don't have the 32 libs < 1271519889 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Daniel B. Cristofani's self-interpreter is so amazing. < 1271519892 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Hey, changing to a tape index shortened the time to 18.194s. < 1271520072 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Speeding this thing up is... rather ridiculously easy. < 1271520104 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Oh, dear; bf4 slowed things down. < 1271520205 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Down to 17.969s; I'm almost as fast as bff.c on mandelbrot. < 1271520223 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :And only 101 lines, too -- though I need to add program loading, and possibly variable tape allocation. < 1271520348 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Strangely enough, not pre-dereferencing ip speeds it up a little bit (<1s, but still). < 1271520359 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :(<.5s, too, but it's still definitely not a coincidence giving time's results) < 1271520378 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :It's now only 99 lines. < 1271520581 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION growls at everyone who uses non-domain-name-based package names
< 1271520584 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I guess I'll bite the bullet. bf6 will be the one that does the first combining of move operations into other instructions. I think. < 1271520645 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :++++>+<[>[>+>++<<-]>>[<<[>+<-]>[<++>-]>-]<<<-]>[<+>-]< ;; bf program to calculate 2^(2058 + 2^4116) < 1271520705 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :source: http://www.iwriteiam.nl/D9901.html#24 < 1271520715 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :even bigger? http://www.iwriteiam.nl/D0904.html#15 < 1271520723 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :if you add +s to the start of that program you get something even bigger < 1271520751 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :2^(2058 + 2^4116) has 10^1239 digits in base 10 < 1271520780 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :or, in other words, < 1271520786 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :it has 100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 < 1271520786 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 < 1271520786 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 base-10 digits < 1271520789 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :approximately. < 1271520832 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :So what we've learned here is with that with the BF kolgomorov complexity K(x): < 1271520849 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :K(2^(2058 + 2^4116)) <= 54 < 1271520852 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :It is a rather simple integer. < 1271521005 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION considers folding in moves by having an int that gets inc/dec on move instructions, then putting it in any newly created instruction
< 1271521005 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :yeah < 1271521304 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Oh dear; it seems like bf6, with its move-folding, is going slower than bf5. < 1271521341 0 :adam_d!~Adam@cpc2-acto6-0-0-cust48.brnt.cable.ntl.com JOIN :#esoteric < 1271521352 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I guess what I really need to do is handle >^nX<^n (also swapping >/<) for all n. < 1271521356 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :But that's Hard. < 1271521367 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :I think your number of digits is off by factor of about 3... :-> < 1271521385 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Ilari: Quite possibly. < 1271521396 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I just asked Wolfram Alpha then pasted the result into Ruby (nearest thing to hand), then copy-pasted the result. < 1271521407 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :The potential for error at any point is large. < 1271521437 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Oh, look: bf6 does not even work. < 1271521437 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I'd better fix it. < 1271521442 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Oh, of course. < 1271521518 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION wonders how playable the JS version of Robozzle is
< 1271521536 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :i tried it. < 1271521543 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :it's alright < 1271521560 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :I get (rounding off a bit): 3.296643047157257677279598742963425708214531905272149037702927150038*10^1238 base 10 digits. < 1271521605 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Nice precision. < 1271521619 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Maybe I rounded a .5 down, rather than up, in the log result. < 1271521650 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Grr; this really should work. < 1271521848 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :That was rounded from result I got (to avoid pasting 1239 digit number to IRC). < 1271521948 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric ::-) < 1271521955 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Is it using floats? < 1271521959 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I guess not. < 1271521989 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :Fixed point (at scale of 10^1500). < 1271522051 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :What calculator? < 1271522056 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :bc < 1271522061 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Clearly what we /really/ need is someone to evaluate it symbolically. < 1271522080 0 :adam_d!unknown@unknown.invalid QUIT :Ping timeout: 245 seconds < 1271522103 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Well, it's /approximately/ 10^1238.518071925292. < 1271522107 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :But that is not very helpful. < 1271522131 0 :adam_d!~Adam@cpc2-acto6-0-0-cust48.brnt.cable.ntl.com JOIN :#esoteric < 1271522171 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :1 + floor((2058 + 2^4116)*log(2)/log(10)) < 1271522179 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :It's amazing how star placement can make a puzzle easier or harder, just by leading you in the right or wrong direction to approach the puzzle < 1271522201 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :[ignoring placement that changes the puzzle itself, ofc] < 1271522255 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Ilari: Well, that is just cheating. < 1271522271 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION tries maxima
< 1271522278 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Anyone have axiom? Or Octave? < 1271522403 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION is installing octave and axiom... Takes a while to download ~130MB...
< 1271522431 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Octave isn't symbolic, I don't think, but a lot of people use it. < 1271522435 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I'm downloading Maxima. < 1271522440 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Octave doesn't do much else than double-precision floats. It's an engineer thing. < 1271522452 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Alright then; skip Octave. < 1271522463 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :It is of the utmost importance that we get an exact answer to this question! < 1271522551 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION goes to try /* Comments */
< 1271522566 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :alise, isn't Maxima costly? < 1271522632 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Free. < 1271522636 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Are you thinking of Mathematica? < 1271522640 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I have Mathematica somewhere. I pirated it. < 1271522657 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION was thinking of Mathematica, yes >.>
< 1271522747 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION drools at http://www.youtube.com/watch?v=SnWJ29eNCbY
< 1271522793 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :"purchasing of puzzle solutions"? WTF? < 1271523162 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :grr, why the hell doesn't this work < 1271523485 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :It's behaving differently for... no reason whatsoever. < 1271523975 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Ilari: Any luck with axiom? < 1271524131 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION wonders if it's possible to make an iPhone emulator for Android
< 1271524206 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Ilari: I've got the precise result. < 1271524280 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :sec < 1271524305 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Ilari: http://pastie.org/924690.txt?key=ofuqp78ktc37x7uktmhuuw < 1271524329 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :But ++++>+<[>[>+>++<<-]>>[<<[>+<-]>[<++>-]>-]<<<-]>[<+>-]< doesn't even calculate the number shown there; it calculates a number with that many digits. < 1271524333 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :2^(2058 + 2^4116); what a number. < 1271524425 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :Looks like that number matches to what I calculated... < 1271524458 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I just kept prompting Wolfram Alpha for more digits. :-) < 1271524462 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :What would adding fifth '+' in beginning do to number it calculates? How large it would then be? < 1271524544 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :The author didn't specify: just that it was much larger. < 1271524556 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :You could probably work it out by figuring out what formula it's running, and treating the initial +s as parameters. < 1271524571 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :http://www.iwriteiam.nl/Ha_bf_numb.html has links to the blogposts; the 1999 one is the one we're talking about. < 1271524822 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION is absolutely determined to beat mazonka's interp...
< 1271524828 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :why isn't my move-combining working! < 1271525018 0 :lament!~lament@S0106002312fa554a.vc.shawcable.net JOIN :#esoteric < 1271525057 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :alise: what are you trying to do? < 1271525085 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :successive iterations of a relatively naive BF interpreter with a new idea of sorts, aiming to beat the current champion (mazonka's bff4.c with linear loop optimisation) < 1271525089 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :or this specific bit? < 1271525103 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :both < 1271525105 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I'm trying to eliminate the Move instruction by e.g. turning >><+ into a + instruction with the field move = 1 < 1271525126 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :but either the bit that does this combining or the actual interpreter loop's handling of these values is meaning that the tape pointer is being moved in an entirely incorrect way < 1271525131 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :and i can't figure out why < 1271525156 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :* Sgeo_ growls at everyone who uses non-domain-name-based package names <-- for what? < 1271525183 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Android < 1271525189 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :okay < 1271525196 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :to be general, java < 1271525272 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :alise: maybe you have move and the +/- the wrng way around < 1271525282 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : case '>': mov++; break; < 1271525282 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : case '<': mov--; break; < 1271525285 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : #define NEXT ip++; tp += ip->mov; goto *ip->kind < 1271525306 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :no < 1271525310 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :what i mean is < 1271525333 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :the difference btween prefix and postfix ++ is why you;re getting errors < 1271525335 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :or the equivalnet < 1271525396 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :well < 1271525398 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :#define NEXT ip++; tp += ip->mov; goto *ip->kind < 1271525401 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :is the bit that actually does the moving < 1271525416 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :and since i merge the mov modified in the past loop into the instruction done now, the moves come before the instruction < 1271525420 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :ip->kind is what actually executes it < 1271525421 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :err... < 1271525424 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :so clearly the move is in the right place < 1271525440 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :i'm confused < 1271525462 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :why? :) < 1271525532 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :so... ip.mov is how much to move by, and ip.kind is how much to +/- by once you're tehre? < 1271525564 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1271525565 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :there is the issue < 1271525570 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :hmm? < 1271525571 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : if (last && last->kind == Change) { < 1271525572 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : last->val += c == '+' ? 1 : -1; < 1271525572 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : p--; < 1271525575 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :a relic from when i always did p++ < 1271525581 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :but now I have it as a separate macro < 1271525585 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :so that p-- keeps running backwards < 1271525588 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :one step forwards, two back < 1271525591 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :or whatever < 1271525604 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: ip->kind is a pointer to a computed goto label, that contains the relevant code for the instruction that it is < 1271525614 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :? < 1271525634 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :jane@jane-desktop:~/code/bf$ gcc -std=gnu99 -O3 bf6.c -o bf6 < 1271525634 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :jane@jane-desktop:~/code/bf$ ./bf6 < 1271525634 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Segmentation fault < 1271525638 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Well, that is an improvement. < 1271525643 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :jane? < 1271525647 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :(re: use name - not my computer) < 1271525648 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :*user < 1271525652 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :(haven't unpacked mine yet :P) < 1271525656 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :aah < 1271525660 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :recently moved. < 1271525667 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :germany? < 1271525677 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :er, no :) < 1271525680 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :not country < 1271525696 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :well i have it back to sitting there doing nothing useful now... < 1271525698 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :turns out that wasn't my bug < 1271525700 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :or, wait, was it? < 1271525700 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1271525705 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :a-HA! < 1271525725 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :nope ... not that either < 1271525732 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :OH OF COURSE! < 1271525739 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : if (last && last->kind == Change) { < 1271525740 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : p--; < 1271525740 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : p->val += c == '+' ? 1 : -1; < 1271525740 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : } else { < 1271525740 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : p->kind = Change; < 1271525740 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : p->val = c == '+' ? 1 : -1; < 1271525741 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : } < 1271525743 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : ADV; < 1271525747 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :adv advances the ip in the parser, and also sets the mov < 1271525748 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :but get this < 1271525753 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :it sets it < 1271525756 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :and when the last instruction was a change < 1271525758 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :we just add to the value < 1271525761 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :but then ADV OVERWRITES IT < 1271525770 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :oooops < 1271525791 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :now it... still doesn't work! < 1271525798 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :but I'll get there eventually i'm sure < 1271525849 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :alise: Without seeing the code it's obviously guesswork, and I wouldn't feel like looking anyway, but... I guess you 0 mov at all the right places? Have you tried dumping the code you create? < 1271525885 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Dumping the created code I should probably do. < 1271525885 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : #define ADV p->mov += mov; mov = 0; last = p; p++; p->mov = 0 < 1271525886 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :and the place that, I think might be causing "trickiness": < 1271525887 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : if (last && last->kind == Change) { < 1271525888 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : p--; < 1271525888 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : p->val += c == '+' ? 1 : -1; < 1271525888 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : } else { < 1271525888 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : p->kind = Change; < 1271525888 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : p->val = c == '+' ? 1 : -1; < 1271525890 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : } < 1271525892 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : ADV; < 1271525897 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :with the p-- and the need to combine movs and the like < 1271525992 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :apart from that it's just boring set-kind-advance < 1271525996 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :apart from maybe < 1271525997 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Yes, should the p--; p->val += ... part also do something to p->move? I guess not necessarily, since you'll add the current "mov" anyway... or is that in p->mov before p-- at that point? Ah well, I don't quite know your logicks. < 1271525997 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : case ']': < 1271525998 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : p->kind = End; < 1271525998 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : loops[--lp]->val = (long)p; < 1271525998 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : p->val = (long)loops[lp]; < 1271525998 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : ADV; < 1271525999 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric : break; < 1271526001 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :but i don't think that should make a difference < 1271526020 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :fizzie: Well, p-- makes p = what last was before. < 1271526026 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :ADV, later on, expands to adding mov to p->mov. < 1271526030 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :So we should add it anyway, I think. < 1271526032 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Oh! < 1271526039 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :fizzie: Imagine >+>+ < 1271526043 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :We get + with mov=1 < 1271526045 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :then mov=0 < 1271526047 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :we increase mov, mov=1 < 1271526047 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :then + < 1271526050 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :since the last instruction was + < 1271526050 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :we get < 1271526053 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :+ with amount=2 mov=2 < 1271526055 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :this is clearly incorrect < 1271526070 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :we need to stipulate that our current mov is 0, or we cannot combine Changes < 1271526108 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :now it works < 1271526142 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :you know, honey < 1271526160 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :this would be so much easier if i could see your code < 1271526196 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :lol, honey < 1271526206 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: i was considering pasting it, but, you know, too busy tweaking random things and seeing if they work < 1271526259 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :I had an attitude like that with ff3 the other day, but then people pestered me too much about it. Should add that border-tracking there. < 1271526308 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Is ff3 becoming Funge-98 then? < 1271526336 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :So, I now have a 93-line program that runs mandelbrot.b in 15.581s. < 1271526348 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Admittedly, it has a fixed size tape, no bounds checking (but that's okay), and doesn't load in the program from a file yet. < 1271526352 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :But it's only the sixth revision. < 1271526365 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :bf5: 0m17.648s; bf6: 0m15.581s < 1271526372 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :bf1 took ~40s on mandelbrot.b < 1271526381 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :alise: No, I just want less useless nops in the wrapping: http://pastebin.com/00xjESHr < 1271526415 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Say; there isn't any Brainfuck benchmark. < 1271526445 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :I don't know of any, which is a shame, because with the ^bf thing that'd work as a rudimentary Befunge benchmark too. < 1271526490 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :How about calculating A(3, 20)? < 1271526499 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :8,388,605 is big but not too unwieldy to manipulate with brainfuck. < 1271526522 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Of course, that would be most useful with already-fast interpreters. < 1271526577 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :And then perhaps outputting the result in base-10. < 1271526606 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :http://mozaika.com.au/oleg/brainf/ ;; some "sort of benchmark" programs < 1271526684 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :Hmm... Wonder where I calculated wrong: I got that "output" of that big number BF program would be 2^(2058 + 2^2059)... < 1271526778 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Maybe he got it wrong. < 1271526833 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :bf6 takes 34.845s to run long.b; not so good. < 1271527003 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Ilari: http://www.iwriteiam.nl/Ha_bf_numb.html#lbl < 1271527005 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :erm < 1271527006 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :http://www.iwriteiam.nl/Ha_bf_numb.html < 1271527009 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :explains the algorithm behind the program < 1271527047 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :0m31.911s to run si ! si ! hi123; not very fast < 1271527069 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I think I'll merge +-s into the surrounding instructions, and then perhaps think about optimising >>x<<, and then do linear loops < 1271527130 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Hmm. < 1271527193 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I can't just have the variables mov and chg, because then I can't distinguish +> and >+. < 1271527280 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :Anyway, for 5 +'s, I get that number would be bigger than 2^2^2^2059. < 1271527280 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :A(m,n) ? < 1271527289 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: ackermann function < 1271527301 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :? < 1271527301 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :http://en.wikipedia.org/wiki/Ackermann_function < 1271527308 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :you know, grows extremely quickly < 1271527315 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :computable but not primitive recursive -- the first such function found < 1271527325 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :good grief < 1271527343 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :A(4,4) = 2^(2^(2^65536)) - 3 < 1271527374 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :A(3,20) is the more manageable 8,388,605 < 1271527380 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :but it'll still take a while to compute... < 1271527459 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Seems easy to express in Haskell < 1271527465 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :What, ackermann? < 1271527467 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Of course it is. < 1271527468 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Although the trivial way is probably not efficient < 1271527479 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION wonders what the big-O of ackermann is
< 1271527497 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: Efficient doesn't matter; beyond very small values you can't fit the result into the universe, or indeed any nearby universes, anyway < 1271527558 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Sure I can. < 1271527562 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :For A(20, 20), the result is simply A(20, 20) < 1271527602 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :Isn't ackerman function fairly easily describable in terms of hyper function? < 1271527622 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Ilari: Yes. < 1271527633 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Hyper function isn't primitive recursive either. < 1271527641 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: That is not the result, that is a symbolic representation of the result. < 1271527648 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :"... Solve for n." "n = n" < 1271527672 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :The /result/ has to be some primitive notion: what it actually returns, such that it cannot be reduced further. < 1271527845 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Hrm, this is awfully confusing results: http://pastebin.com/KrSjfAgS < 1271527880 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :fizzie, is it? < 1271527901 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: Yes, because of the last number. < 1271527965 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :What's the length of BF program that loads first cell with number at least g64 and leaves the rest zero? < 1271527974 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :The difference between -DPF_X=15 -DPF_Y=1 and -DBOUNDARY_TRACKING for the actual time-wasting loop part in benchmark.bef is that for -DPF_X=15, in the wrapping instruction -- ip += PF_DELTA(0, -pf_box_w, 0); IP_GOTO; -- pf_box_w is a compile-time constant, whereas for -DBOUNDARY_TRACKING it's a file-scope "static int pf_box_w". < 1271527989 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :You wouldn't normally assume a compile-time constant be slower to subtract than a variable value. < 1271528233 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :fizzie, heh indeed < 1271528250 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :fizzie, run more timings and see if they agree < 1271528294 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :I ran the benchmark a couple of times, and it seems to be constantly close to those numbers. The actual moving of boundaries on 'p' isn't done yet, so I can't run anything very complicated. < 1271528297 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :rot13 should work. < 1271528321 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :how goes jitfunge? < 1271528355 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :I've been sick, man! Or possibly just "sick man". Getting better now, though; will see if I get some jitfungey done tomorrow. There's that bug I was chasing still there. < 1271528377 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah < 1271528402 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :fizzie, where can I svn/bzr/hg/darcs/cvs it from? < 1271528413 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :(did I miss any major ones?) < 1271528433 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :no love for git? < 1271528445 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I like this style of development. Write a really stupid program with 1 appended to its name, then copy it, increment the number and improve on it. Only advance to a higher number if the current revision is better than the past, by whatever metric you're going for. < 1271528451 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: AnMaster really, really hates git. < 1271528455 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :to the point of religious zealotry. < 1271528467 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :pineapple, ah I missed that. And no I don't love it < 1271528473 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :should i ask? < 1271528475 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :bzr for me :) < 1271528481 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :pineapple, ask for what? < 1271528498 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: no < 1271528498 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :It's a nice miss, given that git is where everything else (public) of mine is. jitfunge's not shared yet, though. < 1271528500 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :...why you don't like it < 1271528504 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: fuck! < 1271528507 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :now you've got him going < 1271528512 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :prepare for an hour of inanity < 1271528528 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :pineapple, horrible user interface. Hard to remember commands. Confusing approach at version control. < 1271528532 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :The only thing I know about Git is that there's GitHub < 1271528543 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :alise: that's what /ignore is for, should i fee it necessary < 1271528554 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :feel* < 1271528561 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :pineapple, transitioning from svg to bzr was easy. bzr -> hg was somewhat easy. git is just very alien to me < 1271528576 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :fair enough < 1271528590 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Hrm, http://pastebin.com/caKbRGzh is the generated assembly with static and tracked boundaries; just based on the number of instructions one would think the first faster, but of course that's a singularly unreliable way of measuring speed. Still. < 1271528591 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION would probably use TortoiseGit
< 1271528595 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: As long as you don't point out that you're ignoring AnMaster every 5 seconds or whenever you miss a line of his, like he does with me. :-) < 1271528611 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric ::-P < 1271528616 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :pineapple, I find darcs easier, and darcs isn't remotely similar to any other the other ones I find. < 1271528633 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :i only have experience with svn < 1271528642 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Huh; doing increments/decrements before moves in the queuer thing makes performance only slightly worserer than the previous version. < 1271528649 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :bbl < 1271528672 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :So, that bf7 attempt failed. < 1271528686 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :That's really strange. For that fixed-size block, it's decided to replace those jmp *%rax's with jmp .L281, where .L281: jmp *%rax. < 1271528690 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Oh well, sauna-time. < 1271528692 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :oh btw I just checked the logs to see what alise said that caused that comment on /ignore up there... "10:23:15 pineapple: As long as you don't point out that you're ignoring AnMaster every 5 seconds or whenever you miss a line of his, like he does with me. :-)" <-- not remotely true. < 1271528694 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :bbl < 1271528710 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Oh, he just can't get enough of me. < 1271528713 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I know you truly love me <3 < 1271528718 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :yawn < 1271528730 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: How about either you stop ignoring me or you don't fucking respond to things I say < 1271528854 0 :Mathnerd314!unknown@unknown.invalid QUIT :Quit: ChatZilla 0.9.86-rdmsoft [XULRunner 1.9.2.2/20100316074819] < 1271528858 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :The question is, what low-hanging fruit are remaining before I take the plunge and do linear loop optimisation... < 1271528942 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :"If you're receiving this automated message, you moderate at least one popular reddit community" < 1271528944 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I do? I wasn't aware... < 1271528948 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION reads fiction instead of doing homework
< 1271528952 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :alise, what's the message? < 1271528957 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :alise, the mspaint one? < 1271528962 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :If you're receiving this automated message, you moderate at least one popular reddit community. Thanks for your contribution to the site, and congratulations on your success. Please subscribe to /r/modnews, a place we've set up for announcements of interest to moderators. Only the reddit admins can post links there, so it shouldn't clutter up your front page too much. < 1271528966 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I guess it's probably mspaint < 1271528972 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :but I don't really know how many posts that gets... < 1271529060 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :RedditNomic(/r/nomic/) < 1271529060 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Yeah, this is a crap idea. < 1271529069 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :What was I thinking? < 1271529083 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :alise, forbidden < 1271529085 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Huh, mspaint is reasonably popular. < 1271529239 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I don't suppose there are any general loop semantics faster than < 1271529240 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :loop: if (!tape[tp]) ip = (void *)ip->val; NEXT; < 1271529240 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :end: if (tape[tp]) ip = (void *)ip->val; NEXT; < 1271529240 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :.. < 1271529242 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :*... < 1271529243 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Hmm. < 1271529248 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :alise, do you know why I can't get to /r/nomic ? < 1271529256 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: dunno. it has 0 subscribers, strangely < 1271529259 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :not even i am subscribed < 1271529271 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :alise, for me, it just says forbidden (reddit.com) < 1271529279 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :dunno < 1271529284 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :maybe i set it private < 1271529597 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :http://pastebin.com/raw.php?i=W4G2jwzU Can anyone think of a way to improve this interpreter that /isn't/ optimising balanced loops? :-) < 1271529704 0 :alise_!~alise@212.183.140.51 JOIN :#esoteric < 1271529910 0 :alise!unknown@unknown.invalid QUIT :Ping timeout: 258 seconds < 1271529939 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Hmm; if I can have a five-megabyte program, I can have a five-megabyte tape. < 1271530030 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :optimizing balanced loops? < 1271530033 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :How do you do that? < 1271530047 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Also: alise_, what do you think of Scala? < 1271530130 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Scala appears to me to be a hodgepodge of features, none particularly cohering too well with each other; and the OOP parts do not really add anything. I gather that this is considered a common misconception about Scala by some very smart people who like Scala, though. Mainly I abandoned Scala because you had to use, not only the tedious Java toolchain, but some extra build-system related quirks are there if you use Scala; at least when I used it there wer < 1271530130 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :e. That was using, I think, not the most recommended build tool for Scala though. < 1271530139 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :If you're already using Java, using Scala would be absolutely fine. JRuby and Jython too. < 1271530179 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Is that a copy/paste? < 1271530197 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: Optimising balanced loops - [>>+<[>+<]<<+>] is p[2]++; p[0] = 0; p[-2]++; < 1271530209 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :You can do this for every nested loop structure with matching > and <. < 1271530229 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: no, I wrote it now < 1271530781 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :alise_: Yes, Scala is very much a thing to make Java programming nicer from what I've seen. < 1271530798 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Worthwhile if you've already got reasons to be in Java, not worth it otherwise. < 1271530833 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION really needs to learn that he can like multiple languages
< 1271530841 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: Hah. < 1271531077 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Anyone have a working clang compiler? pikhq? < 1271531090 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :I do. < 1271531160 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Would you be so kind as to compile a lil' 64-bit binary with high optimisation for me? I'm thinking clang might have the wisdom to beat gcc on my current version. < 1271531203 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :http://pastie.org/924802.txt?key=9hndhxn9dpruigx3zxg bf7.c < 1271531206 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :http://pastie.org/924803.txt?key=drcs7zwkn7w5buut0xzl9g the requisite mandelbrot.h < 1271531220 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I'd install clang but I'm on an old version of Ubuntu with only a mobile internet connection. < 1271531231 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Just a bit. < 1271531272 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Any prefered -march=? < 1271531291 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Also, -fwhole-program, correct? < 1271531301 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Yeah, whole program. And, this is an... /me looks it up < 1271531307 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :*a < 1271531380 0 :alise__!~alise@212.183.140.35 JOIN :#esoteric < 1271531395 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : Also, -fwhole-program, correct? < 1271531397 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :? < 1271531403 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : Yeah, whole program. And, this is an... /me looks it up < 1271531403 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : *a < 1271531403 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : ...an AMD Athlon 64 X2 5200+. < 1271531403 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : So I guess just dual-core Athlon 64. < 1271531403 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : Not sure what march that is. < 1271531410 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Okay, then. < 1271531414 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :-march=k8 it is. < 1271531468 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Filebinning. < 1271531477 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :There's very little to the program, really, so I don't expect it to do /vastly/ better. < 1271531486 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :http://filebin.ca/jnad/a.out < 1271531567 0 :alise_!unknown@unknown.invalid QUIT :Ping timeout: 258 seconds < 1271531641 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :http://pastie.org/924812.txt?key=bq9xhffo89frcoacjgqr0w ;; I hope that bf7 being very, very slightly slower than its predecessor on average is just coincidence in my measurings. < 1271531646 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Because, really, < 1271531648 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :- p--; < 1271531648 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :- p->val += c == '+' ? 1 : -1; < 1271531648 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :+ last->val += c == '+' ? 1 : -1; < 1271531651 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :and only running ADV if we need to < 1271531654 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :should be a speed up if anything < 1271531658 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :and < 1271531659 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :- #define ADV p->mov += mov; mov = 0; last = p; p++; p->mov = 0 < 1271531660 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :+ #define ADV p->mov = mov; mov = 0; last = p; p++ < 1271531663 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :almost certainly either does the same thing, or less < 1271531755 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: Congratulations. Your computer produces far better code for my computer than my computer does. < 1271531772 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Hooray. < 1271531774 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :11.314s, vs average of 15.000 to 15.350 for mine. < 1271531783 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :You shaved off ~4 seconds. Fuck yeah, clang. < 1271531793 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :BTW, -O3 -march=k8 -msse3 should be good "absurdly good" flags for your computer. < 1271531806 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :-O2 -march=k8 -msse3 should be sane ones. < 1271531864 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Hey, gcc does -fwhole-program too. < 1271531867 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Or does -O3 automatically do that? < 1271531873 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :It doesn't. < 1271531883 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :For this program, -fwhole-program as well. < 1271531888 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Hmm... no loops to unroll that wouldn't be cheating (unrolling the parsing loop would be cheating; the program is currently a constant string) < 1271531902 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :BTW, -fwhole-program will break not-small programs. :) < 1271531906 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :No fucking clue what most of the -f options do. < 1271531918 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: This program will grow to at most a couple hundred lines ;-) < 1271531925 0 :olsner!unknown@unknown.invalid PRIVMSG #esoteric :what does whole-program do? < 1271531935 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :olsner: assumes that nothing will link with it < 1271531941 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :and so basically fucks everything into one great big ball of mud < 1271531953 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :then smashes it with a hammer so that it looks like the pure operations that need doing, nothing more < 1271531960 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :olsner: -fwhole-program tells the compiler that the only symbol that will be exported is main. < 1271531960 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :you can see how this would cause problems on complicated programs. < 1271531966 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: Also that. < 1271531980 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: Why SSE? I can't think of a single thing in my program that would be helped by SSE. < 1271532000 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :alise__: Oh, that's just because your CPU supports -msse3. < 1271532007 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :XD < 1271532031 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :The -march flags will turn on most of the supported such extensions, but your CPU supports SSE3 and -march doesn't tell the compiler that. < 1271532035 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Just a habit. ;) < 1271532067 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I wonder if -Os might not help here; the programs are very small (bf7 is just 93 lines), and the actual tight main loop is all manual computed gotos, so there's not many clever optimisations to be done there. < 1271532075 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :So having everything fit in the computer's nice little pocket could help. < 1271532086 0 :olsner!unknown@unknown.invalid PRIVMSG #esoteric :ah, right... -fwhole-program wouldn't really be needed if it wasn't so fiendishly complicated to tell a C compiler/linker/etc system exactly what needs to be exported < 1271532097 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: -fwhole-program -march=k8 -msse3 don't seem to have improved bf7 performance any, which supports my hunch that it can't optimise my awesomeness. < 1271532109 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :also it bloated the size of the binary by like 500 :P < 1271532112 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Your program is already small enough to fit in the whole cache. < 1271532115 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :now they're all 24k < 1271532119 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Okay, GCC sucks. :) < 1271532120 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :as opposed to ~13k < 1271532125 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :cool < 1271532129 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :I never knew about -fwhole-program < 1271532132 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION tries -Os
< 1271532141 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Now they're all 23K. < 1271532154 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :alise__: Strip, man, strip! < 1271532156 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :How queer; they won't go smaller. < 1271532167 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :olsner: The link-time optimiser that GCC and Clang have should help with that. < 1271532169 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Will -fwhole-program work with, or against, -Os? < 1271532177 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I assume -march=k8 is fine to use with it. < 1271532177 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :alise__: With. < 1271532179 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :what are you trying to accomplish? < 1271532186 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: Me? < 1271532193 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :And yes, -march=k8 is just fine. < 1271532194 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :A brainfuck interpreter faster than bff4 with linear loop optimisation. < 1271532212 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :you're compiling brainfuck to C? < 1271532215 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :No. < 1271532217 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Interpreting. < 1271532221 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1271532224 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Compiling, esotope has already cornered that market. < 1271532229 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :It compiles hello world to a constant output, after all. < 1271532234 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :When interpreting, optimisations cost. < 1271532237 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Post-stripping, an -Os'd bf7 is 19K. < 1271532251 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Let's see how fast it goes. Brrm brrm! < 1271532266 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :This is all just tactics to avoid working on the linear loop optimisation :-) < 1271532317 0 :wareya!unknown@unknown.invalid PRIVMSG #esoteric :am I stupid for trying to cast a file to a string in C? < 1271532333 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :wareya: Intensely. < 1271532337 0 :wareya!unknown@unknown.invalid PRIVMSG #esoteric :okay < 1271532337 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :$ ./bf7 >/dev/null; time ./bf7 >/dev/null < 1271532338 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :real 0m20.730s < 1271532338 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :user 0m20.661s < 1271532338 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :sys 0m0.052s < 1271532342 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Conclusion: Bad -Os; bad! < 1271532368 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I'd love to see the assembly for this thing. Computed gotos can't be pretty. < 1271532376 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :-S < 1271532391 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Yep. < 1271532400 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :-O3 restores everything back to its original glory. < 1271532403 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :And at 19K, too. < 1271532419 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Oh, I know... < 1271532433 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Clang seems to handle computed gotos *much* better than GCC. < 1271532446 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Ah. < 1271532458 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :Clang version? < 1271532460 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :http://pastie.org/924802.txt?key=9hndhxn9dpruigx3zxg Anyone know if I can initialise blueprints without having to call interp? < 1271532465 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :After all, clearly it can be done in asm. < 1271532469 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant: 2.6. < 1271532480 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :That's interesting, then < 1271532505 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :Given that 2.6 doesn't support indirectbr :-P < 1271532532 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Still handles it better. < 1271532580 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I can't just put the declaration of blueprints inside interp, can I? < 1271532582 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :No, I suppose not. < 1271532582 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :2.6 just lowers indirect gotos to switches < 1271532583 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Hmm. < 1271532587 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :And I can't assign an array literal like that. < 1271532596 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :So it makes me wonder what GCC must be doing there, if that's better < 1271532601 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant: Well, maybe that would turn out faster. < 1271532618 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Since theoretically the indirect goto has an "unknown" destination, not just one-of-a-few-cases. < 1271532623 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :So we have to jump "generically", not specialisedly. < 1271532635 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :The only reason computed gotos are faster with gcc is that it sucks at switches, and a switch makes it jump more. < 1271532684 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : #define NEXT ip++; tp += ip->mov; goto *ip->kind < 1271532685 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :compiles to < 1271532689 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : leaq 24(%rcx), %rax < 1271532689 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : movq %rcx, %r8 < 1271532689 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : xorl %esi, %esi < 1271532689 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : jmp .L12 < 1271532691 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :with gcc < 1271532719 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :*Gah*, that's right. GCC is merging the tails of all that. < 1271532720 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Some of them have code I don't even know what it does, though. < 1271532729 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :So it can have a single indirect jump instruction. < 1271532732 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :"Because". < 1271532737 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :L12 is just < 1271532740 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :.L12: < 1271532740 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : movq %rax, %rcx < 1271532740 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :.L2: < 1271532740 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : movzbl (%rdi), %edx < 1271532741 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : incq %rdi < 1271532743 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : testb %dl, %dl < 1271532745 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : je .L23 < 1271532747 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : leal -43(%rdx), %eax < 1271532749 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : cmpb $50, %al < 1271532751 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : ja .L20 < 1271532753 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : movzbl %al, %eax < 1271532755 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : jmp *.L11(,%rax,8) < 1271532757 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :which is, you know, longer than I'd like for threaded code < 1271532759 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :also there is an awful lot of .quads around here < 1271532761 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: Can I disable that? < 1271532789 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :alise__: I've been trying to. < 1271532794 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :I dunno how. < 1271532870 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :In the next revision, or at least in the next few, I'm going to have to bite the bullet and implement linear loop optimisation. < 1271532878 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :When I do that I should beat least competitive with bff4lnr. < 1271532884 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Hopefully, I'll be able to beat it. < 1271532902 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Here's what I'm up against: http://mozaika.com.au/oleg/brainf/bff4.c compiled with -DLNR. < 1271532922 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Of course, it will be cheating until I add loading a program somehow, and then an automatically growing tape. < 1271532933 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I have a feeling malloc will slow my program down immensely; right now I don't use it at all. < 1271532943 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Perhaps I will mmap some ridiculously large space instead, and depend on overcommitting. < 1271533028 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :doing it in hardware ftw! < 1271533044 0 :lament!unknown@unknown.invalid QUIT :Quit: lament < 1271533116 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :you could mmap a bunch of contiguous pages, mark the last one PROT_NONE, and install a SIGSEGV handler to grow the space < 1271533156 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :That seems... Awful. < 1271533170 0 :olsner!unknown@unknown.invalid PRIVMSG #esoteric :besides, isn't that exactly what the kernel does internally if you just mmap the whole free address space? < 1271533184 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Something like that, I think. < 1271533190 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: Hey, there's a library to handle segfaults. < 1271533194 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Not that I'd use it; too much overhead. < 1271533198 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :But it would work, yeah. < 1271533202 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :that's not necessary at all < 1271533205 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :just sigaction < 1271533208 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :yeah < 1271533212 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :it's cleaning up afterwards that's the problem < 1271533213 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :olsner: the kernel will likely do it faster though, won't it? < 1271533216 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :as for mmaping the whole space, I don't know :p < 1271533246 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :isn't it likely to reserve a whole lot of physical memory? or does it not do that until the memory is actually used < 1271533248 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :The advantage of the SIGSEGV solution is that it would work even with overcommit turned off. < 1271533250 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: no, it doesn't < 1271533254 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Linux always grants a request for memory < 1271533261 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :as long as it's within certain (ludicrous) bounds < 1271533264 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :or wait < 1271533268 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :you can't ask for more than you have < 1271533271 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :but you can ask for what you have, twice < 1271533275 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :it'll grant both immediately < 1271533281 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :then it only actually grabs the memory when you need it < 1271533284 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :this is why it needs the OOM killer < 1271533294 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :a program gets some memory, uses it, suddenly we can't give it the memory we've already told it we have < 1271533296 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :yes, but it could also allocate some memory to you in the assumption yuou're about to use it < 1271533299 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :who's the culprit? who's hogging our memory? < 1271533300 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :KILL! KILL! < 1271533306 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :but I'm wrong about that so k :p < 1271533313 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: I've done it before and it doesn't actually reserve much memory at all < 1271533314 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :if any < 1271533314 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :...or swap. < 1271533328 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :http://pastie.org/924840.txt?key=jhefhf0gduvence49befva Look for low hanging fruit, feeble-minded slaves! < 1271533343 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :comex: malloc almost *cannot* fail on Linux. < 1271533351 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I bet using the C stack is faster than maintaining my loop stack. < 1271533357 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Unless you turn off overcommitting. < 1271533362 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :alise__: why would it be faster? < 1271533365 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :alise__: Yes, the C stack is very fast. < 1271533377 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: what pikhq said < 1271533377 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :oh, wait < 1271533386 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :x86 has dedicated opcodes for pushing on the stack < 1271533387 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :fine:p < 1271533389 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I'm doing lots of manual stack operations for something that C compilers are optimised to do millions of times a second < 1271533393 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :and processors < 1271533427 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :the question is whether processors actually treat *SP specially < 1271533435 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :They do. < 1271533458 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :C stack handling is *absurdly* fast on x86. < 1271533511 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :eh, bf7 will be a cleanup revision < 1271533513 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :onto bf8 < 1271533517 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :i'll do the stack thing < 1271533540 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :otoh, if you mean using recursion for loops, you are wasting some stack space < 1271533540 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :this is just like using a version control system, but nicer :P < 1271533547 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :nah < 1271533549 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :for the stack of loops < 1271533551 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :for the return address etc < 1271533553 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : case '[': p->kind = Loop; loops[lp++] = p; ADV; break; < 1271533554 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : case ']': < 1271533555 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : p->kind = End; < 1271533555 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : loops[--lp]->val = (long)p; < 1271533555 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : p->val = (long)loops[lp]; < 1271533555 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : ADV; < 1271533556 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : break; < 1271533558 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : } < 1271533560 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :also not if your compiler optimises that < 1271533577 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION wonders how to write the above using recursion
< 1271533586 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :never heard of a compiler optimizing that :p < 1271533592 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :gcc optimises tail recursion. < 1271533601 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :well, I may be thinking of a different implementation than you < 1271533607 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :that would definitely not be tail recursion < 1271533614 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :it wouldn't be in this case < 1271533619 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :but it'd be better than using my manual stack < 1271533622 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :All recursion can be turned into iteration [unless it's just tail recursion]. Can all iteration be turned into recursion somehow? < 1271533624 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :if you feel like being a jerk, you could use inline asm to push/pop :p < 1271533647 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :All recursion can be turned into iteration [unless it's just tail recursion]. < 1271533648 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :false < 1271533650 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :that would probably be the fastest, but I doubt there's a way to do that in C < 1271533650 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :you have to use a stack < 1271533656 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :which is basically just recursion < 1271533661 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: and the answer is yes < 1271533664 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :iteration is just tail recursion < 1271533725 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :one thing you could do is do a loop beforehand that converts non-BF characters to some known character < 1271533758 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Why? < 1271533762 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I just completely ignore non-BF chars. < 1271533776 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :then you could optimize the switch statement because you know all characters are one of 8 characters < 1271533789 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :[About Ubisoft] "They're actually trying to stop piracy. If the servers stay down, it's impossible for the pirates to track communication between client and server in order to get the data they need to fully crack the game. So, if they keep the servers down forever, the game will be never be cracked!" < 1271533792 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :that would probably simplify the machine code significantly and avoid a branch < 1271533793 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :http://www.fark.com/cgi/comments.pl?IDLink=5216097 < 1271533802 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :well, maybe about the branch :p < 1271533852 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: oh, I'm not optimising the parser yet < 1271533876 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :The parser should be the quickest thing you deal with. < 1271533878 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1271533879 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : case '[': p->kind = Loop; loops[lp++] = p; ADV; break; < 1271533879 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :what I really want to do here is parse the current s < 1271533882 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :to get the loop result < 1271533888 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :btw, I wouldn't be surprised if it runs faster in 32-bit mode < 1271533892 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Like, "parse all of LostKng in a few fractions of a second". < 1271533893 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: yes, probably < 1271533906 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :comex: My experience has been "no". < 1271533907 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1271533913 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: then it makes sense to preprocess for faster runtime < 1271533914 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I need to have parse return, not modify a global variable < 1271533931 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :parse gives me a headache :p < 1271533934 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :parse : str -> op* < 1271533937 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: what, mine? < 1271533939 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :it's simple < 1271534004 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :oh wait < 1271534007 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :I'm misunderstanding your code < 1271534012 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric ::p < 1271534025 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Admittedly I have not wrote for clarity much. < 1271534032 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I think parse is quite nice code though. < 1271534037 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :uh, maybe. < 1271534046 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :how... < 1271534052 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :parse is running once, beforehand, right? and then interp? < 1271534060 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1271534066 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :parse starts at prog < 1271534069 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :then advances onwards < 1271534071 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :oh, End actually stores hwere it is going < 1271534074 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1271534077 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :jesus. < 1271534082 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :and then modifies the Start to point to the End < 1271534083 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :jesus what? < 1271534116 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :also, mov could be a short < 1271534173 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :To what avail? And what if you had more <>s than that in a row? < 1271534194 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Unlikely but not almost impossible in the way overflowing the int is. < 1271534200 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :well the tape is only 65536 long eh? < 1271534208 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :such a thing would overflow the tape anyway < 1271534208 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Well, true. < 1271534217 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :But it can be increased, and will be dynamically sized later. < 1271534223 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I don't think shorts would be stored more efficiently on most machines, anyway. < 1271534294 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :fwiw 'val' could also be 32-bit if it's an offset from prog instead of a pointer < 1271534298 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :but I guess that wouldn't be much gain < 1271534335 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :the arithmetic would make it worse on the whole < 1271534351 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Loops would be faster if their pointers pointed to the instructions /after/ the loop instructions. < 1271534359 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :I don't believe that without a test :p < 1271534360 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :That way, we could do less work than the general NEXT; we could skip ip++. < 1271534368 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :jane@jane-desktop:~/code/bf$ ./bf8 < 1271534368 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Segmentation fault < 1271534370 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Well, it is a start. < 1271534375 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :(bf8 is the recursive-parser version) < 1271534382 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :heh < 1271534413 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :well you should definitely use a pointer to tape + tp that changes, instead of indexing every time < 1271534417 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :though maybe the compiler does that ofr you < 1271534423 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :for that matter, what if you make rsp = &tape[tp] < 1271534502 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :using the syntax that lets you reserve a register for a variable < 1271534502 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: actually i used a pointer to tape + tp < 1271534503 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :it was slower < 1271534504 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I measured it < 1271534507 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :huh. < 1271534517 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: I think because the compiler can optimise the array access because it knows tape is static < 1271534522 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :whereas a pointer could be any old thing < 1271534544 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :wouldn't the same apply to indexing prog :p < 1271534554 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I tried that too. Slower. < 1271534565 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :mm < 1271534566 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I think because prog already has the indirect jump magic, so it doesn't help much, and the overhead of the indexing wins out. < 1271534572 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :can I have a copy of mandelbrot.h? < 1271534574 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :I want to try something < 1271534591 0 :BeholdMyGlory!~behold@unaffiliated/beholdmyglory JOIN :#esoteric < 1271534617 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :.h ? < 1271534623 0 :olsner!unknown@unknown.invalid PRIVMSG #esoteric :alise__: it should be obvious from the assembly if it actually does (optimize indexing) < 1271534631 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :and the compiler flags even :p < 1271534634 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :if you don't mind < 1271534637 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: it's just mandelbrot.b without newlines enclosed in "" < 1271534638 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :so I can do < 1271534642 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : char *code = < 1271534643 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :#include "mandelbrot.h" < 1271534643 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : ; < 1271534648 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: of bf7, presumably, since that one actually works < 1271534653 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :bf8 is just my tweak-parser version < 1271534660 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :sure, I was using the one on pastie < 1271534670 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I think that is bf7. < 1271534690 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Here is mandelbrot.h. < 1271534694 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :http://pastie.org/924867.txt?key=y1tsv0fos2dcg2ku9rkqw < 1271534697 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Compiler flags I use: < 1271534709 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :-O3 -march=k8 -msse3 -fwhole-program < 1271534713 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :then afterwards, strip -s it < 1271534724 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Change the march if you're not on AMD Athlon or similar, of course. < 1271534730 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :core2, if you're on Core 2. < 1271534738 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :(why not just -march=native?) < 1271534747 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Because pikhq did it at first :P < 1271534761 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :you're using clang or gcc? < 1271534762 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :what does mandelbrot.b do? < 1271534795 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: gcc. pikhq did it with clang and got significant (many seconds) improvement < 1271534798 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: ascii art mandelbrot set renderer < 1271534805 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :a good benchmark < 1271534824 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :book.c:41: warning: comparison is always false due to limited range of data type < 1271534851 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :(getchar) < 1271534852 0 :kar8nga!~kar8nga@jol13-1-82-66-176-74.fbx.proxad.net JOIN :#esoteric < 1271534853 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :and EOF < 1271534859 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :er right < 1271534862 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :it still works though < 1271534864 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I wonder why < 1271534867 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :even with ,[.,] < 1271534895 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :yep clang is faster for me too < 1271534925 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :slightly faster with -m32 < 1271534952 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :changing mov to short has no effect < 1271534977 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :maybe a very slight improvement < 1271534993 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :By low hanging fruit I meant codewise, not typewise. :-) < 1271535062 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :if you insist. :p < 1271535112 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :I get a significant improvement using a pointer instead of tape[tp] < 1271535136 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :on core2 who knows if you're different < 1271535165 0 :jcp!unknown@unknown.invalid QUIT :Ping timeout: 264 seconds < 1271535282 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :-fomit-frame-pointer is also an improvement < 1271535300 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :what /is/ the frame poitner anyway? < 1271535305 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: hmm really? plz post timings for pointer < 1271535306 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :and also code < 1271535374 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :The frame pointer points to a location in the stack frame :-P < 1271535391 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :http://pastie.org/private/f9etyzhaoucns4mm0hfua <- pretty obvious change < 1271535392 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :Typically the return address or thereabouts < 1271535405 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :omitting it makes debugging impossible < 1271535452 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :I've always considered it as more a tool for humans and don't understand why compilers use it by default < 1271535514 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: timings please? < 1271535518 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :i timed it before... < 1271535630 0 :ENKI-][!unknown@unknown.invalid QUIT :Read error: Connection reset by peer < 1271535647 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :it's not that much of an improvement, but definitely there < 1271535670 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :~.025s improvement, 5.214 instead of 5.234 < 1271535676 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :input: if ((tape[tp] = getchar()) == EOF) tape[tp] = 0; NEXT; < 1271535676 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :how come this works? < 1271535676 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :even though the comparison is always false < 1271535676 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :,[.,] works < 1271535679 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :and it should only work with 0 eof < 1271535685 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: measured multiple times yeah? < 1271535691 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :otherwise disk cache and stuff < 1271535693 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1271535710 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :ok, as soon as this new parser works i'll add that < 1271535846 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :no idea about EOF < 1271535940 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :grr < 1271535943 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :this keeps segfaulting and I have no idea why < 1271535970 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :gdb? :p < 1271536061 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant: Did you notice my curious ff3 thing? < 1271536071 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :Don't think so, no < 1271536089 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant: http://pastebin.com/KrSjfAgS < 1271536109 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: gdb is worse than useless. usually :P < 1271536134 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :fizzie: How does boundary tracking work versus PF_X/PF_Y? < 1271536145 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant: Where the difference between -DPF_X=15 and -DBOUNDARY_TRACKING is that for -DPF_X the subtraction of pf_box_x has a compile-time constant argument, whereas for the other it's a file-scope "static int pf_box_x". < 1271536153 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant: Here's the generated assembly: http://pastebin.com/KrSjfAgS < 1271536161 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Uh, copypaste mishap. :p < 1271536162 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :fizzie: Wrong link < 1271536178 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant: http://pastebin.com/caKbRGzh I mean. < 1271536207 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :And for the upper, .L281: jmp *%rax; and nothing else. < 1271536210 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :There must be other differences :-P < 1271536221 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :Well, double-jump might do it < 1271536233 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :That snippet is the wrapping function. Of course there are other differences in the code. < 1271536237 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :It's a strange thing to do though. < 1271536248 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Should perhaps try both with clang. < 1271536263 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :After some ice-cream experiences, away a while. < 1271536326 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION steps too far in gdb.
< 1271536327 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :feck < 1271536328 0 :oerjan!~oerjan@hagbart.nvg.ntnu.no JOIN :#esoteric < 1271536359 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :stepi < 1271536434 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric : i guess that answer your previous question, then <-- what was that question? < 1271536440 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :you may never know < 1271536445 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION cackles evilly
< 1271536486 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION keeps doing next 100
< 1271536493 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :oh i think i know how it is segfaulting? < 1271536494 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :maybe < 1271536588 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric : (The simple answer, of course, is that mirrors rotate in the fourth dimension.*) < 1271536599 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION swats alise__ -----###
< 1271536616 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :they swap _back_ with _front_ < 1271536650 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric ::( < 1271536683 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :I tried manually (in the assembly) swapping edi (which clang picked to store ptr) with esp < 1271536687 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :in case it would speed things up < 1271536718 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :admittedly, my assembly was nonoptimal (it used two 'xchg' around each putchar) but that shouldn't make a huge difference; however, the code just slowed down a lot < 1271536799 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Program received signal SIGSEGV, Segmentation fault. < 1271536800 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :0x00000000004005f4 in interp (setup=0 '\0') at bf8.c:39 < 1271536800 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :39 change: tape[tp] += ip->val; NEXT; < 1271536800 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :(gdb) < 1271536800 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :wutters < 1271536850 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :(gdb) print *(op*)*(ip+1)->val < 1271536851 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :$11 = {kind = 0xf00213959058b48, val = -4574530908104654666, mov = -1958210955} < 1271536862 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :ok; I have an end-loop instruction whose val (go back to...) is pointing to random memory < 1271536871 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Understandable enough: < 1271536872 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : case ']': < 1271536872 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : p->kind = End; < 1271536873 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : return p; < 1271536873 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :but < 1271536877 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : q = parse(s, p); < 1271536877 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : q->val = (long)last; < 1271536879 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : last->val = (long)q; < 1271536881 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : p = q; < 1271536884 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :last should always be valid, so how is this happening? < 1271536986 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :$ ./bf8 < 1271536986 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :im jumpin < 1271536987 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :back in da haus < 1271536987 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :im jumpin < 1271536987 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Segmentation fault < 1271536996 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :im jumpin = yo bitch, this is parse() and we got a ], returning nao < 1271537003 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :back in da haus = parse totally gave us some fucking shit < 1271537010 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :so we have an un-haused jumpin. < 1271537024 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I know the brackets are balanced so HOW IS THIS MONSTROSITY < 1271537048 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: if i give you the code, you fix it k < 1271537049 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant: Oh, right, forgot; did try clang earlier, but http://pastebin.com/9qX7qyd5 < 1271537076 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: http://pastie.org/924919.txt?key=djk4pkptyma547uhozx1q < 1271537134 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION procrastinates
< 1271537224 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION swears at the neighbor's barking dog
< 1271537251 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :fizzie: So fix it :-P < 1271537252 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: oh! < 1271537258 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I don't increment s when I recurse < 1271537267 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :ugh, so parse needs to return a tuple < 1271537270 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :or a ** < 1271537272 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :as an argument < 1271537274 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant: I guess it could be something a bit like http://llvm.org/bugs/show_bug.cgi?id=6608 which seems fixed already; I don't exactly use LLVM trunk, maybe I should start. < 1271537274 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :***** < 1271537282 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :oh the pain < 1271537293 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :fizzie, when did you last play Robozzle? < 1271537293 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :so your s is cursed rather than recursed < 1271537308 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :fizzie: You could try llvm-gcc 2.6 as well < 1271537308 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: I would enjoy killing you! < 1271537340 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Now it works but segfaults anyway < 1271537367 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION hands alise__ a potion of holy water
< 1271537401 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: When it was talked about back then; I haven't played since. < 1271537429 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant: I'll try this Ubuntu "llvm-gcc-4.2" thing first, but I guess if I'm serious about jitfunge's llvm side, I should try to get them codes too. < 1271537576 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant: Well, that's better: http://pastebin.com/xQFwEaUu < 1271537789 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :WHY DOES THIS DEFOUL MY PEOPLE. < 1271537846 0 :tombom!tombom@wikipedia/Tombomp JOIN :#esoteric < 1271537999 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Work, blasted computer! Work! < 1271538064 0 :tombom_!tombom@wikipedia/Tombomp JOIN :#esoteric < 1271538176 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION sees another Nexus One ad and starts hyperventilating
< 1271538201 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :AROUSING TELEPHONE < 1271538228 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: MAKE MY CODE WORK < 1271538274 0 :tombom!unknown@unknown.invalid QUIT :Ping timeout: 260 seconds < 1271538351 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :12:21:16 input: if ((tape[tp] = getchar()) == EOF) tape[tp] = 0; NEXT; < 1271538354 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :12:21:16 how come this works? < 1271538365 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :is it possible that EOF % 256 is accidentally 0? < 1271538383 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :no, because it's -1 < 1271538395 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well then it should set it to 255 < 1271538400 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :which it doesn't < 1271538402 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :because ,[.,] works < 1271538414 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: it sets it to -1 actually < 1271538421 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :signed chars < 1271538426 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :oh well < 1271538433 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :maybe this is false somehow, dunno :P < 1271538493 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :!c ((char)(-1) == EOF) < 1271538519 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :!help languages < 1271538520 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :languages: Esoteric: 1l 2l adjust asm axo bch befunge befunge98 bf bf8 bf16 bf32 boolfuck cintercal clcintercal dimensifuck glass glypho haskell kipple lambda lazyk linguine malbolge pbrain perl qbf rail rhotor sadol sceql trigger udage01 underload unlambda whirl. Competitive: bfjoust fyb. Other: asm c cxx forth sh. < 1271538524 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :you need to print < 1271538527 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1271538544 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :!c char c = EOF; if (c) { printf("true\n"); } else { printf("false\n"); } < 1271538546 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :true < 1271538552 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :then ... what? < 1271538564 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :!c printf ("%d", ((char)(-1) == EOF)) < 1271538565 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :1 < 1271538589 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :so it is actually true < 1271538599 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION doesn't like the thought that most apps will come out for the iPhone before Android
< 1271538604 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: then wut. < 1271538614 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: the iphone isn't an option if you have any morals. < 1271538617 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :or coding desire. < 1271538621 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :or lack of $99. < 1271538634 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :alise__: i guess you'll get a bug if you input an _actual_ -1 char, then < 1271538642 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: er... there is no such thing :P < 1271538646 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :oh wait < 1271538646 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1271538659 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :255 < 1271538665 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :getchar returns int < 1271538666 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :so < 1271538670 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :(mod 256) < 1271538680 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :!c int gcr = EOF; char c = gcr; printf("%d\n", c); < 1271538682 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :-1 < 1271538697 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: On the other hand, 255 isn't used in any UTF-8 combination, so if you only use UTF-8 input, you should be safe. < 1271538700 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :!c printf("%d", (char)255) < 1271538700 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :this is really confusing < 1271538702 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :-1 < 1271538720 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :alise__: the printing converts from char to int, preserving sign, obviously < 1271538755 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :The "passing as argument to a vararg function" already converts it to int, doesn't it? < 1271538768 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well yeah < 1271538783 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :!c int gcr = EOF; char c = gcr; if (c) printf("hmm\n"); else printf("WHAT THE FUCK IN THE WORLD\n"); < 1271538784 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1271538788 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :WHAT IS THIS < 1271538833 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :alise__: (char) EOF is not 0 < 1271538838 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I KNOW < 1271538841 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :So why is this happening < 1271538842 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Why does it work < 1271538850 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :input: if ((tape[tp] = getchar()) == EOF) tape[tp] = 0; NEXT; < 1271538850 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :loop: if (!tape[tp]) ip = (op *)ip->val; NEXT; < 1271538851 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :end: if (tape[tp]) ip = (op *)ip->val; NEXT; < 1271538852 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :It undeniably shouldn't work < 1271538855 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :tape[tp] is never set to 0 < 1271538864 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Hmm, it IS unsigned char < 1271538870 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :!c int gcr = EOF; unsigned char c = gcr; if (c) printf("hmm\n"); else printf("WHAT THE FUCK IN THE WORLD\n"); < 1271538871 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1271538879 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :WHAT DO YOU WANT FROM ME, COMPUTER?! < 1271538904 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :alise__: er wait tape is _unsigned_? < 1271538913 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i just had an explanation if it was signed :( < 1271538915 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Well, it didn't use to be! < 1271538919 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: what's the explanation? < 1271538927 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :TOGETHER SCIENCE WILL UNLOCK THIS MYSTERY, & ALL OTHER MYSTERIES AFTER IT < 1271538942 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :(== converts char back to int, preserving sign, so (char)(-1) is actually compared as (int)(-1) < 1271538946 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :) < 1271538954 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :and < 1271538956 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :? < 1271538963 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :gcc even tells me the comparison can't be true < 1271538966 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :to EOF, which is also (int)(-1) < 1271538969 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: clever, though < 1271538973 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :maybe i should make it signed < 1271538977 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :wait < 1271538979 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :maybe ,[.,] doesn't work < 1271538982 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :i only tested it with bf1 < 1271538985 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :then made it unsigned < 1271539008 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :!c printf("%d", (char)(-1) == (int)(-1)) < 1271539010 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :1 < 1271539014 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :is char defined to be signed, or undefined either way? < 1271539016 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :!c printf("%d", (unsigned char)(-1) == (int)(-1)) < 1271539017 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :0 < 1271539025 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :heh with char the warning disappears < 1271539032 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION is afraid that part of the reason he wants N1 is to show off and counter the iPhone stuff
< 1271539042 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: so what < 1271539045 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :*might be < 1271539053 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Of course it disappears; if tape[tp] is signed, it can never be == -1, while if it's signed, it can. < 1271539069 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1271539070 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :but I mean < 1271539072 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :i didn't even realise < 1271539075 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :that ,[.,] was broken :) < 1271539079 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :because of that < 1271539090 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :so is char defined to be signed? iirc i read that it was undefined < 1271539104 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Implementation-defined, isn't it? Can't quite recall. < 1271539172 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i vaguely recall it's implementation-defined < 1271539199 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Maybe you should just do the input part right (something like "t = getchar(); tape[tp] = (t == EOF ? 0 : t);" with an int t); if you map the 257 possible return values (-1, 0, .., 255) of getchar() into a type that can hold 256 values, you'll undoubtedly have problems distinguishing two of them. < 1271539213 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :fizzie: But that is slower. < 1271539225 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :in the incredibly common case that t != EOF < 1271539234 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Why would it be slower than writing a bogus value to tape[tp], then testing? < 1271539248 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :when == EOF, it's the same < 1271539249 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :but < 1271539251 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :input: if ((tape[tp] = getchar()) == EOF) tape[tp] = 0; NEXT; < 1271539255 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :with yours < 1271539260 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :we have to set t and then set tape[tp] < 1271539265 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :with ours, it's only one assignment < 1271539268 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :*mine < 1271539286 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :The compiler is not going to start sticking t into memory somewhere. < 1271539300 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :You can't really count the =s and say "this is slower, it has more of 'em". < 1271539323 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Okay, fine. :P < 1271539338 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Though you might want to put a { int t = getchar(); ... } block around to make sure t's scope is so short as possible to help it a bit. < 1271539351 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :What's wrong with just making the tape signed, though? < 1271539363 0 :olsner!unknown@unknown.invalid PRIVMSG #esoteric :implementation-defined, it varies between compilers < 1271539367 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :You'll think that the character 255 is EOF in that case., < 1271539373 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :We're already squeezing 257 values into 256 < 1271539376 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :because we're using 0 as \0 and EOF < 1271539384 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :fizzie: well, good bound < 1271539385 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :*point < 1271539538 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :this parser still confuses me to no end < 1271539866 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :wtf? i know there aren't unbalanced brackets in this program... < 1271539873 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :oh it is that problem again. < 1271540159 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :woot < 1271540170 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :recursive parser, though ugly, cut time from 15.152s to 14.552s < 1271540175 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: I'll try your pointer now < 1271540190 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :What if I'm mostly getting the Nexus One because it looks sexier than the iPhone? :/ < 1271540241 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :This almost reminds me of Linux -- and I did end up switching back to Windows < 1271540254 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :your cpu sucks :p < 1271540309 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: yes; and my compiler < 1271540314 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :it's only 4.3.3 < 1271540324 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: using pointer increases from 14.552 to 16.357 < 1271540539 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: can i send you bf[89].c so you can test yourself? < 1271540620 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :eh < 1271540625 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :anyone want to try it? < 1271540631 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :http://sprunge.us/JTZe bf8.c < 1271540633 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :http://sprunge.us/KZMR bf9.c < 1271540635 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :compile with: < 1271540643 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :gcc -O3 -march= -fwhole-program -fomit-frame-pointer < 1271540645 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :then strip -s the resulting binary < 1271540646 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :then < 1271540652 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :./bf8 >/dev/null; time ./bf8 >/dev/null < 1271540652 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :-march=native < 1271540655 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :./bf9 >/dev/null; time ./bf9 >/dev/null < 1271540657 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant: also that < 1271540660 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :...and report the timings to me < 1271540672 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant need not apply as his computer runs everything in infinitesimal time < 1271540673 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric ::-D < 1271540742 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :although, you know, he can if he wants. < 1271540752 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :4.3.3? < 1271540755 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :I thought you were using clang < 1271540759 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :also doing it with clang may be worthwhile < 1271540761 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: no; I don't have clang < 1271540767 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: do the timings plox :P < 1271540771 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :k < 1271540773 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :i can't believe it is faster for you < 1271540782 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :I can't believe it's not butter. < 1271540949 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :4.95 and 6.41 using gcc (GCC) 4.3.0 20080305 (alpha-testing) mingw-20080502 < 1271540964 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :So bf9 is slower, yes? < 1271540969 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :Yes < 1271540978 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :with gcc, bf9 is slightly slower < 1271540981 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Well, it's Windows, so I'm inclined to almost entirely ignore the data point, but it supports my rejection of comex's findings. < 1271540981 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :with clang, bf9 is slightly faster < 1271540986 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Right. < 1271540993 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :neither of them give me as much of a result; .05 sec both ways < 1271540999 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :however, clang is *much* faster than gcc < 1271541001 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :For me, 14.552s vs 16.357s is not "slightly". < 1271541007 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :So I will stick to array access. < 1271541014 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :11ish seconds vs 7 seconds < 1271541016 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: Yes, well, I'm on an old version of Ubuntu. < 1271541020 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :I'm on OSX < 1271541020 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I really don't want to compile LLVM & clang. < 1271541024 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Too lazy. < 1271541025 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :So. < 1271541027 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :ther'es no package for it? < 1271541043 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Not in 9.04... < 1271541051 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :It wasn't even released then. < 1271541078 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :eh, okay < 1271541082 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :clang is pretty cool in general though :p < 1271541088 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :What's this mandelbrot.h file? (Haven't been following.) < 1271541106 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :fizzie: http://pastie.org/924867.txt?key=y1tsv0fos2dcg2ku9rkqw < 1271541124 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Gah, and I just started to paste it, too. < 1271541216 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :If I have T a[], and and v = (long)(a[0] + 1), then a[v] should = a[1], right? < 1271541221 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :It's that silly 1-not-meaning-1 thing, isn't it? < 1271541227 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I mean, that is the definition of array dereferencing. < 1271541231 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :So, I wonder, why it isn't working... < 1271541241 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :a[0] + 1 is not *(&a[0] + 1) < 1271541251 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Oh, I see what I did wrong < 1271541259 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant: It's not actually a[0] in the code < 1271541265 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Complicated :P < 1271541267 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :But I figured it out < 1271541273 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :Regardless, adding one to a[0] does not, in general, give a[1] < 1271541275 0 :Oranjer!~HP_Admini@adsl-34-17-217.cae.bellsouth.net JOIN :#esoteric < 1271541290 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Well, "in general" here it's worked perfectly < 1271541334 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Adding one to a[0]'s address might work; I'm having hard time believing adding one to a[0]'s value will yield a[1] unless you've set up a very specifically. < 1271541341 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :I think you're confused or your code does not represent your actual code < 1271541343 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Yes, yes, yes, shush :P < 1271541346 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :It doesn't < 1271541348 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I was just being stupid < 1271541358 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :It was actually &a[0] because it was a pointer to a variable which happens to be in the array < 1271541359 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :So nyah < 1271541408 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :clang on bf8.c: http://pastebin.com/krFjTXma -- it seems I really should get a newer clang. < 1271541419 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :http://pastie.org/924983.txt?key=nksyxpkqzwqs6fwwvmmppg < 1271541424 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :What a fucking ridiculous speedup < 1271541429 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Why on earth does that make more than a tiny amount of difference < 1271541433 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I hate you, GCC < 1271541474 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Seriously, it's over .5s faster just because it avoids some ip++s < 1271541483 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :And it even pays some +1s for that at the start < 1271541504 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: I bet if you apply that diff and do it with clang the difference is nil... < 1271541508 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :As for gcc, 10.4s for bf8, 11.35s for bf9. < 1271541537 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :The http://pastie.org/924983.txt?key=nksyxpkqzwqs6fwwvmmppg bf9 or the pointer-not-array bf9? < 1271541548 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :The one you pasted when asking for timings. < 1271541550 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :If the latter, just delete it; the former is the proper bf9 because the latter didn't work out so well. < 1271541563 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :There's a nice olde-style diff, if you like that kind of thing, in the pastie, from bf8 :P < 1271541567 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :http://sprunge.us/JTZe one < 1271541581 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :JTZe is bf8, not bf9 < 1271541592 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Oh, right. Well, the one next to it. < 1271541595 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :KZMR. < 1271541610 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Gnblblblb qweeb zkxvfs speaking in tongues. < 1271541632 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I'm surprised I've been able to get such good performance out of very little code. < 1271541711 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Anyway, http://sprunge.us/JTZe + diff in http://pastie.org/924983.txt?key=nksyxpkqzwqs6fwwvmmppg = bf9 that I'm curious as to the performance of. < 1271541717 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Mostly with clang, comex, ahem. < 1271541980 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :yeah, I'm impressed at the simplicity < 1271542026 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :Well, op prog[5242880] :-P < 1271542032 0 :ze_german!~fpoo@dslb-088-078-164-249.pools.arcor-ip.net JOIN :#esoteric < 1271542078 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant: Well, that's just part of the whole file-loading malarkey, which is really not the most important or difficult part of brainfuck implementation. < 1271542096 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :True enough < 1271542112 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant: I'd complain more about the fixed tape size. < 1271542126 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :alise__: that patch increases performance with clang by 1s < 1271542128 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I don't think the code to handle segfault-means-realloc should be too terribly difficult. < 1271542134 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: lol < 1271542135 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :alise__: But isn't that defined in BF < 1271542141 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: isn't it hilarious < 1271542141 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :30000 or whatever. < 1271542153 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :7s -> 6s ish < 1271542159 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant: No, not defined, just in one of the original implementations. The original compiler had significantly fewer cells, iirc. < 1271542163 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: it's like... barely anything < 1271542170 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :but it has such an effect < 1271542178 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :Why is s a char** < 1271542201 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :because i recurse to do loops < 1271542204 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :and it advances through the string < 1271542217 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :please, rewrite it without the extra star, I'd love that; I hate pointers-to-pointers < 1271542219 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :Ah < 1271542224 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :maybe it affects some random register allocation < 1271542227 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I'm not dropping the recursion, though; it came out quite a bit faster this way. < 1271542240 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: it's better, though, not just some random hack, because it /is/ objectively doing less things < 1271542246 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1271542251 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :$ time ../bf_compet/bff4 /dev/null < 1271542252 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :real 0m18.026s < 1271542252 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :user 0m17.865s < 1271542252 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :sys 0m0.040s < 1271542254 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :HAHAHAHAHAHAA YOU LOSE < 1271542266 0 :comex!unknown@unknown.invalid PRIVMSG #esoteric ::] < 1271542290 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Mind, I won't beat it in the general case until I do linear loop optimisation. < 1271542375 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION tries the self-interp!self-interp!hi123 combo
< 1271542408 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :comex: I wish I could get rid of the setup part of interp < 1271542412 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :it's such an ugly way to do it < 1271542652 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I'm worried I may be overfitting for mandelbrot. < 1271542667 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Well, maybe I just need linear loops. < 1271542674 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I don't think I have any mandelbrot-ishly-specific optimisations. < 1271542900 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :oh lol < 1271542901 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :it was just waiting for input < 1271543172 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :yeah i actually beat bff4lnr < 1271543531 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :brb < 1271543764 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Why are there more games for iPhone :( < 1271545170 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :iphone is more popular < 1271545207 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :an iphone is like windows, android is like linux, except android isn't as fiddly as linux :P < 1271545357 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :Anyone have any idea how to write an unordered pair {,} A type such that you can write {,} (bool,A) => (A,A) but not {,} A => (A,A) < 1271545362 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :i.e. it preserves unorderedness < 1271545449 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :please rephrase that mess < 1271545562 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :if the first one is an unordered pair of elements of type (bool,A), then i don't see how you can get an (A,A) from it unless the bools are different < 1271545606 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :er, good point < 1271545609 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :how was it a mess? :( < 1271545618 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :{,} A is an unordered pair of two As < 1271545631 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well it confused me < 1271545644 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :_clearly_ it must then be a mess < 1271545666 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :hang on... what are you tryuing t do? < 1271545689 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: I cannot rephrase that bool example to get it working properly... < 1271545689 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :(T : {,} (bool,A)) /\ (exists x y, fst x =/= fst y /\ x in T /\ y in T) < 1271545692 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :the problem with that is - constructively - < 1271545696 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :exists x y hands us the two values on a platter < 1271545699 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :which is not really the point at all < 1271545701 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :but, it works < 1271545712 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :so I guess I just want {,} A such that we cannot write {,} A => (A,A) and similar < 1271545810 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :http://lifthrasiir.jottit.com/esotope-bfc_comparison ;; I want to do "Simple loop detection"; I don't think I want to do "Pointer propagation" -- too expensive on the whole < 1271545811 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION knows nothing about that
< 1271545842 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :alise__: i'm not sure i understand < 1271545851 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :oh they're unrelated < 1271545861 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: hmm do you know anything about type theory? or at least haskell < 1271545867 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :if not it's hard to explain... < 1271545872 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :assume i don't < 1271545880 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :"unordered pair"? < 1271545893 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :um... your regular tuple of two values, except unordered < 1271545902 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :think of a two-element set -- you are familiar with basic set theory, right? < 1271545920 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :it's been a hwile, but yeah < 1271545936 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :anyway, let's think about it as two-element sets < 1271545937 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :we have < 1271545942 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :intro(x,y) := {x,y} < 1271545952 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :so we have a function that takes two values and returns an unordered pair of those two values < 1271545962 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :but we don't have (function taking a function here) < 1271545968 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :which side of that is the unordered pair? < 1271545973 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :the right hand side < 1271545974 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :ok < 1271545983 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :we do intro(3,2) and get {2,3}, we do intro(2,3) and get {2,3} < 1271545987 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :obviously this function is valid. < 1271545991 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :but we do not have < 1271545991 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :yeah, ok < 1271545995 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :exit(F,{x,y}) := F(x,y) < 1271546000 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :because we cannot pick which value is x, and which value is y < 1271546008 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :it matters, because F can distinguish its two arguments < 1271546031 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :creating the unorderd pair is a one way "move", because it can't be reversed < 1271546036 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :right < 1271546063 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :I'm trying to come up with an analogous type in type theory -- basically a functional language's type system but more abstracted < 1271546088 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric :perhaps < 1271546089 0 :alise__!unknown@unknown.invalid PRIVMSG #esoteric : {,} A := A x A => Bool < 1271546102 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :{,} A ??? < 1271546164 0 :MigoMipo!unknown@unknown.invalid QUIT :Quit: When two people dream the same dream, it ceases to be an illusion. KVIrc 3.4.2 Shiny http://www.kvirc.net < 1271546176 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :i don't understand the "new" notation < 1271546356 0 :alise__!unknown@unknown.invalid QUIT :Ping timeout: 258 seconds < 1271546403 0 :alise!~alise@212.183.140.20 JOIN :#esoteric < 1271546410 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Sorry; what did I last say? < 1271546431 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :ugh; ages ago < 1271546438 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: I am just using {,}A to denote the type of an unordered pair of As < 1271546446 0 :tombom_!unknown@unknown.invalid QUIT :Quit: Leaving < 1271546449 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :i.e., intro(X,Y) has-type {,}A where X and Y have-type A < 1271546451 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric : {,} A := A x A => Bool < 1271546464 0 :dbc!unknown@unknown.invalid QUIT :Quit: Seeeeeya < 1271546488 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: http://pastie.org/925078.txt?key=s1xvjdrz0hakx4spiqbiq < 1271546495 0 :dbc!~daniel@130-94-161-238-dsl.hevanet.com JOIN :#esoteric < 1271546506 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :A x A is an ordered tuple of As < 1271546546 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :tbh it helps to grasp how type theory, computation and logic intertwine to understand all of this... < 1271546552 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :and that requires a good knowledge of type theory < 1271546611 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION starts work on bf10.c
< 1271546615 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :you do know that i struggle with pointers, right? < 1271546638 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: actually this is far more theoretical and mathematical than pointers. so that is not /necessarily/ an impairment < 1271546678 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION struggles with how magical & types seem
< 1271546684 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :my point is that i haven't worked out how to get my head around them < 1271546688 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION pulls an AnMaster, and reads bff4's source to find out how to do linear loops nicely
< 1271546689 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Well, not really badly struggle, but it's strange < 1271546692 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: & types? < 1271546702 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :int& some_ref_type; < 1271546705 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: have you watched Pointer Fun with Binky < 1271546710 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :no? < 1271546714 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :I like pointers. They're sensible. < 1271546716 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :http://www.youtube.com/watch?v=i49_SNt4yfk < 1271546719 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: become enlightened < 1271546722 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :And non-magical < 1271546738 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :(it's actually a really good explanation!) < 1271546738 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :i'm about to (at some point) read chapter 5 of K&R though < 1271546749 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :i get the theory < 1271546752 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :pointer fun with binky. you will be enlightened forevermore < 1271546768 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :but... finding the syntax for what i want to do feels like pot luck < 1271546794 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :basically... here's a good intuition to develop: < 1271546807 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :if only I (this scope; mostly, this function) will want to change this, use a value < 1271546832 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :if I want someone else to change the individual items in this compound value (structure, array, pointer, etc), but not the compound value as a whole, use one * < 1271546840 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :ugh... C++? < 1271546846 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :if Iw ant someone else to be able to change the individual items /and/ the whole value in this compound, use two **s < 1271546848 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :*if I want < 1271546857 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I don't want ***. < 1271546862 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: there is your intuition ^ < 1271546884 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :does *** ever have a use? < 1271546899 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :and... how much of this vid is relevant to C? < 1271546998 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: the whole vid is C < 1271547000 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :none of it is C++ < 1271547009 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Anything that doesn't involve, say, int&, is probably relevant. (something& is revevant thoug) < 1271547019 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :erm, &something < 1271547022 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: *** probably has /some/ use, but if you think it does, unless you're really experienced with pointers -- and so already /know/ what uses it has -- you're wrong; and you don't need it. < 1271547027 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :*** is almost always really bad practice. < 1271547036 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :It should be exceedingly rare; I wouldn't worry about it. If you end up doing ***, rethink. < 1271547045 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :alise, our professor, without explanation, had a function take an argument *& < 1271547051 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Took me a bit to work it out < 1271547052 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Ignore Sgeo_; I've seen the vid and it's not C++ at all :P < 1271547055 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: lol < 1271547060 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :I don't think anyone else worked it out < 1271547065 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Sgeo_: as we all know that is the same as taking a value argument! < 1271547067 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :...right? < 1271547070 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric ::-) < 1271547137 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :The linear loop code in http://mazonka.com/brainf/bff4.c is not very helpful at all... < 1271547231 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I think if( o[i].c == '[' && o[i].igo == i+1 && o[i].shift==0 && o[i].off <= 0 ) is the magic bit... < 1271547233 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Or maybe consume. < 1271547286 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :alise: the new keyword is C ? < 1271547299 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :?! < 1271547302 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :Screenshot? < 1271547305 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1271547307 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :this is a C++ version < 1271547312 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :... < 1271547312 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :forget every single thing you heard < 1271547316 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :LOL < 1271547318 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :and watch this http://www.youtube.com/watch?v=r4-9Mh3761E&feature=related < 1271547318 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :XD < 1271547320 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :sorry :D < 1271547320 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :thanks honey < 1271547329 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :WIPE YOUR MIND < 1271547330 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :LA LA LA LA < 1271547347 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :alise, unless it goes over reference types and not pointers, why bother wiping your mind? < 1271547356 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :because it's probably stupid < 1271547358 0 :Sgeo_!unknown@unknown.invalid PRIVMSG #esoteric :Although new instead of malloc could be hurtful < 1271547417 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION throws a cucumber at alise
< 1271547430 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :YOUR MOM < 1271547437 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :? < 1271547479 0 :alise!unknown@unknown.invalid PRIVMSG #esoteric :I am merely deflecting your blows < 1271547676 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :i found the C version < 1271547711 0 :alise_!~alise@212.183.140.36 JOIN :#esoteric < 1271547718 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :hey comex < 1271547761 0 :Rugxulo!~rugxulo@adsl-065-013-115-246.sip.mob.bellsouth.net JOIN :#esoteric < 1271547784 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Rugxulo: wow i almost forgot about you < 1271547799 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :that's no surprise, I'm nobody ;-) < 1271547827 0 :alise!unknown@unknown.invalid QUIT :Ping timeout: 258 seconds < 1271547838 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :BTW, if anybody cares, I updated the tiny BEFI.COM, fixed a bug (negmod.bef), now only 1014 bytes < 1271547878 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :You'll be glad to know I'm doing my bit to combat bloated and slow software by writing a very small, very fast brainfuck interpreter! < 1271547887 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :what language? < 1271547893 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :C < 1271547899 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :using GCC? ;-) < 1271547909 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I do use computed gotos, but that makes things faster. It works with clang too. < 1271547926 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Apart from the computed gotos -- vital to its speed -- it's standard C. < 1271547926 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :yeah, Clang is getting lots of press these days, self-hosting, ClangBSD in testing, etc. < 1271547938 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :It's much faster with clang because gcc does really stupid things to it. < 1271547943 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :it's just that GCC isn't exactly super optimal in output size < 1271547951 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :(not that any compiler is) < 1271547956 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :It's bloated up marvellously for its first day of development -- bf1.c compiled to 19K when stripped; bf9, 27K. < 1271547979 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :alise_: goto is not evil < 1271547981 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :BTW, here's a modified benchmark for someone to test: < 1271547983 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :>91+:*-:0`#@ #._v < 1271547983 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :^ < < 1271547994 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Mind, bf1 is 81 lines and bf9 is 97 lines, so the actual code isn't bloating much; plus, the former takes ~40s to run mandelbrot.b, the latter something like 13s < 1271548003 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: Did I ever say it was? < 1271548003 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :Rugxulo: -Os ? < 1271548010 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :N.B. for some reason, it's much slower on my P4 and AMD64 (but much faster on P1), probably self-modifying code < 1271548021 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Rugxulo: -Os doesn't really help size at all here < 1271548025 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :alise_: no... but that seems to be the "default" answer < 1271548026 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :-O3 and stripping produce an executable just as small < 1271548026 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :-Os isn't bad anymore, but it's not perfect either < 1271548033 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I dunno about clang's output size, but it is much faster < 1271548037 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: lol :P < 1271548040 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :clang? < 1271548045 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: computed gotos are non-standard < 1271548046 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :is the point < 1271548047 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :gotos aren't < 1271548055 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :clang is a C compiler that's better than gcc. < 1271548056 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :computed goto ? < 1271548069 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :computed goto lets you make pointers to goto labels then do < 1271548070 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :goto *ptr; < 1271548071 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :Clang is considered "more modern" (whatever that means) < 1271548084 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :but GCC supports more targets and languages < 1271548093 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Clang is the apple-funded -- but totally open source and independent -- ultra-optimising, helpful-error-spewing, actually-well-designed-unlike-GCC C compiler. < 1271548095 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :(but is slow, admittedly) < 1271548095 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Rugxulo: fallacy < 1271548108 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Clang supports C/C++/Objective-C (admittedly, C++ not so well); and LLVM has many non-Clang compilers < 1271548124 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :C++ has supposedly improved a lot, it can self-host now (itself being written in C++) < 1271548124 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :GCC is like a badly-implemented and badly-specified half of LLVM plus something worse than Clang < 1271548138 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :GCC 4.5.0 was just released, now with plugin support < 1271548139 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :all apps in mac os x 10.6 are compiled with clang... < 1271548144 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :e.g. DragonEgg < 1271548151 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :whoop de doo < 1271548168 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :anyway i'm trying to beat the current bf world champion of speed... mazonka's bff4lnr < 1271548182 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :i think i do already, but I'm implementing the same linear loop optimisation just to clinch it < 1271548188 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :I also recompiled the standard bef 2.2.1 bef.c with GCC 4.4.2 -march=pentium, but it was like twice as slow as -mtune=pentium4 (even on a P1) < 1271548192 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :as a bonus my code is a lot shorter < 1271548194 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :bah, optimization is so tricky :-( < 1271548211 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :admittedly I need to add some code to open source files and stuff < 1271548213 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :but that's easy < 1271548216 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :and i need a tape-expander < 1271548221 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :(hook into segfault, make that grow the tape) < 1271548229 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :(either that or mmap a huge amount and rely on overcommitting) < 1271548233 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :(right now my tape is fixed-size) < 1271548247 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :so is your hard drive! ;-) < 1271548273 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :dumb question, but how are you testing the speed? < 1271548288 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :my hard drive isn't 65536 bytes long though. < 1271548303 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :no, but it's a fixed size, so basically I meant "don't sweat it too much" ;-) < 1271548315 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :my impl can never be truly tc because c pointers cannot be infinite < 1271548323 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Rugxulo: yes but you need an arbitrary growing type lest you allocate 2gb every time someone runs it < 1271548329 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :and besides the universe is fixed-size too, but that doesn't...matter < 1271548335 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :testing speed, I have it hardcoded to parse & run mandelbrot.b < 1271548340 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :which renders a pretty ASCII art mandelbrot; slowly. < 1271548341 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :the universe is expanding (or so they say) < 1271548349 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :it's still finit. < 1271548351 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :*finite < 1271548364 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :dunno how they claim to know that anyways ;-) < 1271548384 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :it's called physics and you can't dismiss it with a wink < 1271548394 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :BTW, there's "mandel.bf" (Befunge) also ;-) < 1271548399 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Gads, I hate computers. I have been getting suspicious filesystem corruptions on the system SSD, so since the manufacturer has a newer firmware (1.5 vs. 1.42) I download the updater ISO and boot. < 1271548400 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :turns out we can measure shit and make models that predict the things that happen < 1271548401 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :sure I can *wink* < 1271548403 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :"[ERROR]Firmware download fail! Bye!" says the updater, reboots, and now BIOS or anything else no longer sees the disk. < 1271548412 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :and they get incredibly detailed such that it is very likely that certain measurements imply certain things < 1271548428 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Rugxulo: just out of curiosity do you live in the US? and if so what state? < 1271548429 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :fizzie, still in warranty? < 1271548438 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :yes, I do < 1271548451 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :why? :-) < 1271548466 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :I asked two questions < 1271548468 0 :Tritonio_GR!~Tritonio@150.140.231.13 JOIN :#esoteric < 1271548470 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Rugxulo: Less than a month old, would assume so. Won't help much before Monday, I guess. < 1271548485 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :yes, but before I give out my precious SSN, I'd like to know why you are asking :-P < 1271548499 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :hhaha < 1271548506 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :state you live in != SSN < 1271548509 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :fizzie, scroll back and see my modified benchmark, try testing it (if you can drag yourself away from your SSD woes) < 1271548518 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :"I live in $state" is about as information-giving as "I live in Wales" < 1271548523 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :or did you not realise that states are fucking huge? < 1271548534 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :not all of 'em, some (e.g. R.I.) are small < 1271548550 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :Quahog ftw! ;-) < 1271548557 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Oh, just tell me. < 1271548559 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :what's a recent version of clang? pacman is saying 2.6-6 < 1271548573 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :alise, why oh why? < 1271548603 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Rugxulo: I just have a certain hunch. I'll tell you the hunch if you answer my question. < 1271548609 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :pineapple: lemme look up the recentest < 1271548617 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :huh, mandel.bf is slow also (surprisingly) < 1271548620 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :Build Date : Tue 05 Jan 2010 22:52:09 GMT < 1271548621 0 :Rugxulo!unknown@unknown.invalid PART #esoteric :? < 1271548622 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :2.6 should be fine < 1271548636 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :ok... what was the hunch? < 1271548638 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :the svn version is more up to date but that involves a bunch of boring compilation, so just go for it < 1271548638 0 :kar8nga!unknown@unknown.invalid QUIT :Read error: Connection reset by peer < 1271548668 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :he hasn't answered my question yet :-) < 1271548678 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :(2.7 svn from March is not fine, it has problems with the labels-as-values thing.) < 1271548687 0 :Rugxulo!~rugxulo@adsl-065-013-115-246.sip.mob.bellsouth.net JOIN :#esoteric < 1271548710 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :Rugxulo: My main workstation is the one that had the SSD as a system disk, so I don't have much to test it with right now. I'll check once I've finished dd'ing a backup on a spare HD so that I get a usable computer back. < 1271548717 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :sorry, optical mouse is quite squirrelly sometimes, it jumped to corner and closed my Opera :-( < 1271548722 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Rugxulo: going to answer? :-) < 1271548724 0 :pineapple!unknown@unknown.invalid PRIVMSG #esoteric :oops < 1271548739 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :fizzie, no pressure, didn't want to bug you, just found it weird that it's twice as slow on "modern" cpus :-P < 1271548759 0 :Rugxulo!unknown@unknown.invalid PRIVMSG #esoteric :alise, just guess, you have a 2% chance of being right ;-) < 1271548789 0 :alise_!unknown@unknown.invalid PRIVMSG #esoteric :Rugxulo: north or south?