tmpmov

I could see some of the warmups used at parties, a few are fun to play with a sig fig or on a road trip.

Another game in the same vein : assign each player a unique alphabet letter. Starting clockwise, each player states a word starting with their letter.

If someone pauses for more than 3 seconds (6 steps if playing while walking) another person may say a word for that letter. We keep score by how many words you helped with (stole from) others. Each word should be unique, you can’t state a word used before. Continue until at destination.

To increase difficulty: when the initial player is reached (after a full round), reverse the direction (if clockwise, go counterclockwise) of play. When a reversal occurs take the letter from the person who goes after you in the clockwise direction.

For those confused on what the navigation does and how it works, I'll try to give a basic example in desktop terms and build up.

1. If we want to switch between windows on a desktop, we use alt-tab.

2. Suppose we could arbitrarily group the windows from multiple applications into a single entity (sort of how Ubuntu defaults to grouping all terminals for application switching). For example, say we have a terminal and a web-browser in a group, and a file explorer and a web-browser in a group. We can switch between the two groups and within a group we can switch between applications.

Why do we care? If you have a large number of applications open, it's tedious to alt-tab through them all to get to the application you want. Other mechanisms exist, like ctrl+f10 for kde, but there is some economy of motion in a tree traversal vs looking at the applications, finding the one we want out of a large display of them and typing in the name of the application to bring it up. For example, if we want a particular terminal when we have 5 to switch between with 20+ other apps also running. ctrl-f10 breaks up the nice flow of alt tab and alt tab takes too long if we want to change between 5 applications rapidly.

3. Over time you may end up with a lot of groups, making navigation by group tedious. Lets introduce another level, say categories. Categories contain groups. So you can switch between Categories, within a category you can switch between groups, within groups you can switch between applications.

This plugin acts like the desktop framework above, but for files and with more features.

Thanks ghj.

I was aware of top coder/leet code, though hadn't heard of code forces/at coder.

For me the adventure game give a bit more concept linkage. Take Monkey Island, I can remember how to reply to many of the sword fighting insults, or what was needed to get pieces of eight via the cannon at the circus. There's something to be said for linking problems via a memorable story, giving examples and meaning from multiple angles helps retain the content over the dryness of problem prompt/quick solve.

Thanks for the write up and git book.

Related question: I’m curious if any has game-ified algorithm learning, sort of like those old educational math games targeting certain grade levels.

Might be cool to make a point and click adventure centered around dynamic programming or greedy algorithms.

For those interested AutoML-Zero cites "Evolving neural networks through augmenting topologies" (2002) among other "learning to learn" papers and is worth a read if you have time and inclination.

For those with more background and time, would any mind bridging the 18 year gap succinctly? A quick look at the paper reveals solution space constraints (assuming for speed), discovering better optimizers, and specific to the AutoML-Zero paper: symbolic discovery.

Not sure if mentioned, another good book: Analysis by its History

My interest was piqued by the "location-neuron" as well.

I like the sci-fi possibilities as you pointed out: an ide that rearranges itself based on focus or products that guide our awareness to salient facts (say a pedestrian in front of a car).

Perhaps taking that to another level: while learning or reading, are you paying attention to what the material "thinks" is appropriate.

Clearly, there's a gap between the different types of attention, and in this case the attention mechanic described is important but rudimentary (it doesn't seem like the neurons include conceptual focus instead of visual).

If we gain better understanding of these mechanisms, and the necessary technology exists, I could imagine learning material that provides users with conceptual paths/guides to follow in a much more intuitive way. It's not thinking for you, but guiding you towards the concept embedded in the material.

Towards this goal, if we could actively use information gained in accordance of the article, we may already be able to help children with some learning oriented tasks.

Exciting stuff.

Yes, my dilemma goes away and comes back. The tedium can be good, neutral, or "sub-optimal." I value the dilemma, not necessarily the tedium.

Good advice from other posters here, I found myself repeating it so I'll keep it short.

Enjoy work if possible. Find happiness.

Thank you for the link to the latex suite. I should have seen this before.

Links for the curious:

https://sourceforge.net/projects/vim-latex/

http://vim-latex.sourceforge.net/

http://vim-latex.sourceforge.net/documentation/latex-suite-q...

Awesome.

