Learning on Noetic Nought

Been there, done that, and still doing it!

Thu, 05 Sep 2019 12:23:00 +0530

I was talking to a friend a few days ago about a new internship she got. She wasn’t sure if and how much she was going to get paid for it. Unpaid internships aren’t cool, and experience doesn’t pay the bills, as they say. Eventually, it turned out that she was indeed going to get paid for it.

But, when she found out that she’ll be paid, she felt way more pressure to “not screw up”. I think working in this mode of “don’t screw up” isn’t very productive. Staying in the mindset of “learn as much as I can” would still be the best way to go about the internship.

Screwing up is a part of the job. People make mistakes and learn from them. Screwing up is a part of gaining experience, and learning. To let people feel comfortable and safe while they are learning, it’s important to have better fallback and recovery mechanisms when things go wrong. The productivity gains are worth investing time into such systems.

I’m going to write down a couple of times I screwed up – one of them in my very first job after college, and the other just a month or so ago. People screw up every day, irrespective of how much experience they have.

Corrupted a server’s hard-disk

In my first job, I had screwed up big time in the first couple of weeks of my job. It’s been a while, and a lot of the details escape me now.

I was supposed to resize partitions on a server’s hard disk so that there’s more space available for the media that we were going to store on the server. The server was pretty newly setup, and there wasn’t all that much data on it, but my bosses (Asokan and Prabhu) had spent some time on configuring it, and setting up user accounts, etc., for all the people that were going to join the project.

I tested the resize operation on a machine locally in the office that I worked in, and it seemed to work. I replicated this on the server, and it went kaput! All the data was lost and I could no longer SSH into it. I was totally freaking out!

But my boss ended up being really calm about it, and asked me to just write to the server hosting service to get a new machine with a bigger media disk. And no, I didn’t get fired from the job. I worked with him for 5-6 years after that, including being hired again at a company he started working for.

Almost Deleted 7-8 years of email

A few weeks ago, I screwed up again. It could’ve been pretty bad, but luckily for me it wasn’t.

I administer a legacy Google Suite for UPAI. We have only 10 email IDs to allocate, and we often recycle them. Recently, I had to merge 3 accounts into a single one to free up 2 new accounts. I transferred data from two of them to the third, and went ahead and deleted them. I did this with a couple of other email accounts before, but they were barely used and nobody really cared about them.

I hadn’t paid attention to what data gets transferred, and what doesn’t. It turns out emails don’t get transferred, and only data in the Google Drive gets transferred. This meant I had lost years of important email communication for the organisation. I freaked out!

My “boss” was again pretty calm, and asked me to write to Google to see if I could get them to restore the data. I looked around, and found that Google allowed restoring deleted accounts for 20 days! I restored those accounts, transferred the email and then deleted the accounts again.

Learning from screw-ups

Learning and improving the systems in-place to prevent such screw-ups is the best thing that we can do from such screw-ups. Just like a piece of software gets hardened by bug reports that are acted upon, over the course of time, other systems can and should too.

As described in this blog post by GitLab on how to take advantage of screw-ups, acknowledging mistakes, fixing them, and improving the systems in-place to prevent such mistakes is a good way to go about it.

Systems needn’t always be super complicated things, but just a little bit of automation, and even simple checklists go a long way in improving work-flows and making processes less error prone. Google’s recovery mechanism definitely helped, and gives me confidence to continue working with these user accounts. Our server had a system admin pretty soon, and he had automated back-ups and the usual stuff in place, for us!

The way a team deals with mistakes sets the tone for how the team works, takes responsibility, and feels about working together. I still screw up after working for about a decade as a developer, and being paid for it. I’m sure I’ll continue to have my screw-ups, even though I’d like to have none. What was nice in both the cases was the way in which my mentors/bosses reacted, and how calm they were about the whole situation.

May you have screw-ups that you learn and grow from!

PS: Google’s Data Migration Service doesn’t support legacy Google Suite accounts, and I ended up using Got Your Back to move email from the accounts I wanted to delete to the other accounts. It worked pretty smoothly!

Thanks to Aishwarya, Meghana, Tejaa and Shantanu for reading drafts of this post.

Effortful things

Sat, 11 Jun 2016 00:00:00 +0530

That dense book you want to read but has been lying on your desk while you procrastinate on twitter. You know you’ll have to tune everything else out, and read slowly, word by word, trying to understand and make sense.

That vague blog post idea swirling in your head while you look at cat pictures, one after another. Distilling your thoughts and putting them down for general consumption is a lot of thinking and effort away.

That ${cool_programming_thing} that a talk got you excited about so long ago. But, watching talks and intending to start using it is all you do about it. You know its going to take a fair amount of reading, thinking and time, before you can really use it well.

