←2019-12-11 2019-12-12 2019-12-13→ ↑2019 ↑all
00:33:40 -!- FreeFull has quit.
00:42:06 -!- arseniiv has quit (Quit: gone completely :o).
00:56:00 -!- ArthurStrong has quit (Quit: leaving).
01:55:38 -!- Lord_of_Life_ has joined.
01:57:57 -!- Lord_of_Life has quit (Ping timeout: 240 seconds).
01:57:57 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
04:37:21 <esowiki> [[Talk:Grime MC]] N https://esolangs.org/w/index.php?oldid=67908 * IFcoltransG * (+319) Created page with "Is this the sort of language where an interpreter would be impossible because it's subjective what a lyric means, or does it have a finite set of possible commands? If the lat..."
04:56:16 <esowiki> [[StackBeat]] M https://esolangs.org/w/index.php?diff=67909&oldid=37539 * IFcoltransG * (+1) /* Other notes */ Typo
05:19:41 -!- fungot has quit (Ping timeout: 246 seconds).
05:25:09 -!- fungot has joined.
06:08:22 -!- sparr has quit (Ping timeout: 252 seconds).
06:11:15 -!- sparr has joined.
07:58:46 -!- xkapastel has joined.
09:15:19 -!- b_jonas has quit (Quit: leaving).
10:06:52 -!- ais523 has joined.
10:12:40 -!- Deewiant has quit (Ping timeout: 264 seconds).
10:13:57 -!- Deewiant has joined.
10:17:25 -!- xkapastel has quit (Quit: Connection closed for inactivity).
10:22:55 -!- ais523 has quit (Remote host closed the connection).
10:24:09 -!- ais523 has joined.
10:27:45 -!- mroman has joined.
10:57:07 -!- mroman has quit (Remote host closed the connection).
10:57:18 <ais523> @messages?
10:57:18 <lambdabot> Sorry, no messages today.
10:57:41 -!- bunnyocte has joined.
10:58:44 <bunnyocte> hm.
10:59:28 -!- bunnyocte has quit (Remote host closed the connection).
10:59:45 -!- bunnyocto has joined.
10:59:47 <bunnyocto> no rename command on freenode?
11:00:54 <bunnyocto> or maybe it was /nick and not /rename
11:00:58 <bunnyocto> ah yep
11:04:59 <bunnyocto> aight. let me check out the newest bf derivatives.
11:13:18 <bunnyocto> verify register bunnyocto azdixccwwmkk
11:16:36 -!- ArthurStrong has joined.
11:26:59 <int-e> `relcome bunnyocto
11:27:03 <HackEso> bunnyocto: Welcome to the international hub for esoteric programming language design and deployment! For more information, check out our wiki: <https://esolangs.org/>. (For the other kind of esoterica, try #esoteric on EFnet or DALnet.)
11:27:37 -!- ais523 has quit (Ping timeout: 240 seconds).
11:30:06 <bunnyocto> fungot: hi
11:30:07 <fungot> bunnyocto: ah well... thanks to intel addressing modes and variable-length opcodes it's not that
11:33:01 <bunnyocto> github workflows has a weird directory structure
11:33:15 <bunnyocto> it's /reponame/reponame
11:44:42 <FireFly> g'fternoon
11:51:33 <bunnyocto> github deprecated integrations?
11:51:37 <bunnyocto> How do I do CI Now then?
11:51:54 <bunnyocto> Like require pull requests to have passing tests.
12:08:05 <bunnyocto> lel I can't review my own pull requests.
12:08:07 <bunnyocto> hm.
12:08:16 -!- arseniiv has joined.
12:18:10 <int-e> Oops, I believe I accidently got some AoC points.
12:18:40 <int-e> Ah, no. Phew.
12:39:46 <shachaf> int-e: Do you think surjections have right inverses?
12:42:26 -!- tromp_ has joined.
12:46:02 -!- tromp has quit (Ping timeout: 276 seconds).
12:49:38 -!- bunnyocto has quit (Remote host closed the connection).
12:56:32 <int-e> shachaf: depends
12:59:04 <int-e> Oh there are actually two issues here.
13:00:00 <int-e> One of convention, and one of choice.
13:00:02 <fizzie> int-e: I got some for the one time I was awake at 5am, and now I have to fight the urge to try again. :/
13:00:27 <int-e> fizzie: I was awake. I deliberately didn't look.
13:01:36 <shachaf> What's the axiom of convention?
13:01:41 <int-e> And now I was worried that today's second part was really hard so I might have earned points for it, but only because I momentarily misread the statistics page.
13:02:03 <int-e> shachaf: The conventional issue is which way function composition composes.
13:05:06 <int-e> shachaf: Also I had trouble connecting dots... while I typed "AoC" I thought and read the whole "Advent of Code".
13:05:38 -!- bunnyocto has joined.
13:07:20 <shachaf> Oh, sure.
13:07:29 <shachaf> What should I call f and g such that f.g = id?
13:09:51 <int-e> f is a left inverse of g; g is a right inverse of f
13:09:57 <bunnyocto> yup
13:10:38 <int-e> It's pretty uncontroversial this far.
13:10:50 <shachaf> I think those are pretty confusing terms.
13:11:07 <shachaf> But if you say that's uncontroversial, where's the controvery?
13:11:28 <int-e> doe (f.g)(x) = f(g(x)) or (f.g)(x) = g(f(x))?
13:11:32 <int-e> *does
13:11:44 <int-e> that's the confusion.
13:12:20 <myname> how so? it's clearly the first
13:12:30 <int-e> The latter happens in some category theory texts.
13:12:35 <bunnyocto> f(g(x)) is the usual convention?
13:12:53 <int-e> Because they want (.) : (a -> b) -> (b -> c) -> (a -> c)
13:13:00 <bunnyocto> also it's the haskell way thus muh
13:13:07 <int-e> and the inner -> are abstract anyway.
13:13:27 <int-e> As much as I like Haskell, it's not defining the world.
13:13:36 <myname> also, there are people that are using \subset for implication
13:13:40 <bunnyocto> what? it isn't?
13:13:41 <myname> I don't like that
13:13:43 <bunnyocto> why am I using it then.
13:13:59 <int-e> not \subset... \supset
13:14:15 <myname> right
13:14:18 <myname> still hate it
13:14:23 <bunnyocto> no, but (f.g) x = f ( g ( x ) ) is more intuitive imo
13:14:36 <bunnyocto> but that may just be because I'm accustomed to it
13:15:04 <myname> that's the definition I am used to from math classes
13:15:10 <int-e> You'll be surprised how little people value other's opinion in general.
13:15:16 <myname> coincidentally, haskell does it that way
13:15:21 <bunnyocto> yep. And thus I don't value their opinions.
13:15:24 <bunnyocto> Cruel world.
13:15:47 <int-e> Also some people really like >>>
13:15:57 <myname> for what?
13:15:59 <bunnyocto> is that arrow notation?
13:16:13 <int-e> And I believe we've had at least one proposal to flip the order of arguments of (.).
13:16:16 <int-e> :t (>>>)
13:16:16 <bunnyocto> haven't used haskell in a while
13:16:20 <lambdabot> forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
13:16:55 <bunnyocto> >>, >=>, $>, >>>,
13:17:00 <bunnyocto> :t (>=>)
13:17:02 <lambdabot> Monad m => (a -> m b) -> (b -> m c) -> a -> m c
13:17:06 <myname> I am okay with >>>
13:17:17 <int-e> bunnyocto: The thing is, if you want to read math texts, you better keep an open mind about notation.
13:17:45 <int-e> And unfortunately that includes basic things like the order of arguments of function composition.
13:19:13 <int-e> That said, I /prefer/ (f.g)(x) = f(g(x)).
13:21:42 <esowiki> [[Special:Log/newusers]] create * Leo9 * New user account
13:42:09 <FireFly> I though the Haskell thing was to use (&) for the g(f(x)) case
13:42:14 -!- kspalaiologos has joined.
13:42:33 <FireFly> no need to pollute established notation with confusion..
13:43:17 <FireFly> I mean I like the forward-direction composition just fine, but under a differet notation
13:44:58 <Taneb> (&) is normally flip ($), not flip (.)
13:45:22 <FireFly> oh right
13:45:30 <FireFly> hmm, point
13:45:36 <Taneb> I've seen (f;g)(x) = g(f(x)) but that doesn't work as a Haskell operator
13:46:36 <FireFly> Clojure calls it (->>) IIRC, but that's more in a prefix, s-expr setting
13:46:56 <FireFly> but thee's he (>>>) from Category as mentioned, etc
13:56:32 -!- Lord_of_Life_ has joined.
13:58:50 -!- Lord_of_Life has quit (Ping timeout: 276 seconds).
13:58:50 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
14:00:58 -!- kspalaiologos has quit (Quit: leaving).
14:03:17 -!- sprocklem has quit (Ping timeout: 240 seconds).
14:03:54 -!- kritixilithos has joined.
14:16:40 -!- wib_jonas has joined.
14:22:04 <wib_jonas> the order of arguments for function composition is simple. if you write the evaluation of the function f at input value x as f(x) or fx then the function composition is (f o g)(x) = f(g(x)) or (f o g)x = f (g x); but if you write it as x f or x^f, then the function composition is x (f o g) = (x f) g or x^(f o g) = (x^f)^g
14:22:51 <wib_jonas> and int-e, they're functions, so the left inverse and the right inverse are the same, we can just call it the inverse or inverse function
14:31:55 <int-e> wib_jonas: ...
14:32:03 <int-e> wib_jonas: you might want to think that through
14:38:14 <int-e> wib_jonas: what is true is that if a function has both a left inverse and a right inverse then they're equal (and that implies the inverse is unique in that case).
14:39:08 <int-e> But existence is a bit of an issue.
14:54:33 <bunnyocto> f being left inverse of g and g being right inverse of f doesn't imply that f . g = g . f
14:54:51 <bunnyocto> or does it?
14:54:52 <wib_jonas> int-e: hmm ok
14:54:54 <bunnyocto> I wouldn't think so
14:55:32 <bunnyocto> wait so if f . g = id and h . f = id then g = h?
14:55:51 <bunnyocto> that doesn't _sound_ right?
15:00:49 <myname> i don't think so
15:01:08 <myname> especially if the signatures differ
15:01:56 <bunnyocto> f .g = id -> h . f . g -> h . id -> h
15:02:48 <bunnyocto> since h . f = id -> h . f . g -> id . g -> g
15:02:50 <bunnyocto> thus h = g
15:02:51 <bunnyocto> hm.
15:02:52 <bunnyocto> it true
15:03:28 <myname> interesting
15:03:49 <bunnyocto> wait
15:03:54 <bunnyocto> I need paper for this.
15:04:48 <bunnyocto> no it's right.
15:05:12 <bunnyocto> h . f .g = id . g but also h . f .g = h . id thus id .g = h . id and id . g = g and h . id = h thus h = g = h
15:06:39 -!- sprocklem has joined.
15:06:46 <bunnyocto> now the question is whether there are functions (a,b) and (c,d) such that a . f = id and f . b = id and c . f = id and f . d = id but a /= c and b /= d
15:07:19 <bunnyocto> I mean... evidently a=b and c=d
15:07:45 <bunnyocto> so that leaves us with a . f = id and c . f = id where a /= c
15:08:13 <bunnyocto> which trivially if a . f = id and c . f = id then a . f = c. f
15:09:06 <bunnyocto> so the inverse is unique
15:09:07 <bunnyocto> hm.
15:17:50 -!- sprocklem has quit (Ping timeout: 246 seconds).
15:24:00 <bunnyocto> assuming id is unique
15:24:05 <bunnyocto> :D
15:25:06 <myname> if you define equality of functions as the same mappings from input to output, id is unique
15:26:54 <bunnyocto> Whats' f x = x / 0 called
15:27:02 <bunnyocto> it's a function that isn't defined forall X
15:28:06 <bunnyocto> the codomain is the empty set.
15:28:52 <bunnyocto> but the domain too
15:28:53 <bunnyocto> hm.
15:36:04 <bunnyocto> wouldn chr(0)+x work to convert to hex
15:37:40 <bunnyocto> I mean my current version (https://pastebin.com/C3kHSXMb) is probably awfully complicated and requires mem lookups
15:37:55 <bunnyocto> I could just add 0x30 to the nibbles
15:43:23 <bunnyocto> oh no
15:44:22 <bunnyocto> the guys making ASCII clearly didn't design for this.
15:44:26 <bunnyocto> BIG MISTAKE
15:44:45 <bunnyocto> on the other hand it would work if I wouldn't use ASCII
15:47:53 <bunnyocto> also I hate it when people say a byte is a number from 0-255
15:48:01 <bunnyocto> it's not accurate. bytes are typeless.
16:41:18 -!- kritixilithos has quit (Quit: quit).
16:49:44 -!- wib_jonas has quit (Remote host closed the connection).
17:09:55 -!- bunnyocto has quit (Ping timeout: 260 seconds).
17:24:29 -!- LKoen has joined.
17:40:07 -!- bunnyocto has joined.
17:55:05 <esowiki> [[Special:Log/newusers]] create * Nirex0 * New user account
17:56:04 -!- LKoen has quit (Remote host closed the connection).
18:00:20 <esowiki> [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=67910&oldid=67875 * Nirex0 * (+314) My First Edit as required by esolangs.org
18:00:34 <kingoffrance> bunnyocto, re: bytes (last i checked anyways) well more than that, eg. rfcs say "octet"; "byte" is totally arbitrary and IIRC basically IBM started doing it (engineers wanted 24-bits, so it was flexible for integer and some floating thing; but they found it was either no machine or compromise on this) and then everyone copied IBM
18:00:49 -!- LKoen has joined.
18:01:00 <kingoffrance> i found that buried in an interview with a designer of that particular IBM CPU :) 8 bits is totally arbitrary from what i found; everyone just wanted to be "compatible" basically
18:01:31 <kingoffrance> and IIRC IBM might have even been trying to be "compatible" with some competitor in the first place! totally arbitrary from what i found
18:01:53 <kingoffrance> (the interviewed person didnt say this, but it was implied)
18:02:48 <kingoffrance> and e.g. knuth IIRC claims trinary would be more efficient (assuming everyone switched, economy of scale, etc.)
18:03:19 <kingoffrance> more efficient pricewise versus performance i mean, but only if everyone switched
18:04:18 <kingoffrance> i dont trust people who say "bytes" if you mean 8 bits "octet"
18:10:41 <arseniiv> [23:03] <kingoffrance> more efficient pricewise versus performance i mean, but only if everyone switched => is it that one argument about e-ary system? Because there it’s assumed that each state of each bit/trit/etc. is equally costly to make, which isn’t that true in reality — AFAIR bits are cheaper to make work reliably than trits, statewise
18:11:00 <arseniiv> sorry about timestamp, wasn’t mean to paste that :D
18:12:07 <esowiki> [[Language list]] https://esolangs.org/w/index.php?diff=67911&oldid=67821 * Nirex0 * (+10) Add: oof programming language (not to be confused with oof!)
18:12:30 <kingoffrance> i dunno, i think knuth says it in aocp so youd have to dig 3 volumes and whatever else i dunno if he ever finished them :)
18:12:44 <kingoffrance> if you google around you might find more detail
18:13:19 <kingoffrance> somehow he claimed either trinary or some other non-binary base would be cheaper for equal performance (paraphrase on my part)
18:13:54 <kingoffrance> theres lots of potential weird bases ...
18:14:14 <kingoffrance> non-integer i mean
18:14:44 <kingoffrance> apologies if i sound vague, not really "trained" in that kinda stuff
18:15:10 <kingoffrance> (and doesnt come up in real life programming for me, however interesting it might be)
18:15:55 <kingoffrance> (plus its been like 20 years since i skimmed that stuff)
18:20:21 <esowiki> [[Oof]] N https://esolangs.org/w/index.php?oldid=67912 * Nirex0 * (+1351) Add: oof programming language (not to be confused with oof!)
18:21:58 <bunnyocto> how does C return structs?
18:22:07 <bunnyocto> doesn't fit into register
18:22:11 <bunnyocto> so presumably on the stack
18:22:54 <bunnyocto> but then presumably it's memcpied somewhere into the callee stack
18:23:01 <bunnyocto> I mean.. later pushes might destroy the struct on the stack
18:23:05 <bunnyocto> so you gotta save it somehow
18:24:42 <esowiki> [[Oof]] https://esolangs.org/w/index.php?diff=67913&oldid=67912 * Nirex0 * (+1)
18:26:20 <bunnyocto> oh well... who needs to return structs :(
18:26:48 <bunnyocto> just pass a pointer to the struct as the callee and let the caller fill that one in
18:30:48 <esowiki> [[Oof]] M https://esolangs.org/w/index.php?diff=67914&oldid=67913 * Nirex0 * (+6) Better Documentation
18:31:05 -!- Jefe has joined.
18:32:03 <Jefe> Hi, my friend told me about a language where only the white space is significant, so all visible characters constitute comments. Anybody happen to know the name?
18:32:29 <kingoffrance> i think it was called whitespace
18:32:36 <kingoffrance> and probably made slashdot
18:32:41 <kingoffrance> long ago
18:33:28 <Jefe> Well that would just make too much sense, wouldn't it?
18:33:32 <esowiki> [[Oof]] M https://esolangs.org/w/index.php?diff=67915&oldid=67914 * Nirex0 * (+30)
18:33:33 <Jefe> Thanks.
18:34:08 * kingoffrance cries himself to sleep that slashdot moderation is actually something missing from a gazillion other sites; at least slashdot's perl forum you could browse the -5 flamebait if you wanted; the modern web stuff just vanishes
18:34:44 <kingoffrance> murphy's law: someone can always do worse implementation of something you don't particularly like
18:35:39 <Jefe> That's kind of like "every bad idea will eventually be implemented in JavaScript."
18:36:34 <kingoffrance> we called it jabbascript or jabbadabbascript in ##programming about 24 hours ago ; as in node.js is modular like slicing a chunk of lard off jabba the hut and moving it somewhere else
18:36:50 <kingoffrance> i dont know if those are common nicknames
18:37:29 <kingoffrance> (referring to node having 5000 dependencies i suppose)
18:39:00 <Jefe> The Signal desktop client is apparently written in Node. I ran it for a week, my load average wouldn't drop below 3.0, and frequently shot over 15.
18:40:39 -!- ais523 has joined.
18:42:19 <kingoffrance> thats good, i dont feel bad for being cruel now
18:49:20 -!- sprocklem has joined.
18:51:52 <bunnyocto> https://stackoverflow.com/questions/22593259/check-if-string-is-int-golang
18:51:53 <bunnyocto> so terrible
18:52:48 <bunnyocto> I mean... the unicode.isDigit is bullshit.
18:53:00 <bunnyocto> then using regexps? pff...
18:58:08 <esowiki> [[Oof]] https://esolangs.org/w/index.php?diff=67916&oldid=67915 * Dart * (-94)
18:58:53 <bunnyocto> is that Ook but s/k/f?
19:01:08 <bunnyocto> OLen / 8
19:01:09 <bunnyocto> uhm.
19:01:25 <bunnyocto> oof has on OLen of 2 so 2 / 8 = 0 so it's executed zero number times
19:01:41 <bunnyocto> probably should be (OLen / 8 ) + 1 as well
19:01:52 <bunnyocto> also... > is f with zero os
19:01:53 <bunnyocto> so...
19:01:57 <bunnyocto> OLen always zero
19:02:04 <bunnyocto> means you can't express >>>> with this mechanism
19:07:59 <ais523> <bunnyocto> https://stackoverflow.com/questions/22593259/check-if-string-is-int-golang ← the question is poorly defined; many of the answers produce different results in specific cases
19:08:20 <ais523> for example, is "123456789012345678901234567890" a string representing an integer?
19:08:46 <ais523> the answer depends on your use case; you can't convert it to an integer but in many cases you'd want to recognise it as one
19:08:59 <bunnyocto> yeh I'm aware of that.
19:09:06 <kmc> i've so far avoided starting an argument with my girlfriend about golang.
19:09:10 <kmc> she seems to be a fan
19:09:35 <ais523> in languages with compiled regexes, the regex solution is actually one of the most efficient ways of doing that, because it's basically a domain-specific language for generating string validators, and the compiler will have a lot of rules to optimise it
19:09:48 <ais523> but I suspect golang doesn't actually compile regexes at compile time
19:09:57 <bunnyocto> I don't know any language that does?
19:10:04 <ais523> Rust does
19:10:11 <bunnyocto> Interesting.
19:10:36 <bunnyocto> kmc: I like golang a lot.
19:10:43 <bunnyocto> unless it's for GUI stuff
19:10:45 <bunnyocto> then puh
19:11:01 <bunnyocto> I don't think there are any reasonably good bindings to do GUI stuff with golang yet.
19:11:28 <bunnyocto> but you know
19:11:43 <bunnyocto> GUI is done in things..
19:11:46 <bunnyocto> html
19:12:26 <bunnyocto> webviews?
19:14:05 <kmc> I mean I'm not sure I'd say "rust does"
19:14:11 <kmc> i'm sure someone has a library that does it with a procedural macro
19:14:40 <kmc> i don't think the 'regex' crate does
19:14:52 <kmc> it suggests using lazy_static so that each regex is compiled once, but that still happens at runtime
19:15:10 <ais523> looking it up, it seems regex! isn't the recommended way of doing things that the moment
19:15:13 <kmc> I'm also sure someone has written a Lisp or Scheme regex library that does it at compile time
19:15:16 <kmc> ok
19:15:25 <ais523> so it's more like it could be done in Rust but isn't the default
19:15:30 <kmc> yeah
19:15:32 <ais523> (that's disappointing, I thought it would be)
19:15:42 <bunnyocto> muahaha. suck it rust.
19:15:48 <bunnyocto> no, but rust is cool.
19:15:57 <ais523> I think Perl compiles regexes on first use rather than compile time, too
19:15:59 <bunnyocto> static memory safety is a neat concept.
19:16:05 <ais523> not sure though, its optimiser does weird things sometimes
19:16:30 <bunnyocto> it's just that most oldschool programmers are too scared of it yet so few use it
19:16:54 <bunnyocto> even newschool programmers
19:17:10 <bunnyocto> we had "tech discovery" meetings back at the place I worked
19:17:35 <bunnyocto> I introduced Rust at one point.
19:18:07 <bunnyocto> I don't know. People just aren't really fond of learning new concepts I guess.
19:18:45 <ais523> hmm, I suspect that most compilers will not generate the fastest asm for verifying that a string consists only of digits on any input, short of outright writing the asm
19:18:55 <bunnyocto> so we used golang. Which is awesome... better than python, C or Java
19:18:57 <bunnyocto> or C#
19:20:35 <kmc> Rust has a steep learning curve
19:20:42 <kmc> because it tries to provide all of safety, convenience, and performance
19:20:48 <kmc> this means it's nearly as complex as C++
19:20:55 <kmc> but the complexity is more necessary and less historical/accidental
19:21:22 <kmc> Rust is largely an attempt to take modern C++ concepts and build a similar language without the historical baggage
19:21:27 <kmc> and in fact those concepts are getting backported into C++
19:21:33 <kmc> (which will make it even more complicated, but that's life)
19:22:44 <kmc> Rust is a cool language with an annoying community and dickish leadership
19:22:50 <kmc> that is also life
19:23:03 <kmc> computers suck, people suck too but in a different way
19:24:24 <kmc> the Rust community is like the Haskell community, a bunch of really excited beginners who think Rust will solve every problem under the sun, plus they're full of themselves for being 'friendly and welcoming' but they don't want to hear about it if your experience is to the contrary
19:25:27 <kmc> 11:18 < ais523> hmm, I suspect that most compilers will not generate the fastest asm for verifying that a string consists only of digits on any input, short of outright writing the asm
19:25:33 <kmc> i've seen LLVM do some clever things in that direction
19:26:08 <kmc> if you have a switch-case with two branches over a set with less than 64 elements it will make a bitmask and use that as an immediate operand
19:27:56 <kmc> https://gcc.godbolt.org/z/Ce-LBo
19:28:35 <ais523> hmm: https://godbolt.org/z/n3PKGD
19:28:44 <kmc> ok gotta go
19:28:46 <kmc> ttyl
19:29:00 <bunnyocto> https://pastebin.com/WYsqm4aj is how I'd probably go about it if we're talking about no signs involved :D
19:29:09 -!- APic has quit (Quit: Boot tut gut™.).
19:30:11 <bunnyocto> not tested yet
19:31:37 -!- myname has quit (Ping timeout: 240 seconds).
19:33:44 <ais523> I suspect the correct option is probably to use the asm instruction VPCMPISTRI, but good luck getting a compiler to generate it
19:34:37 <ais523> (I put in the check to make sure that the string's starting address was divisible by 32 to make sure that any resulting overread wouldn't cause issues with page faults, in case the compiler was scared to do an overread and that was suppressing the optimisation)
19:36:00 <ais523> this would be particularly good on long strings or if you were checking lots of different strings in a loop (because you can loop-invariant-code-motion the loading of the list of permitted character ranges)
19:38:51 <bunnyocto> so the string has to be <=128 bytes for pcmpistri?
19:38:57 -!- APic has joined.
19:39:00 -!- Jefe has left ("Leaving").
19:39:03 <ais523> bunnyocto: <= 128 bits for each call to pcmpistri (16 bytes)
19:39:11 <ais523> however it lets you know if the whole segment of the string you're looking at matches
19:39:22 <ais523> if it does you can just look at the next 16 bytes, and so on
19:39:34 <ais523> the length limit makes sense because this is using a hardware string-tesing circuit
19:39:35 <bunnyocto> yeh but what about \0?
19:39:43 <ais523> pcmpistri handles \0 itself
19:39:52 -!- b_jonas has joined.
19:39:58 <ais523> it has a friend pcmpestri for length-prefixed strings
19:40:22 <bunnyocto> so it stops at a \0?
19:41:02 <ais523> yes
19:41:33 <ais523> the basic idea is to use pcmpistri in a similar way to strspn to check how many bytes at the start of the string are digits
19:41:39 <ais523> then you look for the byte just beyond those and see if it's \0
19:41:49 <ais523> if it is, the string's entirely digits
19:42:01 <ais523> (you can then adjust for ensuring the string's nonempty, checking for +/-, etc., if you want to)
19:42:24 <ais523> if pcmpistri tells you that the 16-byte section of string you're looking at has 16 digits in it, you have to move onto the next section, otherwise you're done
19:42:36 -!- myname has joined.
19:44:15 -!- FreeFull has joined.
19:44:18 <ais523> (16 digits consecutively at the start, that is)
19:44:55 <ais523> unfortunately it wouldn't work for UTF-8 (you could make it work for UTF-16 though, at least if you confined yourself to ASCII digits)
19:45:02 <ais523> or ,hmm
19:45:11 <ais523> actually it does work for UTF-8 if you confine yourself to ASCII digits
19:45:25 <ais523> because you don't actually have to parse it
19:45:53 -!- xkapastel has joined.
19:53:57 <bunnyocto> my neighbour is singing since like 3 hours
19:54:43 <bunnyocto> ais523: thx for your explanations.
19:56:16 <bunnyocto> PUNPCKLDQ
19:56:20 <bunnyocto> nice mnemonics.
19:58:32 <b_jonas> "I suspect that most compilers will not generate the fastest asm for verifying that a string consists only of digits on any input, short of outright writing the asm" => the problem with that stuff is that "fastest" depends on whether you are allowed to assume 31 readable bytes after the end of the string or not, and we still don't have interfaces to malloc that even let you allocate vectors that way, or
19:58:38 <b_jonas> reference types or containers or any high-level abtstractions to track that info
19:59:30 <b_jonas> "I put in the check to make sure that the string's starting address was divisible by 32" => yes, that
19:59:48 <ais523> oddly enough, C doesn't allow aligned pointers as function arguments
20:00:07 <ais523> it supports aligned pointers but there's an explicit rule that prevents you putting an _Alignas on a function argument, or sneaking one in via a typedef
20:00:29 <bunnyocto> hu?
20:00:30 <bunnyocto> why?
20:00:34 <ais523> (16 would actually be enough alignment, but I put 32 just in case the compiler could think of something clever to do with the 256-bit vector units)
20:00:40 <b_jonas> ais523: sure, but you can put those things in a struct
20:00:48 <bunnyocto> why does it care whether a char* is aligned?
20:00:55 <ais523> bunnyocto: it lets you overread safely
20:01:14 <ais523> on basically all modern processors, there's a limit to the memory protection's granularity
20:01:28 <ais523> so, say, memory can only go from readable to unreadable at a multiple of 512, or a multiple of 2048
20:01:46 <ais523> so if you know the address is divisible by 16, either the first byte is unreadable or the whole thing is readable
20:01:58 <b_jonas> on a multiple of 4096 bytes on x86 actually
20:02:07 <ais523> I forgot the modern number
20:02:17 <b_jonas> and I think 8192 in linux userspace, but I'm not sure of that
20:02:17 <bunnyocto> yeh yeh page sizes and what not.... but how does this matter for this purpose?
20:02:18 <ais523> it keeps changing, wasting 4K of memory isn't really a big deal nowadays
20:02:38 <ais523> because if you have a string like "12", it might be right at the end of a page
20:02:45 <bunnyocto> if I make like uhm void bar() { char* __align(16) blubb = "blubberlutsch"; foo(blubb); }?
20:02:47 <ais523> so you can't read the first 16 bytes in case there's unreadable memory just after it
20:03:10 <ais523> bunnyocto: that works but the function isn't allowed to know that it was given a pointer that's 16-byte aligned, it just gets a char*
20:03:31 <b_jonas> and, I know I ranted about this a lot, I wish we could eventually transition to larger pages required system-wise, because there's a hard limit that the L1 data cache can be at most 8 pages large, and that's very often the bottleneck
20:04:01 <b_jonas> that reminds me
20:04:17 <ais523> b_jonas: huh, why the limit?
20:04:18 <b_jonas> did izabera return after she asked that question about graph algorithm to which I first gave a stupid answer?
20:04:33 <izabera> hi
20:04:37 <b_jonas> hello
20:04:40 <ais523> like, it doesn't seem significantly harder to make the L1 cache bigger by doubling the page size, and by doubling the number of pages it supports
20:04:41 <izabera> i have returned
20:05:08 <ais523> in either case the main cost is going to be the silicon that actually stores the values in the cache, rather than the control circuitry
20:05:21 <ais523> and if the control circuitry is the issue, you might want to make cache lines longer instead
20:05:34 <b_jonas> ais523: the L1 cache has to have a very low latency, so it needs to find which cache line to return when it only knows the linear address, and then verify if that's correct after the physical address is computed.
20:05:34 <ais523> is the issue actually the TLB rather than the L1 cache? that would be more believable
20:05:57 <b_jonas> ok wait, I'm explaining that wrong
20:06:01 <izabera> b_jonas: i ended up running bfs from each node
20:06:14 <ais523> b_jonas: oh, the L1 cache works on virtual addresses? I'd have expected it to work on physical addresses (as the TLB that caches virtual addresses)
20:06:15 <izabera> easily parallelizable
20:06:23 <b_jonas> the L1 cache needs to have a very low latency, so it has to do most of the computation when only the linear address is available, the physical isn't
20:06:52 <b_jonas> so how it works is that it finds the bunch of 8 cache lines whose address matches the linear address modulo the page size, then when the physical address arrives, it chooses one of those
20:07:00 <b_jonas> it has to be able to do this on two reads in parallel by the way
20:07:07 <b_jonas> or one read and one write
20:07:26 <b_jonas> in order to keep the latency low, it can't have more than 8 cache lines with the same address modulo page size
20:07:48 <ais523> that's not actually a limit of 8 pages, though; it's just a limit of 8 addresses that are on the same place within the page
20:07:58 <b_jonas> the size of the individual cache lines, which happens to be 64 bytes on x86, doesn't influence this
20:08:00 <ais523> there are a huge number of caching effects that have limitations like that
20:08:08 <b_jonas> ais523: yes, 8 page sizes of total data
20:08:38 <b_jonas> 32 kilobytes, divided to 64 bytes sized cache lines, such that each address modulo 4 kilobyte has at most 8 cache lines
20:09:13 <ais523> you could have more while retaining the virtual address lookup behaviour, though
20:09:56 <b_jonas> "it doesn't seem significantly harder to make the L1 cache bigger by doubling the page size" => you can do that only if the OS guarantees that there can't be small pages anywhere, not even in other processes, because processes can share memory, and even then the cpu would need extra circuitry to handle the compatibility node for old OSes that can't guarantee that, so it's a bit messy
20:11:29 <ais523> b_jonas: no, if you end up with more than 8 addresses in cache that would clash with each other, you just evict one to avoid hte problem
20:11:46 <ais523> but if the addresses happen to not clash, you can go with it
20:12:09 <b_jonas> ais523: no, it's definitely the L1 cache, not the TLB cache. the TLB cache is improved by making most pages large pages (2 megabyte in x86_64), while the OS can still allocate some normal 4 kilobyte sized pages, the TLB can handle the mixing reasonably efficiently
20:13:14 <b_jonas> ais523: yes, you evict one if you have more than 8 addresses that clash, which means that the total L1 data cache (on a single cpu core) can be no larger than 32 kilobytes total, or 512 cache lines of 64 bytes if you wish.
20:13:59 <b_jonas> and 32 kilobytes is rather small, it would be nice to be able to increase that for some applications, because the L1 data cache is often the bottleneck
20:14:05 <b_jonas> it isn't always for all computations, obviously
20:14:30 <bunnyocto> bottleneck for what...
20:14:31 <b_jonas> these cache lines could be from 512 different pages possibly
20:14:38 <bunnyocto> back in the old day we had 333mhz something
20:14:43 <bunnyocto> and it was running smoothly
20:14:48 <bunnyocto> it should run incredibly fast now
20:14:48 <b_jonas> or they could contain the entirety of 8 pages
20:16:40 <bunnyocto> also excel 2019 probably has still the same set of features as good old lotus
20:17:19 -!- ais523 has quit (Ping timeout: 265 seconds).
20:22:57 <b_jonas> izabera: good, that's what I figured too eventually. you may have read my answer in the logs.
20:25:55 <bunnyocto> this is really interesting.
20:26:12 <bunnyocto> I don't think that current basic software is any more advanced than like 15y ago
20:26:27 <bunnyocto> sure... it looks less pixely but other than that
20:32:06 -!- ArthurStrong has quit (Quit: leaving).
20:34:46 -!- ais523 has joined.
20:50:49 -!- ais523 has quit (Remote host closed the connection).
20:52:01 -!- ais523 has joined.
21:12:53 -!- bunnyocto has quit (Remote host closed the connection).
21:13:41 -!- myname has quit (Ping timeout: 276 seconds).
21:19:52 -!- myname has joined.
21:53:09 -!- ais523 has quit (Quit: quit).
22:12:28 -!- xkapastel has quit (Quit: Connection closed for inactivity).
22:39:21 <b_jonas> so the UK general election was today?
22:39:54 -!- aloril has quit (Ping timeout: 265 seconds).
22:40:09 <fizzie> Yes, the polling places just closed 40 minutes ago.
22:40:51 <fizzie> My phone tried to keep telling me how to vote, I don't think it realizes I'm not enfranchised.
22:44:31 <b_jonas> fizzie: you lied to websites that you're older than your real age because they don't allow you to use the website or buy drugs otherwise, and now your lie bites back in the form of election ads?
22:45:44 <fizzie> I don't think it's that.
22:46:46 <fizzie> I did want to share a picture of one of the most misleading infographics from the ads in our mailbox, but I threw it away already.
22:47:29 <b_jonas> you may be able to find a copy online
22:47:29 <fizzie> It had a bar chart for Tories, Labour and Lib Dems, and the bar heights were not to scale.
22:47:59 <b_jonas> was it one of these plots that show bars in 3D with exaggerated perspective for no reason?
22:48:49 <fizzie> It was flat, but the height difference indicating a 5 percentage-point difference was more or less the same as that for 9.
22:50:09 <int-e> well the glyphs are similar too so what's your complaint...
22:50:33 <fizzie> They had also drawn an up-pointing triangle on top of their own bar, but it didn't make any more sense even treating the top of the triangle as their bar height.
22:51:06 <b_jonas> what if you consider the areas of the bars, with the triangle included?
22:51:30 <fizzie> Hmmm, well. Too late now.
22:51:43 <b_jonas> search the web, there's probably a copy online
22:53:14 -!- aloril has joined.
22:54:13 <fizzie> I did find an article about generally misleading leaflets -- https://www.bbc.co.uk/news/uk-politics-50375532 -- though this is mostly about dodgy data and other misrepresentation, rather than graphical tricks.
22:56:23 -!- b_jonas has quit (Ping timeout: 250 seconds).
22:57:15 <fizzie> IMO they should just stop with this FPTP stuff.
22:57:26 -!- b_jonas has joined.
22:58:12 <b_jonas> another of those stupid power outages that they do some nights, when electricity goes down in the whole block for two minutes, then stays up for 10 to 15 minutes, then goes down for 2 minutes again
22:58:24 <b_jonas> I don't know why they do this so often
22:58:38 <b_jonas> so expect me to disconnect again within 10 minutes
23:00:23 <b_jonas> the internet takes two more minutes to come back after the power of course, and even mobile phone disconnects for half a minute at the start of the power outage before the aggregator for the cell tower starts up
23:09:30 -!- izabera has quit (Ping timeout: 268 seconds).
23:10:03 -!- LBPHacker has quit (Quit: Entering cryogenic sleep in three, two, on--).
23:10:18 -!- LBPHacker has joined.
23:10:18 <b_jonas> hmm, maybe they're skipping the second outage this time?
23:10:42 -!- izabera has joined.
23:11:21 -!- myname has quit (Ping timeout: 268 seconds).
23:17:31 -!- subleq has quit (Ping timeout: 268 seconds).
23:30:41 -!- myname has joined.
23:33:59 -!- subleq has joined.
23:35:17 -!- myname has quit (Ping timeout: 240 seconds).
23:39:15 -!- myname has joined.
23:39:16 -!- Cale has quit (Remote host closed the connection).
23:40:31 <esowiki> [[Oof]] M https://esolangs.org/w/index.php?diff=67917&oldid=67916 * IFcoltransG * (+94) Shamelessly plagiarised some categories from Ook!
23:45:15 <esowiki> [[Oof]] M https://esolangs.org/w/index.php?diff=67918&oldid=67917 * IFcoltransG * (+5) Moved to joke langs cat (w/ permission of author)
23:47:03 <esowiki> [[Joke language list]] https://esolangs.org/w/index.php?diff=67919&oldid=67886 * IFcoltransG * (+10) /* Brainfuck derivatives */ + Oof (from serious lang list)
23:48:22 <esowiki> [[Language list]] https://esolangs.org/w/index.php?diff=67920&oldid=67911 * IFcoltransG * (-10) /* O */ Move Oof to joke langs list
23:49:30 <esowiki> [[Oof!]] M https://esolangs.org/w/index.php?diff=67921&oldid=8487 * IFcoltransG * (+34) Added hint for disambiguation w/ Oof
23:51:38 -!- Cale has joined.
23:57:22 <esowiki> [[Talk:Grime MC]] https://esolangs.org/w/index.php?diff=67922&oldid=67908 * Salpynx * (+3598) clarifying this was NOT meant to be a finite prescriptive language, but interpreter should still be possible, just never complete
←2019-12-11 2019-12-12 2019-12-13→ ↑2019 ↑all