The method consists in actually jumping, skipping the hardest part, then when being on top with the head above the bar, you let your body fall as slowly as you can.
It turns out this works because in the eccentric phase your arm muscles are more powerful, but you are still able to progress overall.
The advice I would give is, as you said, embrace confusion but pay attention to where is your next mentor, the one that will show you that little trick or that little piece of understanding that will get you progressing.
I’ve found in learning the process can be similar. If I don’t understand something I can only read so much and study so much. I have to get my hands into it. I will pull down a codebase, run it, change it, break it, fix it, try and emulate it from first principles and contrast that with my reading and repeat. The best way I’ve found so far is to couple that with bottom up learning— working and reworking the fundamentals as I capitulate and bounce off the walls of reverse engineering and experimenting. I can’t confirm the benefits of that for anybody else but it works for me and keeps me interested
The quickest example I could find (of pronate form) is this guy, (but he's right): https://www.youtube.com/watch?v=yLXn2OtQmxo
Wanted to add, off topic but for interested parties of the digression, a good resource— Scott.. from Boston? never checked. But he's pretty good: https://www.youtube.com/watch?v=MogM8PlV1NI
(We down-weighted those assignments in the grading, of course, so that people with GPA requirements for scholarships didn't suffer.)
It helps that I have the flexibility to dig in instead of feeling the timeline pinch.
Part of intellectual maturity is learning how to not need the hand.
In the closed worlds of today's mobile infractructure (i.e. iOS and Droid “walled gardens”), remaining “can do” is getting harder. If I could trade mine in for a truly open smart phone, I'd do it in a heartbeat.
Start small and make sure you talk to the maintainers and make sure they are comfortable with you and what you want to work on. Introduce tiny patches to begin with. You'll disarm any gatekeepers this way, and get people on your side with you. The larger the project, the more politics involved generally.
I still download popular 3rd-party programs (i.e. not in the OS repos), especially if they are open-source (i.e. just GitHub), and there is evidence of active maintenance with a significant number of contributors to the project, or if it is from a reputable, popular real-life person.
I think it is a real shame. I should be able to download any program and know that they aren't just going to be trawling through the files on my PC without the OS at least asking me (and so on). It's a tricky balance between sandboxed "useless" apps, and god-mode, but something that I feel desktop OS's need to focus on if their platform is to survive.
Where "do it" is go ahead and hack & submit a patch on that open source project you rely on instead of working around it, get past that fear.
- Go on github, find the repo
- Fork the repo
- git clone https://github.com/me/forked_repo
- cd into the repo, and 'git checkout -b me_myfix'
- write your change
- cd ..
- 'pip uninstall forked_repo' so that you can work with your fork's clone instead
- Sometimes, if the repo has a setup.py, some symbolic linking needs to be setup so we can easily do 'import forked_repo'
- use 'import forked_repo'
- later, you can do 'git push origin me_myfix' and submit a pull request from Github.
I think there is a better way but I did not think about this problem much. It would be nice if someone could outline how to go about this properly. And there's almost no chance I could do this with another language since I am not as comfortable with the building/packaging with other languages.
A while back I needed py3k support in pybindgen so hacked it in and it magically got merged into the main branch. Surprisingly, as is -- I guess I can hack on the python good enough ;)
For the benefit of both the maintainers and the contributors, projects should really have advanced, comprehensive, automated code linting/style-checking/safety/etc. It should be possible to run it locally, and it should also integrate with GitHub's Pull Requests with automated comments (e.g. Travis CI).
This should instil confidence in the contributor, they know they have at least passed the basic checks.
Well, in this day and age, that kind of thing gets called out pretty quickly.
Me: "Hi! I just found a bug in your program. If you do A, B and C, X doesn't work properly."
Maintainer: "Our test case covers A and B and works perfectly."
Me: "Yes, C is an edge-case your testcase didn't include, and which is what breaks everything horribly. You know more about modifying your testcase than I do, but I guarantee you that when you make the change, this will fail consistently."
Maintainer: "You must provide us a new testcase."
Me: "I don't know how to do that."
Maintainer: "Our existing test cases work fine."
Me: [ Gives up before frustration turns to anger ]
This happened. https://github.com/rg3/youtube-dl/issues/7872
Me (on a sadly now-defunct forum): "I think it would be awesome if we ported my favorite application to this new OS"
Owner of application, unexpectedly: [ Long rant about the difficulty of porting things and that my ideas are going to affect him personally ]
Me: [ Freaks out ]
Forum maintainers: [ Words of comfort ]
Sadly there are no copies of the post in the Web Archive (I just downloaded the entire forum to check), but I remember the conversation well.
New contributor: "Here's a patch to this program. It fixes this and that problem."
Long-term maintainer: "We don't do things that way."
New contributor: "It'll improve performance and simplify the code."
Long-term maintainer: [ Blah blah blahblahblahblahblahblahblahblah(...) ]
New contributor: "...?!"
This is what came to mind when I thought about systemd.
The thing the article is completely missing is the political element.
It exists, it's real, I wasn't warned I'd get bitten, and I have cognitive issues and don't know how to resolve confrontation in some situations.
I generally avoid open source communities nowadays. My experiences discussing closed-source software have consistently been less toxic!
You are technically right. The specific issue was that youtube-dl had a bug downloading WAVs from soundcloud. The WAV in question was privately linked to me, and it was the first WAV I'd ever encountered. It's not possible to search for "has WAV" on soundcloud. I had no idea how to find one, and was unsure how to go about uploading test media (eg if it would be taken down etc).
I'll admit that yeah there was some laziness and "just fix it" and unimpressedness in there. I'm at fault to an extent.