I don't have links at the ready, but I have seen multiple instances of TD brigading with pinned topics. I am not saying I know for a fact it has happened recently, but it has happened. I don't blame you for wanting evidence, but their track record doesn't give them the benefit of the doubt.
The nerve you have to accuse, then say you don't have links of proof, then demand links of proof from me when I say I've seen brigading. They are both anecdotal and yet you feel like yours is right and mine is laughable.
Neither side can say who is brigading for sure but only one side is getting banned.
The sanders subreddits and /r/politics brigading is prevalent from what I've seen. Hell, it was an issue on one of the Democratic debates about his supporters brigading. Warren seemed to think it was bad.
Anti-brigading rules were enacted on T_D and you can still see them in full force. I have never seen any pinned brigading posts. Other subs have not done the same an yet they haven't even been quarantined.
I don't have any links and you just said you don't have any links with proof of T_D brigading. Why would I keep track of that? I'm not the company banning users for their ideologies and pretending it was because of "brigading" while providing no proof. I'm the guy saying it's an unpassable purity test and no sub would be safe under the same scrutiny. It's targeted and wrong.
All of this is anecdotal and that's how you know it's targeted. There hasn't been one sliver of evidence that T_D mods supported brigading.
Yes there are probably a lot of reports, but that's because it's a political subreddit in this climate, of course there are, especially when everyone else on the site hates them.
Reddit is now officially 100% an echo-chamber. Congrats you're on the way to be Digg. Good riddance.
Without any pattern specified, the code you posted will accept emojis as input, it's not a good choice for a numeric only field. It's also intended for phone numbers...
Woops, for some reason I read the title as "Why the GOV.UK Design System team changed the input type for phone numbers" - removed my comment since it doesn't apply.
>We continue to investigate the issues with GitHub services and will shift to a slower update cadence to provide more meaningful updates going forward.
Translation: our shitty software update practices are now affecting Github, not just Windows!
If anyone from Microsoft is reading this, why is your company so incompetent at software updates in the past few years?
I've read it as "we'll stop posting silly updates to this incident until we actually know something", not "we'll stop rolling out updates to our services".
I'd wage that Microsoft practices had nothing to do with this, but I'll wait for RCA.
You honestly believe that a company the size of GitHub has had their software update practices appreciably change since the acquisition? Relax, GitHub had update issues before and they will have them again.
You should consider doing more research on a topic before trying to present your opinion/viewpoint as fact. You are stating patently false things, which invalidates your credibility.
Perhaps you could enlighten me instead of being arrogant?
The state of prisons is avoidable and due to society not caring enough. Is that a false and ignorant claim? Why? I think you should explain because I think that may claim is patently observable and a matter of fact.
As a non-Haskell-er, this article is impossible to follow. I have tried to learn Haskell a few times, always unsuccessfully. Haskell code is filled with so many Haskell-specific things. I realize the goal isn't to be an 'easy' language, but jeez.
Aside from the horrendous variable naming, I'm having trouble understanding what the author actually accomplished, and why it's necessary for a tool like this to exist in the first place.
Can anyone translate the problem into a more simplified, non-Haskell-specific version?
> jonk :: (a -> b) -> ((a -> Int) -> Int) -> ((b -> Int) -> Int)
I have no idea what this line means.
To me, it looks like he wants to write a transformer that matches a specific signature, and he uses a tool that tells him which functions can fit the 'hole' he has in the code, based on types. If I'm correct (I'm assuming I'm not), how is this different than intellisense in an IDE that tells you a list of type-valid functions/variables? Why is this a necessary part of the Haskell coding process? My first instinct is that this demonstrates a problem with the language, if something like this is necessary.
Appreciate anyone that tries to explain. I know most of my assumptions are probably wrong.
> I have tried to learn Haskell a few times, always unsuccessfully
I suspect that people wanting to learn Haskell actually want to learn a statically typed functional programming language. And if you also want that language suitable to everyday problems, the kind of things you are dealing with at work, then Haskell is probably not the best one to start with.
I love how Scott Wlaschin presents statically typed functional programming languages as straightforward and pragmatic solutions to everyday problems:
Once you're comfortable with that (and the way it is presented here really isn't very complex) then Haskell becomes a lot easier to understand.
But Haskell is very distracting because it is much more expressive and complex than than ML dialects for example, so it will be a big learning curve before someone is comfortable reading someone else's Haskell code. For other statically typed functional programming languages (f.i. OCaml/ReasonML, F#, Elm) that is not the case.
Any time you see a '::', it means 'the thing on the left hand side has the type on the right hand side'. As such, you should parse this line as 'there is a function jonk that has a type '(a -> b) -> ((a -> Int) -> Int) -> ((b -> Int) -> Int)'.
A simple type in Haskell is `Int -> Bool`. This means a function that takes a value of type Int and return a value of type Bool.
Now `Int -> (Int -> Bool)`, means 'a function that takes a value of type Int and returns a function that takes a value of type Int and returns a value of type Bool'. And because currying, this can be also read as 'a function that takes a value of type Int, then a value of type Int, and returns a value of type Bool'. As in, if you first call the function with Int, you'll be getting an `Int -> Bool` in return. Then you call it again with Int, and then you get a Bool. Because of how we define precedence of things, this signature can also be written as `Int -> Int -> Bool`, which makes it a bit more readable. However, if you really want to grok Haskell you need to grok this equivalency early on.
Compare this to `(Int -> Int) -> Bool`. This means 'a function that takes a function that takes a type Int and returns a type Int, and returns a type Bool'. By this point you should see that the type is more readable than my human language descriptions.
One last thing you're missing is the types 'a' and 'b'. You'll notice that these start with a small letter, and that's because they are generic types. It means that in practice this function can be called with whatever type instead of 'a' and 'b' in the declaration, it's just that it must be the same type for all cases of 'a' and 'b'. For a simple example, let's look at a function that takes two Ints, a Bool, and returns the first Int if the boolean is true, otherwise the second. The type signature for this in Haskell would be `foo :: Int -> Int -> Bool -> Int`. However, the function doesn't really care that these are Ints - they might as well be any values. As such, we can define the function signature as `foo :: a -> a -> Bool -> a`. This is is naturally similar to generic in C++, Typescript or Rust.
Armed with this knowledge (albeit maybe explained a bit better - see Learn You A Haskell!) you should be able to read this complex type signature now.
class MyJonk implements Jonk<A, B> {
public Summary<B> jonk(Adapter<A, B> adapter, Summary<A> summary) {
// Equivalent to the author's jonk ab aii = _
}
}
Looks like we'll need to create a Summary<B>, so let's do that:
class MyJonk implements Jonk<A, B> {
public Summary<B> jonk(Adapter<A, B> adapter, Summary<A> summary) {
return new Summary<B>() {
public int summarize(Statistic<B> st) {
// Equivalent to jonk ab aii = \bi -> _
}
}
}
}
Following the article, notice that there are a lot of signatures returning int around; pick summary rather than st;
class MyJonk implements Jonk<A, B> {
public Summary<B> jonk(Adapter<A, B> adapter, Summary<A> summary) {
return new Summary<B>() {
public int summarize(Statistic<B> st) {
return summary.summarize( /* ...? */ );
// Equivalent to jonk ab aii = \bi -> aii $ _
}
}
}
}
Skipping some intermediate steps, we end up eventually with the solution which maps to the haskell
// equivalent to jonk ab aii = \bi -> aii $ \a -> bi $ ab $ a
class MyJonk implements Jonk<A, B> {
public Summary<B> jonk(Adapter<A, B> adapter, Summary<A> summary) {
return new Summary<B>() {
public int summarize(Statistic<B> st) {
return summary.summarize(new Statistic<A>() {
public int valueOf(A a) {
return st.valueOf(adapter.adapt(a));
}
});
}
}
}
}
Do you have any plans to open-source all or parts of the game or underlying platform? Do you plan on developing this into it's own 'game engine' or plan on going further than this initial game? I've been following a few multi-threaded game projects and they are always very interesting to read up on, best of luck!
Yes, open sourcing at least the client part of the game is something that I'm very interested in. I'm not entirely sure when or how this will happen just yet, it will depend greatly on the commercial success of the game. But it's definitely my preferred course of action for the future.
EDIT: I'm not really interested in separating or spinning off the engine, but you will have few problems turning the game into something entirely different.
While I would advise against open sourcing the core of the game, opening the client api may be a good idea - perhaps others can write clients for it, but there may be issuing around people making bots to cheat the game.
I wrote a "bot" myself in the form of a network simulator for general and load testing of the server. If players were to automate the game I'd be more than happy to make a special server where we could show off their work. Making an agent navigate an open 3D space and performing planned tasks would make for an impressive demo for all parties involved.
That might make a good first open source release actually, if it implements a good chunk of the game protocol you might be able to use it to get a rough idea for the types of ideas people would want to run with, and it would also allow people to hit the ground running actually implementing ideas against the engine quickly.
A separate test server would be a very good companion idea.
I hadn't even considered this before, but I see your point! Getting a "core" part of the game's "API" released first allowing players to fiddle around writing a bot sounds like a beautiful gift for the technically inclined players. Because of the small(er) scope it could help iron out wrinkles in the open-sourcing of the client as a whole later on. Thanks!
Is there any ELI5-type explanation for us non-mathers? Whenever I see stuff like this, I start trying to actually understand it, then fail miserably just trying to google terms I'm not familiar with. Is advanced knowledge of these math principles required to understand the significance of this page, or why it is interesting?
[The following isn't really "like you're five", but given how long it is already that's probably just as well.]
Proofs and formal systems, and why we're kinda screwed
Mathematicians like to prove things. What we would really like would be to be able to find, for every mathematical statement, either a proof that it's true or a proof that it's false.
It wasn't until the early 20th century that mathematicians got a clear enough idea of what proof is to figure out whether that could be done. And it turns out it can't! That was proved in 1931 by Kurt Goedel, who did something that these days is very familiar to anyone in computing but was novel then: he found a way to encode mathematical statements, and sequences of mathematical statements, as numbers, in such a way that properties of those statements turn into properties of the numbers, so that you can use ordinary mathematics to reason about them.
This enabled him to show that if you have any system for doing mathematics that (1) is powerful enough to describe ordinary arithmetical statements and (2) is simple enough that you can check mechanically what is and isn't a proof, then there are statements that that system can neither prove nor disprove. (With a proviso I'll come to in a couple of paragraphs.)
So much for the hopes of mathematicians.
Anyway, despite that setback, mathematicians didn't abandon the idea of building up all of mathematics in some nice simple formalized system in which we can prove and disprove things. We still like to do that, and have come to terms with the fact that there will be things we can neither prove nor disprove.
... Unless the system we're working in happens to be inconsistent, meaning that there's some proposition that it can both prove and disprove. In that case, what actually happens is that it can prove everything, which is of course completely useless. So far as we know, the systems we like to use aren't inconsistent. It would be nice to prove they aren't -- but there's a nice variant of Goedel's theorem that says not just "for any system that isn't inconsistent, there are propositions it can't decide" but "for any system that isn't inconsistent, a formalized statement of its own consistency is a proposition it can't decide".
Once, again, so much for the hopes of mathematicians.
The particular formal system called ZFC
One particular nice simple formalized system is called ZFC, which is short for "Zermelo-Fraenkel set theory with the Axiom of Choice". That's a bit of a mouthful. So, "set theory" means that the basic idea we're starting with is that of a set of things. (In order to do mathematics, we certainly need some idea like that. It turns out that taking it as the foundational idea works fairly well.) Zermelo was a mathematician who came up with one fairly good way to do that. Fraenkel was another mathematician who improved Zermelo's system.
The "Axiom of Choice" -- the C in ZFC -- is a rather technical statement in set theory that turns out to be (1) "obviously true" according to some mathematicians' intuition, (2) useful for proving things we care about, and (3) something that plain old ZF, without the C, can neither prove nor disprove. (Unless, as usual, ZF is actually inconsistent.) In particular, this means that if ZF is a consistent system -- if it isn't able to prove 1+1=3 -- then ZFC is as well. (Because if you could get a contradiction out of ZFC, you could use it to prove not-C within ZF.) So adding the Axiom of Choice to ZF is "safe"; it can't create contradictions that weren't already there. And, since it's useful, we tend to keep it around.
[You can skip the next two paragraphs if you like. They describe the sort of thing you do if you want to build up all of mathematics on top of set theory.]
So, how do you build mathematics out of set theory? The usual sort of game you play is this. We want to be able to talk about numbers. So first of all we find an implementation of numbers in terms of sets. (If you were doing mathematics in a computer you'd want to do roughly the reverse, and build your sets out of numbers.) So we might, e.g., say that 0 "is" the empty set, and then 1 "is" the set containing just 0, and then 2 "is" the set containing just 0 and 1, and so forth. That gets you a load of sets that can (as well as being sets) do double duty as the non-negative integers. Then you construct the integers (negative as well as positive) out of those, and then the rational numbers (ratios of integers) out of those, and then you need some fancier footwork to get the "real numbers" (including things like pi and the square root of 2).
And then you're off to the races, because once you have the real numbers you can do geometry: e.g., three-dimensional space "is" the set of triples (x,y,z) of real numbers, and things like spheres and dodecahedra are just sets of points in space. And now you have numbers and geometrical things, and you can build all the other weirder more abstract things mathematicians like to study in a similar way.
OK, so if we have sets then we have everything, so a formalized set theory is a reasonable thing to try to use as a basis for mathematics. But, ever since Goedel, we know that any formalized system will be unable to decide (i.e., either prove or disprove) some statements we might be interested in.
What that page is about
The Wikipedia page linked here is a list of statements we might be interested in that ZFC is, as it turns out, unable to decide. "Independent of" means "neither provable nor disprovable from".
(There are other systems you can use instead of ZFC. Some of them are other varieties of set theory; some work entirely differently. It usually turns out that you can translate most statements of ordinary mathematics to and fro between them, and that what's provable and what isn't doesn't depend on "implementation details" (e.g., I described one particular way to build non-negative integers out of sets; what if we do it a different way? The answer is usually that it doesn't matter). But some systems are "stronger" than others and can prove or refute more statements. To be usable for mathematics, a system can't be "too much" weaker than ZFC. And since in some sense ZFC encodes most of the things that mathematicians are pretty sure "ought" to be true, most systems people want to use aren't "too much" stronger than ZFC either. A lot of the statements on that page would also be on similar pages about systems other than ZFC.)
A lot of those statements are weird technical things that only a mathematician could care about, and indeed that only a mathematician specifically interested in what's provable from ZFC and what isn't could care about. Some of them are at least potentially interesting to some mathematicians for their own sake, but understanding them generally requires a pile of background that (1) I don't really have myself in most cases and (2) you really don't want me to make this long enough to deal with.
But here's one of them, one of the oldest of them all. Some sets are bigger than others. For instance, {1,2,3} is bigger than {1,2}. What about infinite sets? It's not obvious a priori what "bigger" should even mean for infinite sets, but Georg Cantor (a pioneer of this stuff) found a good answer, whose details we don't need right now. It turns out that the integers are "the same size" as the rational numbers, even though the integers seem like a tiny subset of the rational numbers, but that the real numbers are "bigger". So here's the question: are there any sets bigger than the rational numbers but smaller than the real numbers? This is called the "continuum hypothesis", which is a bit of a stupid name but never mind, and it is neither provable nor disprovable in ZFC.
You can kinda think of it as "the set of real numbers MOD the set of rationals". Kinda. And they're dorked up because the length is infinitesimal, but a countably infinite number of them add up to length 1.
Also note that the construction of the above set requires the axiom of choice. And, as we all know, the axiom of choice is equivalent to the continuum hypothesis in ZFC. So that's how it all fits.
"strictly subsets of the reals", thanks autocorrect.
For example, if ℚ is the rationals and ℝ is the reals then ℚ∪{√2} is a strict superset of the rationals but a strict subset of the reals. However, it still has the same cardinality as the rationals (cf. https://en.wikipedia.org/wiki/Hilbert%27s_paradox_of_the_Gra...)
