Azeria Labs

May I recommend Maria Markstedter? https://azeria-labs.com/the-process-of-mastering-a-skill/ 90% of her content is about ARM exploitation (which I'm personally not interested in). However, she has a couple of posts on how she learns and works, that are believable to me thanks to the rest of her content. She's also not selling coaching, she's selling her technical skills.

if you want to understand chip architectures, work through the elements of computing systems (aka nand to tetris). it walks you through implementing your own cpu, gate by gate, plus an operating system, compiler, and tetris game, in a way tested to successfully fit inside of a single-semester undergraduate class. their hardware designs are pretty weird (their hdl looks nothing like any hdl you can actually synthesize hardware from, their descriptions of how gates work are oversimplified, and their instruction set architecture is pretty similar to the eclipse that kidder was writing about but completely unlike any current design) but that isn't really important after completing the work in that book and raising investment capital for your company, you can honestly call yourself a fullstack engineer — arm — the best architecture to write assembly for is the arm—the original one, not thumb, which is a bit of a pain—and arm is also only slightly more complex to build than the fake-ass architecture in nand2tetris, and quite a bit faster. if you already know any assembly language, including the nand2tetris one, the best introduction to arm might not actually be any current tutorial but rather the vlsi arm3 datasheet from 01990 https://www.chiark.greenend.org.uk/~theom/riscos/docs/ARM3-datasheet_A… which has a summary of the instruction set on p.1-7 (9/56) and a fully complete description on pp.3-12 to 3-43 (19/56 to 34/56) as you probably know,…

I use "the 30 hour method"[0]. I think carefully about what is worth working on, then write it at the top of a sticky note. A few words will do, something like "Create X MVP" for example. Also write down the start date. As you put in time, write it down in pen on the sticky note. Once you've written down a time don't adjust it later, don't worry about it, the goal isn't to have a 100% accurate time log. Now that it's written down, you can't get out of it. The only way out is through. Work on it for 30 hours of dedicated work. It's long enough that you can get something done, but not so long that you'll waste your life if you choose the wrong thing. I used to work on too many different projects, and I think it was because I would switch projects once I hit a small difficulty. It wasn't a conscious thing; your subconscious can come up with plenty of valid reasons you should switch to something that seems easier. That 30 hour timebox will force you to overcome some difficulties, no more running away to another project to avoid doing something hard. But, if you choose something that really is too hard, try for 30 hours, it's long enough, but not too long. At the end, record what you worked on during that time. You might say "from October 1st to October 15th, I worked on X MVP, I struggled with Y, I learned Z". Think carefully about what is worth working on and choose the next thing. Maybe spend another 30 hours on the same thing. Maybe go back to something you were working…

There is this guide [0], the same person has also written a book. But I don't think it's a similar style? [0] https://azeria-labs.com/writing-arm-assembly-part-1/

I found Azeria's tutorial nice, although I stopped midway after an interruption few weeks ago: https://azeria-labs.com/writing-arm-assembly-part-1/

This gets shared a lot whenever Assembly is mentioned on HN but this is a pretty good intro to arm32 Assembly. The tutorials and examples can be run on a physical or emulated Raspberry Pi : https://azeria-labs.com/writing-arm-assembly-part-1/

https://azeria-labs.com/arm-on-x86-qemu-user/ is one example. You can run some of it (asm64 work but not the objdump or gdb, only 32 bit?) by using the docker under macOS ``` docker run -it --entrypoint "/bin/bash" ubuntu:latest ```

I found this pretty useful recently: https://azeria-labs.com/writing-arm-assembly-part-1/ There's also this, but I haven't dug much into it yet: https://hackaday.com/2018/09/20/learn-arm-assembly-with-the-raspberry-…

I found Azeria Labs [0] to be a pretty good introduction for learning ARM assembly basics. Although the main focus is ARM exploitation, it's still a good primer [0]: https://azeria-labs.com/writing-arm-assembly-part-1/

I personally often use this technique: https://azeria-labs.com/the-importance-of-deep-work-the-30-hour-method…

I use the pre-built image from Azeria Labs. It's a Linux VM with QEMU set up for Pi/Raspian out of the box. https://azeria-labs.com/arm-lab-vm/

Take a look at this: https://azeria-labs.com/the-process-of-mastering-a-skill/

Qemu can emulate the Raspberry Pi - there's instructions here: https://azeria-labs.com/emulate-raspberry-pi-with-qemu/

As an extension to your comment, here's a decent advice which is based on the principle of DeepWork. https://azeria-labs.com/the-importance-of-deep-work-the-30-hour-method… So basically, instead of just going through different subjects try to work on 1 subject/topic for 30 hours (across multiple days, maybe take a break between days) and then check if you want to go further on the subject. Apparently, 30 hours is a good enough time frame to realise if you have an interest on the subject of your choosing. I'm struggling to actually start with something interesting, and after reading your comment I remembered the process outlined in the article. Thanks!!

Azeria Labs has a good introduction to ARM assembly and ARM exploitation. https://azeria-labs.com/writing-arm-assembly-part-1/

What's with the branch instructions "Branch with Link" and "Branch with Exchange"? What do they do? I haven't seen anything like this before. I see some explanation in https://azeria-labs.com/arm-conditional-execution-and-branching-part-6… but the reason why branching must work this way isn't explained. edit: I see "Branch with Exchange" switches the processor from ARM to Thumb in http://www.embedded.com/electronics-blogs/beginner-s-corner/4024632/In… But I don't see why switching processor modes must happen on branch instructions.

Try https://azeria-labs.com/writing-arm-assembly-part-1/.

Machine Learning: * https://www.youtube.com/watch?v=UzxYlbK2c7E: Andrew Ng's machine Learning course, the recommended entry point by most people * https://mlcourse.ai/ : More kaggle focused, but also more modern and has interesting projects Do both courses simultaneously, take good notes, write useful flashcards, and above all do all the exercises and projects Deep Learning * https://www.fast.ai/ - Very hands-on, begin with " Practical Deep Learning for Coders" and then "Advanced Deep Learning for coders" * https://www.coursera.org/specializations/deep-learning : More bottom-up approach, helps to understand the theory better Do those two courses in parallel (you can try 2 weeks of coursera followed by one of fastai in the beginning, and then just alternate between them), take notes, write good flashcards and above all do the exercises and projects. After that you will be done with the beginning, your next step will depend on what area interested you the most, and getting way too many resources right now can be extremely confusing, so I would recommend doing a follow-up post after you worked through the above resources. Also as non-ML stuff I recommend Scott Young's Ultralearning and Azeria's self improvement posts (https://azeria-labs.com/the-importance-of-deep-work-the-30-hour-method…