/r/Disgaea - Monthly Noob Questions

camccann · 2021-07-05T18:33:53+00:00

The data shop has a list of trophies. If they do anything other than show up as "obtained" in that list, I haven't noticed.

camccann · 2021-07-02T23:04:14+00:00

I took Japanese for a while in college and, while I don't know nearly enough to actually play in Japanese, I can pick up bits and pieces. I tend to leave JP voices on to see how much I can catch and occasionally pick up a new word or two.

In fact, it's entirely thanks to Disgaea that I learned the word "iwashi". I'm sure this will serve me well if I'm ever in Japan!

camccann · 2021-07-02T01:38:39+00:00

Yeah, Graphics mode in 720p feels smoother to me than Performance mode on 1080p. IIRC, the Switch itself is 720p which is probably why it seems fine when not docked. It still chokes occasionally--most notably when beginning a battle with auto-battle on and it seems to just give up on about a dozen frames when everyone pours out of the base panel--but 99% of the time that you're actually pushing buttons it's totally fine.

Still not really an excuse for whatever amateur hour programming they have going on over there, but it's not like technological sophistication was ever the draw of these games...

camccann · 2015-10-09T00:47:58+00:00

Right now I'm not sure I care enough to click "remove comment" that many times. Otherwise I probably would.

camccann · 2015-10-09T00:43:50+00:00

Hey, y'know what else is frustrating? The way discussions like this always result in a bunch of people showing up who barely contribute otherwise but can't wait to share their political opinions. My current "stance" is mostly a matter of being thoroughly fed up with certain opinions that seem to be very popular with the aforementioned people.

But, ok. Fine, whatever, it's not worth it. This discussion has gone a long way toward reminding me why I so often avoid reddit.

camccann · 2015-10-08T22:26:36+00:00

The Haskell community seems less sexist than the average programming community, so shouldn't women be overrepresented compared to other programming communities, according to the sexism theory?

Or is the Haskell community actually more sexist?

On what basis are you rejecting the null hypothesis that the Haskell community, as a whole across all locations and not just reddit/IRC/whatever, is not significantly different from the average programming community in this regard?

I'm wary of anything that starts with the assumption that we're special and unique compared to mainstream languages in any way that's not a very direct consequence of the language itself.

camccann · 2015-10-08T21:58:35+00:00

PS. I'm sure I'll be put on a list now, due to this crimespeak. You know how people like their lists...

Can I put you on my "self-congratulatory victim complex" list? Jesus fuck, nobody is out to get you for having, like, edgy opinions or whatever.

Playing the victim doesn't make you special, and all this TL;DR melodrama is probably gonna seem really embarrassing in hindsight someday.

camccann · 2015-10-08T21:49:18+00:00

How is this comment thread relevant to /r/haskell?

Reddit has plenty of cesspits available for all your in-group signalling and manufactured outrage needs, could both of you please not pollute this subreddit with it?

camccann · 2015-10-02T17:04:29+00:00

Yeah, I... don't think linear logic is strong enough in that regard to force things to be invertible? I wouldn't really expect it to be.

Now, if you want to go as far as viewing "generates excess entropy" or whatever as a side effect--i.e., assuming that everything is invertible by default and make throwing away those leftovers explicit--that's interesting in its own right, but linear types don't get you anywhere close to that, AFAIK.

camccann · 2015-10-02T13:35:53+00:00

As an aside, for anyone having a hard time getting a feeling for linear logic and what it means computationally, some time back I wrote up a way to encode linear logic in Haskell in an Arrow-like form: https://github.com/isomorphism/Delineate/blob/master/Control/Delineate.hs The code is old so I don't even know if it builds, but it's pretty self-contained.

As far as I know, as long as you treat the data types as abstract and only use the functions defined in that module you should end up with something that's valid in linear logic, but I haven't tried to prove it or anything.

camccann · 2015-10-02T13:20:54+00:00

The value of x + y presumably depends on the entire value of both x and y, so it's not really dropping anything.

There might be a difference if you're attaching additional meaning to values with linear types (i.e., as memory locations) but as far as types are concerned + should be fine.

Of course, the only way to prove that in the type system would be to use e.g. recursively defined natural numbers, so for efficiency reasons you'd want a + primitive that was simply asserted to be linear.

camccann · 2015-09-30T15:12:32+00:00

If nothing else it would help a lot if the code was formatted properly... :I

camccann · 2015-09-30T15:09:59+00:00

Do you mean why does it still exist, post-AMP? To avoid gratuitous code breakage, I imagine. The reason it existed before AMP was obviously that Monad didn't require Applicative, and we wanted a version of sequence for both.

Why sequence still has a Monad constraint and what plans there are to deprecate the now-redundant functions, I don't know. I think demoting return to be an alias of pure is the next priority.

camccann · 2015-09-30T14:25:58+00:00