Like all those squats and lifts you dread, these things are building your muscle. The thing about building muscle – it needs effort and feels like so much hard work.

You can’t build muscles effortlessly. Go do those effortful things! Only if you care about those muscles, anyway.

Level-up Tools

Mon, 23 May 2016 00:00:00 +0530

Thanks to a friend I got an upgrade to our still-being-setup kitchen. I now have a non-stick pan along with a few more new additions. I would previously use a bowl that people usually use to boil milk etc. for making whatever I did. The non-stick pan feels so great! It has made it a lot simpler to make some of the things I used to, because its non-stick. And it has vastly expanded the possibilities of things I can make, by virtue of being flat and wide based. The pan is such a great addition to my kitchen paraphernalia, and it adds a new dimension to the kind of things I can make. I’m not here to write a user review for it, though.

What are such tools in other things that you do, that drastically changed the way you did something, or added a new dimension to the kinds of things you could do, tools that make you feel like you have a new super-power? Learning to write Python (after starting off with C) seemed to give me so much power allowing me to focus on the problem, rather than fussing over the low level details. Sasha mentions in this post how using a Spaced Repetition System like Anki drastically improved her efficiency because she could focus on thinking about higher level things rather than trying to recall or search for what method or function to use to do something.

What are some such level-up tools for you? Is there a systematic approach to discovering tools?

org-drill for making it stick!

Sat, 17 Jan 2015 00:00:00 +0530

Those who read the last few posts here, would know that I have been experimenting with org-drill (a spaced repetition extension to Org mode). I have been using the system (almost) religiously for the past 2 months, and I do find that it has helped a great deal! (in some respects). I have also spent a considerable amount of time trying to reduce the friction to put new stuff into the system, and am constantly on the look out for further improvements.

Using this system has definitely helped with retention, and I find that I can recall quite a few things I have read a few weeks ago, that I would normally have been unable to. Though, I can recall a lot of information, I have been having a feeling of “fragmentation”: the feeling of just retaining individual bits/fragments of information, while losing out on actually internalizing the knowledge; not seeing the big picture, etc.

Wozniak (the author of super-memo) warns against learning without understanding, and memorizing before actually learning stuff. I haven’t consciously added stuff into the system that I didn’t understand (when I added it), but, later it does feel like I have lost some connections or the understanding, and am only holding onto the fragments of information.

The problems as explained in (read: as interpreted by me from) Make it Stick appear to be:

The understanding (if any) at the time of adding stuff into the spaced-repetition system is untested. It may just be familiarity masquerading as understanding.
The lack of any spaced repetitions for the overall concept/understanding and actual repetitions only for individual bits doesn’t help retention of the understanding (even if there was any, in the first place).

To work around this, I’m going to try adding questions that test understanding, to the system. The Super-memo team strongly recommends keeping the drill items small and easy to answer. This may be helpful in keeping each drill session short, but I would really like to add conceptual questions to the system, and see how it goes. I hacked org-drill to allow me to type out answers, before looking at the “correct” ones. This is an adaptation of a system that a fellow Hacker Schooler uses, and shared. Also, hopefully forcing myself to type out the answer will help me get around the problem of sometimes saying “yeah I know that”, then looking at the answer only to reaffirm the feeling of familiarity, rather than actually testing myself. I’m still going to continue adding quick and short questions that test “bits of information”, though. But, hopefully the additional conceptual questions are going to tie things together and help fill in the gaps. Lets see how this goes!

For those interested, my hacks to org-drill below. The code is really a hack, and welcome any suggestions on cleaning up the code.

(advice-add 'org-drill-presentation-prompt :around 'pc/org-drill-presentation-prompt)