I dislike the latex math syntax per the reasons stated in the github article. I also like the idea of being able to output polynomials from a math calculation in python without having to roll my own latex pretty printer (many libraries exist here, but given my infrequent use case I like to keep things as simple as possible).

If I'm honest, I had only thought of intermixing tex with other constructs from the web (e.g. Markdown) and 'lax' gave me the idea to look around. I found a few more tidbits:

https://github.com/s9w/preTeX https://github.com/jobh/latex.py https://github.com/lukasdietrich/untex https://github.com/kosmikus/lhs2tex/ (cool example at https://github.com/kosmikus/lhs2tex/blob/master/doc/AGExampl...)

While I prefer vim and like the bindings, I like to have editor agnostic tools.

For those interested, I currently use pandoc, markdown, and latex -- via vim -- with an Ergodox EZ... (https://configure.ergodox-ez.com/layouts/ywYn/latest/0).

Have you considered medication to treat the CFS? From what I've read, it seems like narcolepsy medication has had positive effects.

Frankly, I'm totally clueless. It might be an interesting exercise to see what they're doing.

Fantastic work. I've been learning music theory off and on to help with my guitar. I was hoping for a whole lot of interactive applications like yours, but found most lacking for me, though I did find a few on the iPhone: FretTrainer for muscle memory stuff. I figure out what to learn next based on Musicopoulus. Both are fair, each with quarks.

I've bookmarked you in my, just created, music "Toby" folder. Speaking of which, here's one last app recommendation that's totally unrelated: if you don't already have an extension for bookmark management on your computer, consider "Toby." It's a decent one for chrome, I use it as I have way too many normal bookmarks and finding stuff via scrolling becomes painful. I'd be interested if anyone else is using a different bookmark extension for Chrome as well.

Great job again!

Interesting. My, perhaps wrong, visualization of the janking effect, without the display update, concerns resizing, or showing, a column or pane in a web app. During the resize, the content in both frames are not updated until the resize is complete under certain (most?) conditions.

"If an undue delay is likely to be caused, the work already completed is processed and the update phase yields to other update phases for unlocked content."

My interpretation for a pane/column resize or hidden to visible operation: display-locking reduces jank if I could operate on these elements with the display lock tools. This jank reduction produces more fluid updates in elements not affected by the lock.

Question: If sub elements have complicated draw/render cycles, how will the interplay of locks at different layers affect the result? Composing objects with libraries that use these locks makes me wonder about this issue (or if I make sub-components myself).

Maybe "studies" such as this can be used as leverage for more time in the "design" phase of things? Design phase could arguably encapsulate choices related to tooling, appropriate staffing decisions, etc.

Knowing the rough costs of rework and bug hunting, I would hope that "studies", like the above, are taken to add more weight to the activities in software engineering, not just the programming/coding aspects.

I like this take on introducing derivatives.

My first intro to derivatives was a little less than 20 years ago, but I feel like it was very much in the "traditional" vein of: Suppose we have "f'(x) = lim(h->0) (f(x+h) - f(x))/h" and we substitute in various equations. What will f'(x) be?

The difference as presented here: I (re?)learned an estimation method for decimal place mathematics while at the same point tying it to a larger/underlying principle.

I think a great approach would be to then do the stuff I started with, e.g. finding f'(x) given f(x).

Out of curiosity, how many of you have seen the approach as seen in the above article? I can't recall seeing it before, but again, it was a fair time ago for me.

My only issue with this is the older in life idea. I agree that marrying later in life has many benefits. The drawbacks for me are health-related. As we age, we have higher health risks. Aside from early death, I seem to recall research indicating offspring "health" decreases as either parent ages.

Still, finding love later in life is quite a good thing. If it happens, then that's wonderful.

The book reasons that learning assembly also teaches the fundamentals of computer architecture.

1.3.1 Gain a Better Understanding of Architecture Issues 1.3.1 Understanding the Tool Chain 1.3.1 Improve Algorithm Development Skills 1.3.1 Improves Understanding of Functions/Procedures 1.3.1 Gain an Understanding of I/O Buffering 1.3.1 Understand Compiler Scope 1.3.1 Introduction to Multi-processing Concepts 1.3.1 Introduction to Interrupt Processing Concepts

The book uses the 1.3.1 heading for each and I'm too lazy to change them.

Reasons to (maybe/arguably) write assembly:

1) You're bringing up a new board, your bootloader is partially written but you need some customization for the real-time OS you're using. It can be advantageous to do this in assembly 2) You're dealing with some particularly old hardware and (ab)using it for some commercial purpose