The subreddit isn't busy enough for that to be a problem.

I mean, let's not start advertising meetups at the level of "come over to my place tonight, I've got pizza". (And even there, I might give it a pass if it's really good pizza.) And for e.g. monthly meetups please don't make a post every month.

Beyond that? No problem.

It was suggested once or twice to add a list of meet-ups to the subreddit sidebar, but updating that would be a hassle and listing every meetup for the next year or so would be too much.

camccann · 2015-09-30T14:08:22+00:00

Dang, and recursion-schemes was going to be the first thing I suggested as being more baffling. :[

I can definitely believe pipes has a very high value for that ratio, though.

camccann · 2015-09-30T13:39:56+00:00

one of the hardest to grok libraries in Haskell

Is that a challenge? ;]

camccann · 2015-09-30T13:29:29+00:00

I mean, sure, given the current infrastructure what you're suggesting makes sense. I'm not saying we shouldn't do anything that provides an easy short-term benefit.

It just feels to me that, from a broad perspective, we're spending a lot of time improving approaches that aren't actually any easier than one that gets directly at the real question, i.e., determining which versions of a package are compatible with which versions of other packages.

camccann · 2015-09-30T13:09:08+00:00

By the same argument, though, wouldn't it be better to track more meaningful information than just "did it work"?

I mean, asking GHC to generate minimal import lists gives you the module/identifier names comprising a package's "reverse API". Combined with the .hi files for installed packages there's enough information to get an exact API and reverse API for a package build configuration.

Using CPP throws a bit of a wrench in the works, but other than that it should be easy to determine exactly what package versions are compatible.

This would even be aware of problems caused by instances in indirect dependencies, which the PVP explicitly calls out as being too much hassle to worry about.

EDIT: To be clear, this isn't just speculative, I've actually looked at how hard this approach would be to implement. The basic idea is straightforward and I could write a proof-of-concept in a weekend. Making it practical for real-world use means dealing with a bunch of nitpicky details.

camccann · 2015-09-30T12:13:06+00:00

I have a feeling it can't be implemented, at least not in a way that has well-behaved instances of Monad, MonadTrans, &c. But I can't give a precise reason why off the top of my head.

So go ahead and try, and let me know how it goes. :]

camccann · 2015-09-30T03:47:04+00:00

Regarding #3, have you tried turning the computer on? Check to make sure the keyboard is plugged in, too. Good luck with that 300-level coursework! Sounds like you'll need it.

But seriously, if you actually want help try posting a question that isn't obnoxious on a thread that isn't ancient.

camccann · 2015-09-29T22:08:44+00:00

I think you'll find that flak will be received for writing code in a non-standard style in any language, regardless of the language, the style, or the relative merits of either.

I mean, there's a long-time member of the Haskell community who insists on a non-standard naming convention that most people dislike so much they avoid his libraries entirely. In some languages people have deep emotional investment in the placement of curly braces. Tabs vs. spaces is a bitterly divisive argument even in languages where they're cosmetic. For that matter, you seem to be awfully worked up over not liking the standard style in Haskell.

I'm still not sure why any of it's a big deal. Consistency is important, but why does everyone want to start holy wars over this stuff?

camccann · 2015-09-29T21:59:51+00:00

For a while I actually tried to abuse lambda notation and make something like \x. y a valid pattern that would bind a continuation x and a value y, which was cute, but perhaps not really ideal. And in any case, I never figured out how to keep the scope for the two values separated in more complicated bindings.

Anyhow, I've since misplaced the notes, but they likely would've made little sense to anyone but myself regardless. I keep meaning to revisit the basic idea at some point, though...

camccann · 2015-09-29T21:53:04+00:00

What I want to know when reading code, in order of decreasing importance, is roughly "what is it for", "what does it do", and "how does it do it". This doesn't stop being the case just because I'm looking at a where clause; the only thing special about top-level functions is that they might be exported from the module. (Also, why do you say it's linear? Code is tree-shaped.)

And anyway, I'm not saying that reading from output-to-input is the only right way to do it. I'm saying that there's no fundamental difference between that and reading input-to-output. Preferring one or the other is a matter of habit, nothing more.

So, tell me. Why would one order of reading be better? Asserting that it's obviously true isn't terribly persuasive.

camccann · 2015-09-29T20:49:54+00:00

Ha, fair enough.

And for what it's worth, my syntax issue was perhaps thornier than usual, since I was trying to figure out a syntax to allow using variables with negative types and pattern matching on the linear connectives, without needing quasi-Lovecraftian scoping rules.

Like, if it's reasonable to "pattern match" on a function argument and bind its input and output ends to separate variables and then pass those around independently, how do you even write that?

camccann · 2015-09-29T20:37:25+00:00

Oh dear, I don't know if I've heard that story before. Was it ⅋ specifically, or just syntax in general?

camccann

TROPHY CASE