pqh

How might one know which address to attack like this? I thought memory was fairly randomly laid out.

What pun?

default to privacy though, please

I feel like my job is to never trust anyone. Don't trust their string encodings, the characters they put into those strings, the arrangements of the characters we do allow, etc.

"Possible UFO" is a silly phrase if you think about it.

Just read the manual.

https://git-scm.com

I had this problem and the solution was to use the game's `f` keybinding for fullscreen instead. Or open the game in a separate window, because ALT-F4 is the only way to close it.

I'd be happy with more turn speed on all aircraft. Or maybe dual-stick control. :]

And yet, thankfully, the old versions of those commits are still present in the reflog for some time. Making it easy to recover from finger slips.

If life isn't worth creating, why is it worth preserving? Why not take this to the logical conclusion of voluntary total extinction? Furthermore, how could one even discuss good or bad without a frame of reference?

I'm not sure yet what to think about the idea of internet access as a social program.

However, I'd be less irritated about losing Net Neutrality if competition actually existed in the US. Break up the monopolies and maybe we can talk about allowing the free market to guide companies to do the right thing instead of requiring regulations.

Tight coupling is the worst enemy of both refactoring and testability, as I see it.

I'd also be interested in effect on resource consumption.

GDP isn't everything. I can't say it better than Kennedy: https://www.youtube.com/watch?v=77IdKFqXbUY

I agree with the latter parts of your comment, but not that "What makes unit tested code maintainable has nothing to do with how application code is structured".

My original point was that code that's hard to test is often hard to refactor.

Would you have any thoughts on how they compare in maintainability?

I think good code usually results in the test suite being useless the vast majority of the time. That is, only let's say one run in a thousand of any given test should fail after adding or refactoring code, if that. Even then, the failures are usually commensurate with the changed expectations of the changed code and not indicative of a bug.

I'm curious what language and techniques you mean this applies to.

In my experience, I've seen a lot of code that was written in a way that was not unit-testable, for what was the same reason that later turned out to be poorly-maintainable.

Don't abstract it out until it's used in multiple places. Don't abstract it out using a complicated system, like inheritance, when you can use a function in a module. Don't abstract it out if it's superficially similar as opposed to actually the same thing.

Regarding the last point: iterators, good abstraction; averaging function, good abstraction. These things never change. But bad abstractions copy things that are only similar in appearance.

Would it still be travelling too fast to be captured if it hit the sun directly?

Euclid's Elements teaches geometric concepts that you're probably familiar with, but with interesting proofs: https://en.wikipedia.org/wiki/Euclid%27s_Elements

It's free, it's time tested, and probably just the right amount of rigor to get your proof abilities up. I think the ability to prove theorems and the ability to construct abstractions go hand-in-hand.

This is a really beautiful proof that connects complex numbers and primes to derive a formula for calculating pi. It should only require high-school algebra prereqs.

https://www.youtube.com/watch?v=NaL_Cb42WyY

If you want to truly follow the proof, there's one little bit on the chi function in there which is connected to something called the One Sentence Proof. This looks rather esoteric and takes a bit of pondering to wrap your head around, but again only really requires high-school level algebra.

Doing proofs like this is what math is really about. This is how you come to really understand. And this video also happens to be entertaining in how well-put-together it is.

While I agree with the spirit of your post, starting with abstract algebra is probably too formal and abstract. The best way to learn something is by learning the concepts first and progressively formalizing, always with some link in the chain connecting back to tangible experience.

I would possibly throw this out as an interesting way to learn a bit (not really a whole lot, but a fun start) about abstract algebra: https://www.crypto101.io/

How did "Blockchain" and "Cryptocurrency" become mass nouns? It's interesting.

http://grammar.yourdictionary.com/parts-of-speech/nouns/Coll...

Bonus if it's all hardware with good Linux drivers.

I mean, I'm in favor of gun control for practical, statistical reasons. I want less gun violence, if we can manage to implement some means of accomplishing that. Hard problem, I know.

But I understand the intent of the second amendment. It's not to allow hunting. It's not to allow you to protect your home from robbers. It's definitely a statement of defiance to tyrannical government. So if the NRA doesn't agree to some similar line of thought on encryption, they're hypocrites.

Okay, fair enough. I'll grant you this.

But this certainly doesn't fit in one line by my standard. It linebreaks in my standard tiling setup. `from random import choice; print(''.join(choice(('\\', '/')) for i in range 10000)))`

Neither a game nor a single line (using semicolons is disingenuous)

I suppose, continuing this thought experiment, the generic game engine behind the AI-generated game would be the AI generating games.

It's hard to be worse than YouTube.

"Here are some videos you've already watched, mostly that you've already liked, but also a few from the same channel, and even a helping of some you've disliked but which other people have uploaded duplicates of."

And that's Google, the AI experts, with a crapload of data on my viewing and others' viewing habits, including in depth learning features such as length of time spent on videos, liked videos, playlists, etc.