Of course, I can imagine that for each you'll have someone obstinately state there's no need to use assembly because of some gcc feature. More than one way to get things done, and most use the tools they're comfortable with.

Interesting note. I immediately looked at the Martin Hammond entry and raised an eyebrow... didn't realize this was a joke!

Was there a reason for the move away from HoTT? I seem to recall looking this up a while ago but didn't find a solid answer. Was there a fork version 2 that continues development with HoTT?

Based on the very light skim I just gave, I like that book. Thank you for the reference.

Take the following as coming from a dilettante... I'm still trying to understand the remainder of the paper but felt like writing on the basics of the encoder/decoder/quantizer setup they mention.

I found this particularly interesting "To compress an image x ∈ X , we follow the formulation of [20, 8] where one learns an encoder E, a decoder G, and a finite quantizer q."

I feel like this is related to some of the standard human memorization/learning techniques. Example: I'm learning the guitar fretboard note placement in e standard. It's difficult for me to visualize the first 4 frets on a 6 string guitar with notes on each fret.

To help me memorize the note placement I develop various mnemonic devices (both lossy and lossless). I know I've memorized the fretboard sufficiently when I can visualize it.

Attempting to translate my reading of the paper I believe the following analogy is apt. My "encoder" operates on a short term image when I close my eyes after looking at a fret diagram. It produces semantic objects, i.e. an ordered sequence of "letters" or pairs of letters (letters that are horizontally, vertically or diagonally aligned). The quantizer takes these objects and looks at the order/distribution. The quantizer places more importance on some of the semantic objects than others (the fourth fret has 4 natural notes before an accidental). My decoder is interpreting the stored/compressed note information to try to produce the image. It may be off substantially, so I correct and repeat the process.

The process of optimizing what the semantic objects are, the weight each gets, and how I use them to derive the original image seems like a fairly good representation of what I do (though at least some of that appears to be fixed in the learning algorithm typically). Of course, analogies are just that and mine doesn't take into account the discriminator or the remaining "heart" of the paper.

I think the heart of the paper is that they're trying to determine through GANs a good way to both store the image and recover it while reducing bits per pixel and increasing the quality of reproduction. Using some classical terms, the GAN algorithm thus tweaks the compressor, the data storage format and the decompressor to optimize what should be "hard-coded" in the compressing/decompressing process or program vs what will be stored as a result of the compression program.

Very handwavey but I think the general idea is right?

I gave a first pass summary in another comment but had a question based on my reading of the paper. I feel I understand it better now and can provide a better summary.

TLDR: You can formally encrypt conversations using strings (or language phrases) such that even if they're communicated over a "compromised" channel, your encrypted conversation retains its confidentiality assuming that the compromised channel hasn't been fundamentally broken (e.g. the snooping party has the keys to the channel, not a universal lock pick that breaks the algorithm). The proposed scheme requires a channel with "strong" encryption capabilities, it won't work otherwise.

For those wondering why that's a big deal: The paper is using public key encryption to enable subliminal messaging using normal everyday phrasing/conversations. You could have any conversation you wanted to (e.g. a non-forced or agreed upon previously conversation) and still communicate covertly (e.g. your talk carries extra meaning that an observer with access to the plain text wouldn't be able to discern).

The two parties don't have to plan or strategize before the meeting takes place. In fact, as long as they both understand what public key cryptography is, they can use the technique proposed in this paper to communicate without ever having met before! I feel like that statement is what throws a lot people off, or wonder why they should care.

For those wondering how it works that know some cryptographic stuff: The paper uses rejection sampling. They assume that the encryption of any given message will produce a string with desirable entropy. Meaning encrypting "hello" five times should result in 5 different encrypted cipher texts. They then select a desirable encryption of "hello" according to their extraction function f (which they defined in their subliminal messaging scheme and extracts the subliminal message but is also an entropy extractor). What the paper does is actually fairly straightforward scheme wise (though the math is different and takes a fair background to follow rigorously). Hand-waving again:

