T
Thinking Geek
thinkingeek.com · Personal blog · on HN since 2013
Thinking Geek is a programmer's blog covering ARM assembly, GCC internals, Fortran runtime details and Rails deployment with Ansible.
What HN saysHN links it for its series on writing a GCC front end for the Tiny language and its ARM assembler tutorials, though one commenter notes the Raspberry Pi series ends early.
17HN people shared it
7linked it in comments
14stories submitted
238story points
1 year agolast shared
2013people per year2026
Most-shared posts
- 1GCC tiny4 people · 135 points · first shared 2016 · 16 comments on HN
- 2A Tiny GCC Front End (2016)2 people · 5 points · first shared 2017 · discussion on HN
- 3ARM Assembler in Raspberry Pi – Chapter 12 people · 3 points · first shared 2015 · discussion on HN
- 4A caveat with statically linked language runtimes2 people · 2 points · first shared 2025 · discussion on HN
- 5Create and configure EC2 instances for Rails deployment using Ansible2 people · 2 points · first shared 2014 · discussion on HN
- 6Exploring AArch64 assembler1 people · 64 points · first shared 2016 · 13 comments on HN
- 7Introduction to the gfortran array descriptor / dope vector1 people · 23 points · first shared 2018 · discussion on HN
- 8Check progress of a mysql database import1 people · 2 points · first shared 2014 · 1 comments on HN
- 9Exploring AArch64 assembler – Chapter 21 people · 2 points · first shared 2016 · discussion on HN
- 10Arm assembler raspberry pi chapter 51 people · first shared 2020
- 11Arm assembler raspberry pi chapter 91 people · first shared 2013
- 12Arm assembler raspberry pi1 people · first shared 2025
- 13Tiny gcc front part 71 people · first shared 2016
- 14Raspberry vectors part 91 people · first shared 2025
What HN people wrote when they linked it
dansmyers · 2025-08-08
We use ARM in our computer organization classes. It's more accessible than x86 and allows you to get a feel for the important concepts of assembly: register-to-register operations, conditional branching, and how the stack is used to manage function calls and returns.
I like the CPUlator as a platform. It lets you step through the program one instruction at a time and observe all of the registers and memory locations.
https://cpulator.01xz.net/?sys=arm
This set of lessons is a good starting point:
https://thinkingeek.com/series/arm-assembler-raspberry-pi/
My course repository has several example programs with explanatory comments:
https://github.com/dansmyers/ComputerOrganizationAndArchitecture/tree/…
theaustinseven · 2017-09-05
This is for building a compiler for the language tiny: http://thinkingeek.com/gcc-tiny/
Otherwise, get your hands dirty with a parser generator(PEG parser generators[1] tend to be fairly forgiving). It is pretty easy to get started making an interpreter that way, and it is quick to prototype with.
[1]: http://bford.info/packrat/
crncosta · 2016-01-22
For those interested in GNU GCC, there is a more recent document been writing here:
http://thinkingeek.com/gcc-tiny/
The author is also writing blog posts about how to code a GCC frontend. Here is the 7º part:
http://thinkingeek.com/2016/01/19/tiny-gcc-front-part-7/
shepardrtc · 2015-08-11
This series ends abruptly at Part 2. The author said there would be a Part 3, but I couldn't find anything.
In any case, if you want another overview article on ARM Assembly, try this: http://www.coranac.com/tonc/text/asm.htm
If you want a tutorial: http://thinkingeek.com/2013/01/09/arm-assembler-raspberry-pi-chapter-1…
And finally, this is a pretty good book if you've never looked at Assembly before and you've got a RPi or RPi emulator: http://www.amazon.com/Raspberry-Assembly-Language-RASPBIAN-Beginners/d…
thangalin · 2013-07-24
cosmicgadget · 2025-04-25
Three fundamental flaws of SIMD ISA:s - Bits'n'Bites (https://news.ycombinator.com/item?id=43783416)
1. Snell-Pym » Processor architecture (https://www.snell-pym.org.uk/archives/2017/03/17/processor-architectur…
2. Fun with vectors in the Raspberry Pi 1 - Part 9 (https://thinkingeek.com/2021/08/22/raspberry-vectors-part-9/)
I think we have enough pieces of machinery working already that we can start with the most exciting part of this journey: autovectorisation!
3. Efficiently compiling efficient query plans for modern hardware | the morning paper (https://blog.acolyer.org/2016/05/23/efficiently-compiling-efficient-qu…
4. Understanding SIMD: Infinite Complexity of Trivial Problems ?? | Ash's Blog (https://ashvardanian.com/posts/understanding-simd-complexity/)
5. SIMD in the GPU world - RasterGrid (https://www.rastergrid.com/blog/gpu-tech/2022/02/simd-in-the-gpu-world…
oso2k · 2020-08-24
`JL` and other conditional jumps/branches are a common type of instruction [0][1][2].
Depending on the ISA [3][4][5], there can be jumps, branches, and subroutine transfers (or even a subset of those). Some can be based (conditional) on what value is in a primary register (often traditionally called the accumulator), a condition/flag/status register, a memory location, and even well known constants (0, 1, -1). Many ISAs have ways branching to a function/subroutine/procedure that can include adjusting a calling stack or transferring control to an OS kernel. x86 is notable in that you can cause a branch or jump without calling a branch or jump instruction.
[0] https://www.tutorialspoint.com/assembly_programming/assembly_condition…
[1] https://thinkingeek.com/2013/01/19/arm-assembler-raspberry-pi-chapter-…
[2] https://www.ibm.com/developerworks/library/l-powasm3/index.html
[3] https://en.wikipedia.org/wiki/Instruction_set_architecture
[4] https://en.wikipedia.org/wiki/Branch_(computer_science)
[5] https://en.wikipedia.org/wiki/Subroutine