tmpmov's comments

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?