Algorithm steps: 1. Establish a random key seed and perform a key exchange; you must be communicating over a semantically secure channel for this. Seed generation works by producing d cipher texts for each party, exchanging them, then using the greater than function on each cipher text to create a shared seed. They acknowledge that the seed is public to anyone that has decryption access to the government mandated encryption channel. 1.1 Do a key exchange, described as: "Let Ext be a strong seeded extractor, and let S serve as its seed. By rejection-sampling ciphertexts c until ExtS(c) = str, either party can embed a random string str of their choice in the conversation. By embedding in this manner the messages of a pseudorandom key-exchange protocol, both parties establish a shared secret sk∗."

So they essentially use the rejection sampling to provide a cover for the key-exchange protocol. Pretty neat!

2. Using the seed and keys, do public key crypto like normal with the exception that transmitting cipher texts will be done on a single bit at a time by selectively choosing what cipher texts of cover messages are actually sent (that efficiency is very poor and I think they provide better techniques). The encrypted messages will thus be communicated by using an extractor function over a set of encrypted strings.

The encrypted strings from step 2 can be generated from any conversation, without restriction, as long as the encryption function is strong. You do this by using a rejection sampling strategy to produce cipher texts with desirable characteristics.

Example of step 2:

Suppose you want to communicate "hello" as your cover text but you want to use the bit value 1 for your subliminal message. To do so, a scheme to encrypt the single bit value could be to ensure whatever cryptographic text you produce has an integer value greater than the last one you received. So, you encrypt your "hello" message repeatedly until it gives a value that, if represented as an integer, is larger numerically than the previous cipher text message. You then transmit this cryptographic text. Similarly, if you want to transmit 0 you generate a cipher text that will be less than the integer representation of the previous cipher text.

Mathematically this scheme is as strong as the underlying government mandated encryption scheme (it uses the underlying cryptographic scheme as a source of entropy).

Hope you found that intelligible and correct me if you see any mistakes!

The paper targets an adversarially selected encryption scheme. Thus perhaps any would work, though I sort of doubt this based on my reading. In addition, the paper supposes that the two parties should be able to communicate using a normal-ish public/private key method.

Based on the quotes below I belive paper relies explicitly on the GE channel's hardness to break:

"On Our Modeling Assumptions. Our model considers a relatively powerful adversary that, for example, has the ability to choose the encryption scheme using which all parties must communicate, and to decrypt all such communications. We believe that this can be very realistic in certain scenarios, but it is also important to note the limitations that our model places on the adversary.

The most obvious limitation is that the encryption scheme chosen by the adversary must be semantically secure (against third parties that do not have the ability to decrypt)."

Later:

"All known constructions of such undetectable random string embedding rely on the sampling of a public random seed after the adversarial strategy is fixed. In this paper, however, we are interested in bootstrapping hidden communications from the very ground up, and we are not willing to assume that the parties start from a state where such a seed is already present."

" We begin with the following simple idea: for each consecutive pair of ciphertexts c and c0, a single hidden (random) bit b is defined by b = f(c, c0) where f is some two-source extractor. It is initially unclear why this should work because (1) c and c0 are encryptions of messages m and m0 which are potentially dependent, and two-source extractors are not guaranteed to work without independence; ..."

"We overcome difficulty (1) by relying on the semantic security of the ciphertexts of the adversarially chosen encryption scheme. Paradoxically, even though the adversary knows the decryption key, we exploit the fact that semantic security still holds against the extractor, which does not have the decryption key."

I skimmed the paper. Find my hand-wavey explanation below. I think I understand the overview, though if you see a mistake/misconception/error let me know.

Suppose Alice and Bob want to "secretly" communicate a message, we'll call the message LL for love-letter, but the government mandates an encryption scheme, we'll call it GE for government encryption. This encryption scheme allows the government to decrypt your correspondence as they know the keys that are necessary for its use.

Suppose also that GE is "secure": only Alice, Bob, and the government can decrypt an encrypted message. We consider this secure as the government already has the keys and hasn't fundamentally broken the algorithm.

The paper proposes that Alice and Bob can still communicate their LL and that the government won't understand it, even over a link that the government can decrypt. Further, the conversation between Alice and Bob will be encoded in such a way that it does not appear to the government that encryption on top of the mandated GE is taking place. In addition, even if the government knew that the conversation had subliminal meaning it wouldn't be capable of decrypting it/understanding it: the LL was encrypted using a method as hard as the GE. Thus the paper gives a good security guarantee for the subliminal messages.