(defun pc/org-drill-presentation-prompt (old-fun &rest fmt-and-args)
  "A presentation prompt that allows capturing answers."

  (let ((cb (current-buffer))
        (heading (nth 4 (org-heading-components)))
        (entry-id (org-entry-get (point) "ID"))
        (input ""))
    (switch-to-buffer-other-window "*org-capture-drill-answer*")
    (org-mode)
    (insert "# Hit C-c C-c once you are done answering!\n")
    (org-insert-heading-respect-content)
    (insert (format "Answer: %s" heading))
    (org-entry-put (point) "QUESTION_ID" entry-id)
    (goto-char (point-max))
    (insert "  ")
    (org-time-stamp-inactive '(16))
    (insert "\n\n  ")
    (while (not (and input (equal input "")))
      (ignore-errors
        (execute-kbd-macro input))
      (setq input (read-key-sequence nil)))
    (switch-to-buffer-other-window cb)
    (apply old-fun fmt-and-args)))

(advice-add 'org-drill-reschedule :around 'pc/org-drill-reschedule)

(defun pc/org-drill-reschedule (old-fun)
  "Calls the original reschedule, but also archives the answer"
  (prog1 (funcall old-fun)
    (let ((cb (current-buffer)))
      (switch-to-buffer-other-window "*org-capture-drill-answer*")
      (pc/org-refile-to-datetree "drill.org_archive")
      (message (buffer-name))
      (switch-to-buffer-other-window cb)
      (kill-buffer "*org-capture-drill-answer*"))))

(require 'org-datetree)
(defun pc/org-refile-to-datetree (journal)
  "Refile an entry to journal file's date-tree"
  (interactive "fRefile to: ")
  (let* ((journal (expand-file-name journal org-directory))
         (date-string (or (org-entry-get (point) "TIMESTAMP_IA")
                          (org-entry-get (point) "TIMESTAMP")))
         (dct (decode-time (or (and date-string (org-time-string-to-time date-string))
                               (current-time))))
         (date (list (nth 4 dct) (nth 3 dct) (nth 5 dct))))
    (org-cut-subtree)
    (with-current-buffer (or (find-buffer-visiting journal)
                             (find-file-noselect journal))
      (org-mode)
      (save-excursion
        (org-datetree-file-entry-under (current-kill 0) date)
        (bookmark-set "org-refile-last-stored")))
    (message "Refiled to %s" journal)))

More input sources for org-drill

Tue, 04 Nov 2014 00:00:00 +0530

I’ve been trying to use org-drill regularly for the last few weeks. I don’t know how well it’s been going but I have been sticking to the routine religiously. I haven’t yet really tried out incremental reading, but in an attempt to make it as easy as possible, I wanted to have a pdf-reader integration, and some kind of integration with Kindle highlights. Browser integration is pretty straight-forward, thanks to some simple java-script.

I looked for a pdf-reader with some sort of plugin support, but I found nothing in Evince or Okular. I thought about pdfjs but it seemed slightly clunky to open pdfs in a browser, though I might shift to this if I don’t like what I finally ended up with. Good old xpdf seemed to be the only pdf reader that had some support for custom keybindings that allowed users to run external commands. With a little Python, I was able to setup a work-flow to capture snippets from xpdf, to add to org-drill. Custom key-bindings somehow don’t seem to work on xpdf bundled on Ubuntu. So, I ended up downloading and using the binary available on the xpdf site.

For Kindle highlights support, with minor updates to Thamer Mahmoud’s clip2org, I have a simple way of getting all the “new” clippings/highlights as org-drill headlines. I haven’t really started using this, and once I do, I may end-up automating even the merging of these items into the org-drill notes file. I’m looking forward to making better use of my Kindle, with this feature!

I don’t know if it would be useful to have more context information like section titles/chapter titles when capturing from html/pdf, but it seems like an interesting problem to try to solve.

Also, it might be easier(?) if I probably tried to have a DE level keybinding, and some code to get selection and file name of the currently active window/application.

Learning about Spaced Repetition, SuperMemo, Org-drill, et al.

Fri, 24 Oct 2014 00:00:00 +0530

I have been reading a bunch of articles on the SuperMemo site (including the original thesis of P. A. Wozniack, the creator of SuperMemo). I initially started off trying to understand the algorithms SM2,5 and 8 which org-drill implements, but reading the articles has given me a lot of general background and theory on how memory works, and why SuperMemo is as effective as it is (for those who stick with it). This blog post is an attempt to summarize and capture what I have read in all those articles, and not get lost in them. I would recommend reading the thesis and the suggested reading there, yourself, but if you really don’t want to – this blog post + the summary in here, and here would be a good alternative.

Memory works by repetition. Each time you recall a fact, the time it takes for the memory to fade increases. Spaced repetition is the idea of repeating items, just when you are about to forget them – trying to optimize the time spent on learning, as well as the retention of learned material.
Prioritization of the items we need to learn is key to being able to stick to Spaced repetition. Beginners tend to be over-enthusiastic about the technique and fill up their system with stuff that they don’t really care about. Applicability of the knowledge you are trying to gain, is a good test for whether or not it goes into your system.
Each version of SuperMemo comes with a slightly modified (on most occassions, improved!) algorithm. SM2, SM5, … refer to these algorithms. Org-drill currently supports only sm2,5 and 8. It may be worth looking at sm15/16 and seeing if it can be implemented and is worth doing. In any case, using any of these is way better than not using Spaced repetition at all.
Understanding what we are trying to learn goes a long way in helping memory. It is, therefore, good to start with basic material. People have been surprised by how easily the advanced stuff fell into place, once they had the basics covered.
Keep items in the system simple. Stick to the minimum information principle. Keeping it simple, doesn’t mean you leave out on learning the complex stuff; instead break it into simpler components. Simpler items has the following advantages:
- Simple is easier to remember.
- Simpler items are easier to schedule. You get more resolution to figure out what the problem areas are.
- Simple makes brings in redundancy automatically. And redundancy is good for memory, just like it is for managing hardware failure.
Keep learning fun! Don’t make review sessions a chore. Think about the material you are reviewing. Edit/delete/improve items based on your reviews, then and there. Stay active.
It is useful to add a link to the source of the items added to your system, considering that you wish to use the system over a long period of time (ideally, the rest of your life!)
Prioritize, add examples, appeal to your emotional state, link to existing knowledge, use images. Anything else that works for you! Use all of these techniques, that work well and you probably already use in everyday life, in the items you add to your system, to make them easier to recall.
Being physically fit and healthy is important for being so mentally. Exercise, sleep, eat well, avoid caffeine.
Try incremental reading, as an input source of items into your memory system.

Learning to use Org-drill

Tue, 14 Oct 2014 00:07:04 -0400

Org-drill is an Org-mode extension that provides spaced-repetition and flash-card functionality. It has a wonderful documentation on Worg, but somehow I couldn’t get myself to read the whole document, and setup org-drill, until now.

The setup is quite straight forward, once you have org-mode along with the contrib packages. Just (require 'org-drill), and you are all set! To add a new card, all you need to do is add a :drill: tag to the items you wish to “Org-drill”. You can start a review session with simply M-x org-drill. You will be shown flash cards, and you can rate how correct and comfortable you were, in answering the questions. Based on your responses, the cards are scheduled for review. Start another review session, whenever you need one!

What I could only understand once I got myself to read the whole document was that:

The default scope of a drill session is the current file. But, you can start sessions with scopes like current tree, current directory, or a specified list of files. This is super-useful!
The review sessions are not automatically scheduled, based on when you schedule failed flash-cards. Scheduling the review for a card only sets a due-date for them, and effects, what you are asked in your next session.

Cram mode and incremental reading are also things I want to try, as I go along.

Happy Learning!

Recurse Center, 2014-07-22

Tue, 22 Jul 2014 10:46:36 -0400

Mel’s talks

Mel’s talk in the morning was brilliant! I wonder why it’s not a part of recommended reading for Hacker Schoolers, or referred to, in the manual.
Logically, it makes sense that Mel came now, so that she didn’t have to come twice to talk to the firsts and seconds, but it would have been great to have had this talk in the first week of Hacker School!
Mel gave us a lot of new information and insights into education and learning styles. I also like the fact that she gave us all a good vocabulary to think about and discuss stuff related to learning. I will try to think, and apply as much of this as I can, for the rest of my time here.
She talked about test driven learning which seemed very interesting. Instead of just saying, “wow that would be an interesting thing to do”, stop for a moment, think about what you are trying to learn, and how you will assess if you have learnt what you wanted to, and then dive into the project.
The learning styles workshop was pretty good too, though I feel like I don’t know myself well enough, and I unable to properly “bucket” myself. Later, I took a quiz, and ended up fairly close to the middle, in all the dimensions.
Mel introduced us to the idea of cognitive apprenticeship, and encouraged us to try out the different modes when pairing. I really liked the idea of Zone of proximal development and I will try to take the advice of spending most of the rest of my time here in this zone.
Do I (really) care? Motivation and mindset, …
Be courageous!

Airplay and Raspberry Pi

I was trying to wrap libshairport and use it on the RPi to be able to listen to songs being streamed on Airplay, and use that data to drive the LEDs.
Shairport, a tool written in C seemed to work. My attempts to wrap libshairport, which is a fork of shairport converting it into a library, failed miserably.
The trouble was essentially getting Airplay to discover my service. I tried a bunch of things with pybonjour and avahi, but wasn’t able to get it right.
Finally, I tried just announcing the service with shairport, and actually running a python script that wraps libshairport to listen to the data. But, this didn’t work and iTunes complained that this Airplay device is not compatible. Before going much further with this, I found shairplay which is a tool similar to shairport, but came with a library, and also Python bindings! I happily used this to get stuff working!
I’m interested to see today, what exactly I was missing yesterday!

Emacs club

I demoed org-mode to a bunch of people for about half an hour, and it was good to see people being blown away by what it can do, exactly the way I was, when I first came across it.

Today

Work on RPi to clean up a few things for the party.
Compare libshairplay and libshairport to see what I was doing wrong, yesterday.
May be write up the whole thing, and make the code available.
Learn a little bit about Parsers from rntz.

Teach Yourself Programming in Ten Years!!

Fri, 02 Feb 2007 00:00:00 +0530

Here’s an interesting article by Peter Norvig, Director of Research Google I have just copied the whole essay here… also here’s a link to the Original one…

Update: - [2010-10-11 Mon] - Removed the copied content