🔗 Quick links thread
-
##Native American participation in WWII
Some of my favorite bits:The Iroquois Confederacy, having declared war on Germany in 1917, had never made peace and so automatically became party to World War II.
...
There were many disappointments as well-intentioned Indians were rejected for the draft. Years of poverty, illiteracy, ill- health, and general bureaucratic neglect had taken its toll. A Chippewa Indian was furious when rejected because he had no teeth. "I don't want to bite 'em," he said, "I just want to shoot 'em!" Another Indian, rejected for being too fat to run, said that he had not come to run, but to fight.
...
During the 1930s, Nazi agents posing as anthropologists and writers on reservations tried to subvert some Indian tribes and learn their language.
...
The Manhattan Project used Navajo helium in New Mexico to make the atomic bomb.
-
Time Turned the Year's Hottest Tech Into the Year's Dumbest Cover, and Parody Is Rampant Poor Palmer Luckey
It obviously belongs to here, what a better way to lampoon VR, and laugh at the expense of others :)
Yeah, that cover image was shown during several of the VR-related presentations at HPG, and I going to keep a count of how many times I'm seeing it at SIGGRAPH.
-
```
234168Considering the actual answer is 233168, I believe some re-reading of the specification may be in order....
-
During the 1930s, Nazi agents posing as anthropologists and writers on reservations tried to subvert some Indian tribes and learn their language.
They might have known this (from The Great War™)...
-
s/1000/999. Pedants.
-
They might have known this (from The Great War™)...
Yes, that was mentioned in TFA.
In fact, the sentence preceding the one I quoted:Because the Choctaw language had befuddled German code-breakers in World War I, the Gemman government feared the likelihood of Indian communications specialists as World War II loomed.
-
sum(1..333) = 333*334/2 = 55611
TIL
No idea how I got this far in life without learning this.
-
Seriesly?
-
Ya, srsly
-
The trick to understanding the formula for the sum of an arithmetic sequence it to realize you are pairing each element from the start of the sequence with an element from the end.
1 + 333 = 334 2 + 332 = 334 ... 166 + 168 = 334 167 + 167 = 334 Poor 167 needs to pair with itself :( 168 + 166 = 334 ... 332 + 2 = 334 333 + 1 = 334So the total sum comes out as the sum of any of the those pairs (in particular the extremeties 1 and 333) times the number of pairs, except you need to divide by two because you're using each element twice.
Alternatively, you can see this as taking the excess of each element above the median element and pouring it down into the corresponding element below the median to compensate.1 + 333 = (167 -166) + (167 +166) = 167 + 167 \ 2 + 332 = (167 -165) + (167 +165) = 167 + 167 | ... > 333 times 167 166 + 168 = (167 -1) + (167 +1) = 167 + 167 | 167 forever alone /
The result is the median times the number of elements, which is also (a1 + an)/2 * n.
-
Potentiallyuseful shilling for a book, website, and github....
(Note that both authors hold doctorates in Nuclear Engineering.)One of the authors:
I can’t spend all my time ramping students up to be useful researchers. I’d rather say “Here’s a book. It’s yours. Come to me if it’s not in the index.”
Effective Computation in Physics with Python
Earlier this week I had a chance to talk with Anthony Scopatz and Katy Huff about their new book, Effective Computation in Physics. *** JC: Thanks for giving me a copy of the book when we were at SciPy 2015. It's a nice book. It's about a lot more than computational physics. KH: Right. If you think
-
Well it's obvious when you put it like that. Good work, thank you.
-
Well it's obvious when you put it like that.
The way I heard it, it took a great mathematician to originally explain it, turning something annoying into something trivial. Once that step's done, it's a trivial problem for lots of people, but the original insight is very much not trivial since it's talking about something quite a bit different.
There are other ways to get the same formula too, a bit trickier in this case but more general (e.g., the method of differences).
-
I always thought that the sum of integers thing was done by Gauss in elementary school.
-
Yes, that's what I'd heard too.
-
So my memory was wrong.
d…
-
I always thought that the sum of integers thing was done by Gauss in elementary school.
That's what we were told™ as well... his teacher assigned them the busy-work of adding 1...100 together... and his reaction was Srsly? there's got to be an easy way to do this....
-
Johnny Cash has been everywhere
(WARNING: auto-playing music in there)
-
LOL. That's great. Although I think all of those places were supposed to be in the US. For sure, Catalina isn't in Tuscon. Still...good stuff.
-
There's a lot of places that aren't mapped, but are real places. I don't get that-- maybe he was just doing a simple search on Google Maps to find them?
Shasta's in Oregon.
I give him credit on Faraday, which I thought was a place, but there's really nothing except a named bit of forest on Ottawa.
-
maybe he was just doing a simple search on Google Maps to find them?
That was my assumption.
-
LOL. That's great. Although I think all of those places were supposed to be in the US. For sure, Catalina isn't in Tuscon. Still...good stuff.
Agree. And I think the person who did it might just not have known all the places--he didn't put a marker for "Opalacka", but there's an Opa-Locka in Florida. Also, Cadillac, MI.
-
-
Man I've been saying that for years.
The problem in IT is that nobody has any concept of history, and there's nobody "standing on the shoulder of giants" as in other fields. It's just hundreds of idiots all milling around, bumping into each other.
I disagree that learning assembly is necessary for the process of understanding how a computer works on a low level. You can get the understanding without the assembly and you can (probably) get the assembly without the understanding-- learning assembly is mostly just an exercise in rote memorization, not true learning.
I do agree that it'd be nice if people took a go at learning protocols like HTTP by implementing it themselves. There's a lot of WTFery that would go away if people just figured out how goddamned simple HTTP actually is. You don't need the 82 MB framework to set up a REST API, guyz, it's like 4 lines of C#.
If you've ever written a simple dependency injector, or a simple XML parser, or a simple observer generator, or a simple query generator, then you've driven that magic away. You could write a framework if you needed to. Or you could just write the code in your application if you needed to. You don't need someone else's framework.
And that puts the framework in a whole new perspective. You don't need it. And if you don't need it, it can't have any power over you. You can look at that framework for what it is: just plain old code -- and probably a lot more code than you actually need.
Now you can judge whether the cost of all that code is worth the benefit. Perhaps there's a simpler framework that will do just as well. Perhaps you don't need any framework at all. Perhaps -- perhaps -- you should just write the little bit of code that you need, instead of importing thousands and thousands of lines into your project. Lines that you didn't write. Lines that you don't control. Lines that you probably shouldn't be putting a whole lot of trust in.
Amen to that. Someone send this to the Discourse team, post-haste.
-
I think he went a bit too far with the "my language sucks" routine here. I guess that's plausible for some stuff, but it also implies that the abstractions provided by the framework should be provided "by the language." Which strikes me as crazytalk.
The problem in IT is that nobody has any concept of history,
This argument never sounds any smarter no matter how you dress it up.
-
This argument never sounds any smarter no matter how you dress it up.
Except it's true.
Does it sound better when "Uncle Bob" makes it? Because he's saying the same thing.
-
Does it sound better when "Uncle Bob" makes it? Because he's saying the same thing.
Not really. I'm not arguing that we're observing a perfect march towards perfection. It's mostly hyperbolic confirmation bias, from what I can see.
-
The problem in IT is that nobody has any concept of history, and there's nobody "standing on the shoulder of giants" as in other fields. It's just hundreds of idiots all milling around, bumping into each other.
I think this is because the gap between academia/major-corporation R&D (which traditionally is where that history is kept) and industry practice is so large in software development, which is quite sad, really -- many software developers find themselves reinventing squared-off wheels simply because they don't know a better algorithm exists for the problem at hand.
I disagree that learning assembly is necessary for the process of understanding how a computer works on a low level. You can get the understanding without the assembly and you can (probably) get the assembly without the understanding-- learning assembly is mostly just an exercise in rote memorization, not true learning.
Most of it is getting past the "CPU as a magic box" phase -- if you can do that by learning a HLL, that's great! I suspect there are some folks who have trouble with that until it's drilled into their head quite soundly by having to sit there and write machine instructions from the word "go". (The memorization isn't nearly as important -- it's useful when you have to dig in and debug some weird low-level issue or such, but that's not something most programmers run into.)I do agree that it'd be nice if people took a go at learning protocols like HTTP by implementing it themselves. There's a lot of WTFery that would go away if people just figured out how goddamned simple HTTP actually is. You don't need the 82 MB framework to set up a REST API, guyz, it's like 4 lines of C#.
QFT! Writing a bare-bones protocol implementation should be something that's done in every networking class. Heck, even learning how to talk to a web or mail server with a telnet client helps...And amen to your quote -- the reason why DI has no magic to me is because I've written ad-hoc DI myself. Likewise with query generation. (Parsing is a bit of a different beast, though, because most folks don't grok the mathematical background needed to write a parser properly. Nothing wrong with writing a recursive-descent parser for some basic tag soup though ;D )
-
Writing a bare-bones protocol implementation should be something that's done in every networking class.
I took a class that was structured so that we designed and implemented a protocol throughout the semester. Every tradeoff was discussed, with real-world examples of each side of each decision. Took out all the magic about any protocol that we would ever run into in the future.
-
I disagree that learning assembly is necessary for the process of understanding how a computer works on a low level.
Depends on whether you are talking about assembly as in "all the instructions of this here particular instruction set of this here CPU family" or assembly as in "a thing that exists because CPUs work with binary opcodes and no one's insane enough to write or inspect those as pure numbers".
I think giving a simple assembly language a try is a good experience for the same reasons you say implementing an existing protocol is a good idea. It gives you a better notion of what they are, how they work, and where they fit in the grand scheme of things.
Having said that, I see that it is more likely that you will be implementing your own protocols in the future than writing more stuff in assembly. So I agree the former is more important than the latter.
-
I disagree that learning assembly is necessary for the process of understanding how a computer works on a low level. You can get the understanding without the assembly and you can (probably) get the assembly without the understanding-- learning assembly is mostly just an exercise in rote memorization, not true learning.
It's mostly about persuading people that there's no magic, just lots of tools built on top of tools, and that everything is predictable if you actually know what's going on. That's a simple profound lesson, so naturally it takes a lot of effort to get most people to learn it (i.e., it's most of what the first year of a Computer Science degree is about). Once people have grokked that properly, they're ready to be told about how things work and to find out how to make new things that work well.
-
###I bought a server. Where's my website? (reddit)
Rather juicy Tale From Tech Support.
-
TLDR: Woman buys metal, expects human baby to be created.
Not getting that one at all. Buys crib? Buys stroller? Buys baby clothes? But...metal?
-
But...metal?
the server.
it's the human baby part of the analogy that's confusing me.
-
Maybe a human's "baby", like, a product a human created and lovingly slaved over?
-
given the interaction i would expect that descriptioon may be better phrased as "Someoneelse's baby" then, yesno?
-
How is
babbywebsite formed?
-
the server.
Yeah.
it's the human baby part of the analogy that's confusing me.
Right. The only explanation I can come up with is that he was trying for an absurd non sequitur. Which doesn't really make sense here. It's not like she leased a server and assumed someone would show up and mow her lawn every week.
-
###React’s JSX: The Other Side of the Coin
Rose colored view of react's jsx.
-
huh. interesting. i may wish to play with that some time...
-
Mixing languages together in a single file can definitely be a cromulent approach (LINQ is pretty much a demonstration of that, and it's hardly a unique example). Whether it should be those two and mixed in that way, that's harder to say.
-
Found this while comparing JSX to the late E4X. It looks like the former was inspired by the latter.
E4X had a lot of potential but unfortunately did not take off. JSX attempts to keep only the good parts of E4X. Since it is much smaller in features and only a Javascript transform, it is more likely to be adopted.
JSX, contrary to E4X, does not contain a runtime for XML, it is only a syntactic sugar. It translates XML syntax into function calls:
<Node attr1="first" attr2="second"> <Child /> </Node>is converted into the following standard Javascript:
Node({attr1: 'first', attr2: 'second'}, Child({}) )The syntax is no longer tied to a specific implementation of the node representation. JSX is pure syntactic sugar.
JSX uses Javascript to deal with the namespace problem. In E4X, each node type is not represented by a unique string across your program. In JSX a node type is represented by a Javascript variable. You can use all the Javascript features (eg variable hoisting, capturing via closure, function arguments ...) in order to find the proper node type you want to use.
var div = ReactDOM.div; <div /> var div = JSXDOM.div; <div /> var div = SomeJSFunctionThatReturnsADiv(); <div />JSX is also totally optional. The actual representation of a node
type is behind the scenes just a Javascript function. If you are not
using JSX, you can create the node by calling it the following way:// Using JSX: <div attr="str"><br /></div> // Without JSX: ReactDOM.div({attr: 'str}, ReactDOM.br());
Effing Discourse. Had to work around its formatting idiosyncrasies.
-
Ever wondered what's the best thread on reddit of all time?
###Throwaway time! What's your secret that could literally ruin your life if it came out?
This one. I've been binge reading for hours and have barely even scratched the surface.
-
-
JSX, contrary to E4X, does not contain a runtime for XML, it is only a syntactic sugar. It translates XML syntax into function calls
Rose colored view of react's jsx
Ok, so I've spent a bit of time trying to wrap my head around this. For starters, that translation from XML into method calls is basically the same thing xaml does. Except separation of concerns is the whole point of xaml, whereas jsx is apparently a shift in the opposite direction; putting markup into the general-purpose programming language instead of taking it out.
Second, that sugar don't look too sweet. If you already have those method calls available in your programming language, why on earth would you intentionally switch to angle brackets?
But for the answer to that, I recalled the part of @cartman82's link about how jsx apparently allows you to be more efficient by using basic ide features such as suggestions and error highlighting and it finally clicked: jsx is an attempt to add strong typing to JavaScript. To which my predictable response is: “lol yeah, wouldn't that be great? But frontend devs would never go for it; tracking down obvious bugs that would have never happened in a real pl is like their national pastime.”
-
Second, that sugar don't look too sweet. If you already have those method calls available in your programming language, why on earth would you intentionally switch to angle brackets?
You can give your file to designers / frontend guys and they will instantly recognize what's going on. Also, don't forget the power of copy-pasta.
That said, it IS a bit of a pain to add jsx support to your dev env and compilation scripting, so I can definitely see some folk just using the functions directly.
But for the answer to that, I recalled the part of @cartman82's link about how jsx apparently allows you to be more efficient by using basic ide features such as suggestions and error highlighting and it finally clicked: jsx is an attempt to add strong typing to JavaScript.
Err, no.
It's an attempt to add an inspectable compiler to HTML. It doesn't change javascript in any way.
-
Oh, I see, so instead of xhtml, which was valid xml that browsers were able to parse as invalid html, we can have valid xml that compiles to valid html (and adds a bunch of functionality besides)? That's pretty cool actually.
-
http://venturebeat.com/2015/08/13/how-microsoft-built-and-is-still-building-windows-10/
Interesting rundown of Microsoft's new user feedback driven development methodology. The upsides, at least.
-
The dream of 'perfect sexual consent' has a nightmare tinge
Surely we can discuss sexual ethics based on honesty without turning every lapse into a crime.
-
Choctaw code talkers - Wikipedia
Clean Coder Blog
JSX: E4X The Good Parts
