Out of curiosity, do you know if these events get taught in history lessons in American schools? I'm by no means throwing shade here - I'm a Brit and our history lessons barely mentioned the unending list of atrocities Britain committed in the name of empire.
Yepper. Trail of Tears, German/Japanese internment are all primary education topics. Now interestingly, I don't think Bush has made it into the history books yet, but I don't have kids, so can't verify current day education materials.
What I find interesting is the bits we leave out. Like we touch on the Banana Republics, but the annex of Hawaii and how that was skulduggerously done is completely skimmed over.
There was, in fact, but the proportion of German (and Italian, also) nationals and citizens of German (and Italian) descent interned was far lower compared to the population of such foreign nationals and citizens than was the case for Japanese nationals and citizens of Japanese descent.
> White people got a pass.
Relatively speaking, yes, but there still were internments, including of US citizens based on German and Italian descent. (But with more individualized review before internment or eviction from coastal areas than was true of citizens of Japanese descent.)
A bit, but it varies some by state and most skip at least some things (do any cover labor struggles in the early 20th century?)
Ours stopped after (an extremely cursory coverage of) the ‘50s and ‘60 civil rights movement because there was no way to cover Vietnam and Nixon and such basically at all without greatly upsetting Republican parents. Anything newer than ~30 years (at the time) was treated as about as handsome-off as religion. Dunno if that’s changed.
No, because f is assumed to be computable from the start, which BB is not (otherwise it could be used as a subroutine in a program that solves the halting problem).
Could you please expand on that ? I haven't found any sources, the only thing that pops up is a bullshit claim by Jordan peterson, that has been debunked as, at best, an oversimplification.
There is nothing more for me to expand on. If you want to do the research some of the starting sources are below.
Peterson has spoken alot on IQ and made several claims about IQ, you'll need to be specific about which claim you mean. Discarding everything the man says is just throwing the baby out with the bathwater, a fallacy/flawed logic.
I don't know about "83" (the number I always see is 100), but: IQ tests are less discriminating at the high end, and test-retest reliability drops at the high end (the "high end" of an IQ test might just be testing grit or fatigue). I think it's widely understood that IQ is unreliably ordinal as scores increase.
You definitely don't need to dip into the Peterson Cinematic Universe to look this up!
One the one hand, this is pretty cool, the API is pythonic and makes quite a lot of sense.
On the other hand, I can't stop myself from thinking about "Greenspun's tenth rule":
> Any sufficiently complicated C or Fortran program contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp.
This doesn't apply directly here, as the features are intentional and it seems they are not bug ridden at all. But I get a nagging feeling of wanting to shout 'just use lisp!' when reading this.
Having written one of these[1] a decade ago and inflicting it (with the best of intentions) upon production code in anger, I can tell you this often leads to completely unmaintainable code. It is impossible to predict the effect of changing a method, tracing a method, debugging a method (where do I put the breakpoint??).
The code reads beautifully though. Pray you never have to change it.
The reason I say "just use haskell" instead of lisp is bc lisp generics suffer from this same problem.
Btw if anyone has a solution to this "generic/multidispatch maintainability in a dynamically typed language" problem I would love to hear it.
I’ve been doing the once-every-few-years deep dive into Smalltalk that I tend to do out of curiosity and this kind of question is one that always comes up for me. The answer there seems to be “the whole environment and philosophy is geared to work that way”; a dynamic language needs a lot of tooling support and interactivity.
No specifically the question of how do you write maintainable code with generic multi-dispatch and highly dynamic languages.
I like Python, but I like static typing too because there’s just less to think about and when I have to learn a new codebase there’s a lot of assumptions I can lean on about how things work; this saves time.
I like the idea of Smalltalk and when you watch Alan Kay or Dan Ingalls talk about it, they make total sense and you have Pharo and Squeak to back it up as in “yes, you can build large systems with this idea”.
But I don’t think you could program Smalltalk and have it be maintainable without everything else the environment brings. Being inside the environment with your objects. The total different approach of sending a message an object doesn’t understand, then having the debugger pop up and then you just implementing that message right there. That’s just an utterly different workflow.
I like the idea in ‘late binding of all things’ and I think the approach of writing a DSL for your problem and then having to write far less code to solve your problem is great. But the objection is then always “okay but what about when someone else has to work with that code”.
I guess what I’m trying to say is, the more dynamic your language is, the more support you need from your tooling to ease the cognitive load while you program, simply because the state-space of things you can do is bigger and not being restricted by types, etc.
> … but what about when someone else has to work with that code.
Someone else has had to work with that code since before Smalltalk escaped Xerox PARC.
1984 "Smalltalk-80 The Interactive Programming Environment" page 500
"At the outset of a project involving two or more programmers: Do assign a member of the team to be the version manager. … The responsibilities of the version manager consist of collecting and cataloging code files submitted by all members of the team, periodically building a new system image incorporating all submitted code files, and releasing the image for use by the team. The version manager stores the current release and all code files for that release in a central place, allowing team members read access, and disallowing write access for anyone except the version manager."
Is it common in Julia to use multiple-dispatch on 3 or more arguments, or just double-dispatch?
Julia definitely made the right choice to implement operators in terms of double-dispatch - it’s straightforward to know what happens when you write `a + b`. Whereas in Python, the addition is turned into a complex set of rules to determine whether to call `a.__add__(b)` or `b.__radd__(a)` - and it can still get it wrong in some fairly simple cases, e.g. when `type(a)` and `type(b)` are sibling classes.
I wonder whether Python would have been better off implementing double-dispatch natively (especially for operators) - could it get most of the elegance of Julia without the complexity of full multiple-dispatch?
It's not uncommon to dispatch on 3 or more arguments. Linear algebra specializations are one case where I tend to do this a lot, for example specializing on structured matrix types (block banded matrices) against non-standard vectors (GPU arrays), you then need to specialize on the output vector to make it non-ambiguous in many cases.
The paper "Julia: Dynamism and Performance Reconciled by Design" [1] (work largely by Jan Vitek's group at North Eastern, with collaboration from Julia co-creators, myself included), has a really interesting section on multiple dispatch, comparing how different languages with support for it make use of it in practice. The takeaway is that Julia has a much higher "dispatch ratio" and "degree of dispatch" than other systems—it really does lean into multiple dispatch harder than any other language. As to why this is the case: in Julia, multiple dispatch is not opt-in, it's always-on, and it has no runtime cost, so there's no reason not to use it. Anecdotally, once you get used to using multiple dispatch everywhere, when you go back to a language without it, it feels like programming in a straight jacket.
Double dispatch feels like kind of a hack, tbh, but it is easier to implement and would certainly be an improvement over Python's awkward `__add__` and `__radd__` methods.
Seibel spends a fair amount of time talking about how powerful and flexible CL's dynamic dispatch mechanism is and how/why it was still a novel feature at the time (~15 years ago).
Not the OP, but Zcash's privacy feztures are optional and seldom used in practice, whereas monero is secure by default. It helps with blending in the crowd.
- van buren https://en.wikipedia.org/wiki/Fort_Cass
- Wilson https://en.wikipedia.org/wiki/Internment_of_German_Americans
- Bush https://en.wikipedia.org/wiki/Guantanamo_Bay_detention_camp
And i must forget a lot of others, but I think you get the gist. "Great again" indeed.