I thought the important point they make in the paper is that the proposed scheme should not generate messages that are clearly encrypted: the government should see a normal conversation between Alice and Bob unrelated to the LL. They reference steganography as an example of sending encrypted information that doesn't appear to be encrypted (e.g. via a message encoding in the color bits of a picture such that the picture looks the same before and after encoding your message into it). We'll call this the normality constraint (NC). They then give an impossibility result for something known as local decoding. Metaphorically, I think local decoding translates to using the same picture to carry a conversation stegenographically. So using your favorite meme picture repeatedly for the stegenographic conversation isn't secure (again, my understanding is shallow here and the constraints may be even stricter). It would appear though that you could randomly select from a meme archive to have your private stegongraphic-like conversation (treating the pictures as strings of bits and randomly selecting among them for the purposes of the proposed algorithm, I explain more below)

The NC motivates them to use a probabilistic function over a set of strings as the alphabet/symbols of their encryption.

I think this means that the government would see a conversation that is syntactically correct and not outrageously meaningless, though I didn't see this quantified/addressed directly in the paper (correct me if I'm wrong).

Thus, as I didn't see the semantics of the encrypted subliminal conversation addressed I felt motivated to attempt a quick answer myself (again my shallow understanding of the paper may have overlooked how they addressed this).

Specifically: Wouldn't it become obvious if the government saw a syntactically wrong and semantically meaningless conversation?

My hair-brained scheme to address the question goes like this:

Use phrase indexes or phrasal pairs. A phrase index would be a string like "hey, how are you?". A phrasal pair might be pairs of related phrasal indexes. I could see this being mechanically generated via machine learning. Although this solution has its own pitfalls as you can probably guess and would need further fleshing out.

The semantic authenticity required by the NC seems to be hard to satisfy based on my reading. Would any care to enlighten me?

TLDR: You can formally encrypt conversations using strings (or language phrases) such that even if they're communicated over a "compromised" channel, your encrypted conversation retains its confidentiality assuming that the compromised channel hasn't been fundamentally broken (e.g. the snooping party has the keys to the channel, not a universal lock pick that breaks the algorithm).

A few email provides can do something similar. I believe it's called Catch-all: https://en.wikipedia.org/wiki/Catch-all

You may find it less palatable, but I could totally see the 'free to play' games going down the road of cryptocurrency mining.

As your project did before, you could tie the mining with in game currency. If the underlying block chain is actively traded you could even scale the game currency with real currency in some way... 0.0001 cent is a gold coin for example. Payment that way would seem fairly above board, especially if you clearly tell the player about the taxing system -- this could then be your funding.

I appreciate that you replied, even if my reply was late!

Same questions. These would be good to know.

Some of the people I know who naturally retain memory the best are some of the brightest and clear headed people. (Not including near perfect memory recording individuals, who do not have humor associated with their memories.) I on the other hand suck at humor. I find if I try to make a humorous association it seems forced, which does work to some extent, but leaves me feeling a bit forced during recall, so I don't find that worth it. However, when it is naturally funny or amusing, you better believe it sticks.

For me, I find that unless the joke has been expressed to others I simply forget the attempted association. Even if it's a bad joke or bad association, the expression portion helps to make the association of humor with the concept/memory more concrete.

I suspect this has to do with anxiety. Humor isn't the opposite of anxiety (that would be closer to hypnosis, I would guess) but humor breaks tension like cutting melted butter. So much so, if you get pulled over, and if you can make the officer laugh within a minute, your chances of getting a ticket are nearly zero.

This is a good point. I seem to recall reading somewhere that there a variety of reasons we find things funny but a large one has to do with inhibiting flight/fight response after a close call.

There is clearly something going on here, but what it is, I admit I'm in the dark.

If you're the kind that can find humor in everything, especially puns and similar, you've very lucky.

If I take an extreme view (one which I don't fully believe but will use for illustration), then humor of a particular variety helps us to recognize situations that are dangerous/seemingly dangerous, but survivable, if we can recall what decisions extricated us from that situation previously. I feel like that's heading in the direction of creating strong, positive, associations.