The Curious Engineer

All blogs / Software / engineering practice

The Craft of Coding

craftofcoding.wordpress.com

Musings on programming and education

Software / engineering practiceAlgorithms / data structuresCEssays / personal

’15’20’25
Posts
1,346 from 28 Jun 2013 to 9 Sep 2026
Posting
monthly (12 in the last year)
Kind
personal blog
Feed
https://craftofcoding.wordpress.com/feed/

2026 10

  1. Petzval on academia (1840-ish Vienna)
  2. University education is cooked
  3. Will we embrace sentient androids? (when they evolve)
  4. Everyone hates a sad professor
  5. Don’t judge new professors too harshly
  6. Why do students fail at computer science?
  7. Participation vs. commitment
  8. Good writing comes from life experiences
  9. The passing of Sir Tony Hoare
  10. Numbers in context − Chinese EV’s: Is 3% significant?

2025 17

  1. Numbers in context − $1M lump sum, or $1000 per week?
  2. Numbers in context − Cookware statistics
  3. The age of computer science is waning (mostly)
  4. Has smartphone technology peaked?
  5. Is the human mind becoming overwhelmed?
  6. Computer-science is cooked (at least for some)
  7. Predictions of the internet : 1994
  8. Rise of the human machines − the ascent of the AI-driven student
  9. Do I miss coding?
  10. Unix was a new style of computing
  11. You don’t know the power of grep
  12. It’s the end of the PhD as we know it (and I feel fine)
  13. On life in retirement from academia
  14. Reflections on 25 years in academia
  15. Only now, at the end, do you understand
  16. cis*3190 a students perspective
  17. Why is so much modern software garbage?

2024 87

  1. Musings from an almost-retired prof
  2. In C some things aren’t exactly what they seem
  3. Is this the weirdest thing in C?
  4. In C, memory management begins immediately
  5. Do Canadian CS degrees need to be 4 years long?
  6. Why does Star Wars tech seem so clunky?
  7. The wrong reason to do computer science
  8. My thoughts on course evaluations
  9. Dijkstra on the essence of programming
  10. Dijkstra on competent programming
  11. Niklaus Wirth on programming in 1968
  12. Algol-68 seemed like a good idea – until it wasn’t
  13. Tony Hoare on language design
  14. Niklaus Wirth on ALGOL-68
  15. Why Star Wars tech was often so secure
  16. What happened to futurism?
  17. The Wirth Trinity – Language comparison
  18. For some people self-learning is the best kind of pedagogy
  19. Fortran is a timeless language
  20. Winter is here for the mediocre CS grad
  21. A dozen basic skills for computer science students
  22. Why the Star Wars universe is decidedly anti-technology
  23. A non-recursive ruler
  24. Is writing a book worth it?
  25. The slowness of software
  26. Will I miss programming?
  27. C programming: while versus do-while
  28. Why didn’t “The Empire” have Google?
  29. Recursive patterns – the Heighway Dragon curve
  30. Who are the greatest computer scientists?
  31. The iPhone is ubiquitous – but what is it used for?
  32. Academic writing is often kinda blah
  33. Office emptied – check ☑︎
  34. Quicksort – Algorithm 63, and 64
  35. Is technology dehumanizing society?
  36. Is a computer science degree worthwhile in 2024?
  37. The math behind 30 year mortgages
  38. A non-recursive Towers of Hanoi
  39. The Josephus puzzle – using a circular linked list
  40. The Josephus puzzle – using arrays
  41. The Josephus puzzle – using recursion
  42. The Josephus puzzle
  43. The hailstone sequence and mutual recursion
  44. The hailstone sequence and recursion
  45. Recursion – The monkey in the well puzzle
  46. Why I’m glad to be done teaching
  47. Software is really quite forgettable
  48. The Eight Queens Puzzle (iv) – non-recursive
  49. I don’t want to sail with this ship of fools
  50. A Fortran stack module
  51. How to calculate large factorials
  52. A statistics program in Cobol
  53. Obfuscated code for π
  54. R.I.P. – Lena finally gets retired
  55. Printing Unicode in Ada
  56. Why isn’t it possible to calculate π to 100 decimal places?
  57. Going to cheat? Maybe don’t post to stackoverflow
  58. Numbers aren’t forever
  59. Troublesome calculations in algorithms
  60. Backtracking (via recursion) and maze-running
  61. Q&A on writing blog articles
  62. Lego versus Stoky’s
  63. Is it possible to “fix” higher education in Canada?
  64. Droste effect ads
  65. A multi-tiered approach to teaching recursion
  66. University tuition put into context
  67. Plateauing technology and boring computing
  68. Rise of the bricks – Does LEGO still engage children in creativity?
  69. An iterative Quicksort
  70. Recursive patterns – the Hilbert curve
  71. Why slow computing was a better learning experience
  72. R.I.P. Niklaus Wirth – you will be sorely missed
  73. Classic moments in Python…
  74. A simple but useful program
  75. Is programming useful in everyday life?
  76. Programming languages by generation
  77. Humanities are important as well
  78. Solving a word jumble in Fortran (v) – final things
  79. Solving a word jumble in Fortran (iv) – the lexicon
  80. Where are the fantastical new programming languages?
  81. Classic moments in coding…
  82. Solving a word jumble in Fortran (iii) – anagrams
  83. Solving a word jumble in Fortran (ii) – input
  84. Solving a word jumble in Fortran (i) – background
  85. Recursion – Pascal’s Triangle (ii)
  86. Recursion – Pascal’s Triangle (i)
  87. Exit stage left? (or just about…)

2023 126

  1. My thoughts on the Star Wars spin-offs
  2. Need a PhD supervisor? Please don’t email me.
  3. I’m on a break…
  4. Star Wars droids offer a good road forward for AI
  5. A Q&A about learning in a university environment
  6. Dijkstra on education
  7. Why not just use Python instead of Fortran?
  8. Computing phrases and meanings
  9. Recursion – the various types
  10. Failure is okay
  11. Coding with C-3PO
  12. Nature’s algorithms are better
  13. The algorithms of antiquity : Egyptian multiplication
  14. The algorithms of antiquity : Euclid’s GCD
  15. Kids learning to code might be a fruitless venture
  16. The algorithms of antiquity : Eratosthenes
  17. The algorithms of antiquity: Babylonia
  18. R.I.P. 🪦 archive.org
  19. Wading through the software mediocrity
  20. Tips for first-year computer science students
  21. The original Googol
  22. What is Meansort?
  23. What number is this?
  24. Thinking of cheating in computer science?
  25. Fibonacci humour
  26. Why do people question math?
  27. Calculating the volume of a gugelhupf pan
  28. Why a computer science degree isn’t everything
  29. Think a CS degree is a golden ticket? Why mediocre CS grads may have a harder time getting a good job in the future
  30. The truth about mental-health in academia
  31. Everyone in technology should read this book
  32. How much did mortgages cost in the 1980s?
  33. Why are so many young people oblivious to financial literacy?
  34. Just say NO to AI
  35. Why scientific journalism can be a joke at times
  36. Could software be the real problem with electric vehicles?
  37. Median filtering using Quickselect
  38. Why Fortran and Cobol will likely be immortal
  39. Recursion – The Knight’s Tour (N.Wirth)
  40. Is Gen-X tiring of technology?
  41. On HTML…
  42. In academia few dare to criticize the status quo
  43. AI will make some people mindless
  44. Stroustrup on the fine details
  45. Shouldn’t we worry about how “green” computing is?
  46. Wirth on “Good enough software”
  47. High school GPAs are *way* too high, and that’s a big problem
  48. Does university broaden the mind?
  49. Wirth on “Good languages”
  50. Niklaus Wirth on the complexity of systems
  51. Ignore-land
  52. The problem with (CS) grad school
  53. A trace of a recursive function
  54. AI will likely replace mediocre programmers
  55. A recursion example : step-by-step
  56. Recursion – implementing sum
  57. What is recursion?
  58. How computer graphics have changed…
  59. The reluctant academic
  60. A historical background to the word “recursion”
  61. Technology has just become a big blah
  62. Dobosort – An improved Bubblesort
  63. The best Sci-fi series?
  64. Technology, and poor parenting is making people soft
  65. Computer versus natural language
  66. Sorry, image processing is NOT a sub-field of AI
  67. The Eight Queens Puzzle (iii) – recursion
  68. The Eight Queens Puzzle (ii) – brute force
  69. The Eight Queens Puzzle (i) – background
  70. Students and the art of spoon-feeding
  71. Marvin on advice (in general) …
  72. Sheil on computer science
  73. Programming inefficiencies and redundant computations
  74. Wirth on inventing languages
  75. Generating a cylinder to represent HSB colour space
  76. How to deep dive for information
  77. Problem solving and the human condition
  78. Recursion – The Sieve of Eratosthenes
  79. Generating a colour wheel in Processing
  80. Why Processing is so good for visual things
  81. The Sieve of Eratosthenes (iii) – Cobol
  82. The Sieve of Eratosthenes (ii) – Fortran
  83. The Sieve of Eratosthenes (i) – Introduction
  84. Coding Cobol: Variable length arrays
  85. Coding Cobol: Arithmetic and picture clauses
  86. Coding Cobol: Adding “time to accrue” calculation
  87. Checking ISBN numbers in Cobol (ii)
  88. Checking ISBN numbers in Cobol (i)
  89. Does academia matter anymore?
  90. Coding Cobol: Simple compound interest
  91. Recursion – Compound Interest (in Ada)
  92. Do you remember the Macintosh 128K?
  93. A month in Ada
  94. Why don’t we use more Ada?
  95. Outputting special characters in Ada
  96. A more interesting linked list in Ada
  97. A basic linked list of words in Ada (ii)
  98. Skip_line through the tulips…
  99. A basic linked list of words in Ada (i)
  100. The rise of the mediocre programmer
  101. What it feels like sometimes to read other peoples code…
  102. Image processing in Ada (v) – the main program
  103. Image processing in Ada (iv) – more functionality
  104. The world of useless things
  105. Image processing in Ada (iii) – the package imageprocess
  106. Image processing in Ada (ii) – the package imagepgm
  107. Image processing in Ada (i) – the theory
  108. A recursive function for reading lines (from a file)
  109. The usability failures in our everyday lives
  110. How cold will my coffee be in X minutes?
  111. Some Fortran string tips
  112. More 2D strings in Fortran
  113. Calculating wind chill in Fortran
  114. One of the problems in the world is a lack of understanding about math
  115. Computing power is too often wasted
  116. Recursion: Permutations by interchange
  117. As AI gets smarter, humans get more stupid
  118. Translating an Algol-60 program to Fortran
  119. What is reverse engineering?
  120. The problem with π (iv) – Fortran to Ada
  121. Coding Fortran: A dynamic array of ragged strings
  122. Recursion : An algorithm for anagrams
  123. The problem with π (iii) – Pascal to Fortran
  124. Fortran – then versus now
  125. Why Fortran is a scientific powerhouse
  126. Another year, another piece of boring technology (or perhaps not?)

2022 143

  1. Kenya Hara on technology
  2. Tips for potential CS grad students
  3. It’s the end of social media as we know it, and I feel fine
  4. Python, where art thou?
  5. Punch-card humour
  6. I dislike OS upgrades because they break things
  7. Where is my flying car?
  8. Are there too many PhDs?
  9. Using awk: Adding line numbers to a program
  10. The shell: Calculating the size of directories
  11. What makes a successful CS grad student?
  12. Using awk: Counting words?
  13. Why some Python libraries aren’t all they’re cracked up to be
  14. University degrees ≠ intelligence
  15. The shell: Finding files using a specific name
  16. What is a modern programming language?
  17. Nonsensical recursion algorithms: Stutter
  18. The shell: Finding files using a specific date
  19. It’s not dead, Jim
  20. Why I hate this ad
  21. The problem with white text on a black background
  22. Languages Pre-Fortran
  23. Choosing a university? – Forget the guides and lists
  24. The worst type of usability?
  25. Half empty or half full?
  26. Why is software (usability) so horrible?
  27. Dȳkstra on the difficulty of recursion
  28. Computer science pioneers: Andrei P. Ershov
  29. Ershov on programmers
  30. How some institutions view scholarly work
  31. Dijkstra’s view of Ada
  32. Dȳkstra on the amathematical society
  33. Dȳkstra on Lisp
  34. Dȳkstra answers a question
  35. Some advice on post-secondary education – for parents
  36. Hoare on PL/1
  37. Dijkstra on curricula
  38. Dijkstra on AI
  39. Education has become the winter of our discontent
  40. Dijkstra on the end of computing science
  41. Dijkstra on faculty
  42. When is a question considered stupid?
  43. Why don’t we build simpler things?
  44. Are cars too complex?
  45. Where are the pink OO unicorns?
  46. Why some students “miss the mark” in computer science
  47. Teach yourself you must
  48. Do you need course material?
  49. On a breather…
  50. Arrays are not pointers!
  51. The programming problem
  52. The “Average Joe” system
  53. Who are we?
  54. Sagan on books
  55. The do’s and don’t of student success
  56. A limit to human abilities?
  57. This is the way
  58. McIlroy on C
  59. On the complexity of C++
  60. Flon on Programming
  61. Do computer scientists love computers?
  62. A CS education is about teaching yourself
  63. Ritchie on C (1977)
  64. Dijkstra on software maintenance
  65. Dijkstra on software engineering
  66. Ritchie on C’s terseness (1977)
  67. A weird C memory bug (i.e. stack directions)
  68. Expectations of writing abilities in higher education
  69. Advice for programming language designers
  70. Technology is often just a house of cards
  71. With recursion a problem solves itself
  72. Do these equations differ?
  73. How to interpret a simple equation
  74. Fibonacci and sunflowers
  75. Fibonacci and pinecones
  76. Technology – as harmful as it is helpful
  77. A simpler life with less technology
  78. Memories of Fortran II
  79. Do or do not…
  80. Timing a Python program
  81. A few words with Niklaus Wirth
  82. Memories of Fortran
  83. A learnable language can be judged by the quality of its error messages
  84. The art of googling
  85. Fortran – the greatest thing (for arrays) since bread came sliced
  86. Blue
  87. Tactile experiences and the world of reverse digitization
  88. Coding Fortran: external vs. module vs. interface
  89. Are you writing safety critical code in C?
  90. Making funny characters visible
  91. Ever wondered why goto is considered harmful?
  92. Coding Cobol: Many ways of doing things
  93. Coding Cobol: Tricks with arrays (or tables)
  94. Coding Cobol: Reading in an array of things
  95. A process zapper in C
  96. The Myths of Fortran
  97. Coding Cobol: A note on strings
  98. Dijkstra on PL/1
  99. Star Trek’s Achilles heel is time-travel.
  100. Why I have given up on Julia
  101. Shell script: batch converting filenames to lowercase
  102. If you want to learn a new language then teach yourself!
  103. The timeline of Fortran
  104. Shell script: Deleting executable’s from the command-line
  105. What to learn Unix?
  106. Cobol is no zombie!
  107. The basics of program legibility
  108. The timeline of C
  109. The confusing world of Nim
  110. The basics of configuring the Z shell (on a Mac)
  111. You don’t know the power of the shell
  112. Recursion versus iteration
  113. The evolution of C-based languages
  114. The evolution of C
  115. Recursion in Python
  116. Recursion and problem solving
  117. Toy programming languages are like atomic playsets of the 1950s
  118. What Fortran does better than C-like languages
  119. Coding Ada: get vs. get_line (ii) – some caveats
  120. Coding Ada: Using multiple packages
  121. Coding Ada: get vs. get_line (i) – the basics
  122. Ada is defensive by default
  123. Forget about teaching kids to code
  124. Reengineering a messy “arithmetic if” in Fortran (iv) – rebuilding the code
  125. Dead, extinct and expired programming languages
  126. Reengineering a messy “arithmetic if” in Fortran (iii) – reverse engineering
  127. The art of naming variables
  128. What are the most common website usability mistakes?
  129. Exploring website usability (ii)
  130. Is C++ just pure dark magic?
  131. Exploring website usability (i)
  132. Reengineering a messy “arithmetic if” in Fortran (ii) – the analysis
  133. Reengineering a messy “arithmetic if” in Fortran (i)
  134. Coding Fortran: Writing an image as a text image file
  135. Translating BASIC to Fortran: Twin primes
  136. The caveat of fixed-point numbers
  137. Coding Fortran: Reading a text image from a file
  138. Coding Fortran: Funny read behaviour from files
  139. The low down on legacy code and languages
  140. Why rankings are kind of hogwash
  141. The origins of the word “program” in computing
  142. Why Fortran is easy to learn
  143. Saving the princess

2021 174

  1. How to build a horse with programming…
  2. Programming languages through the ages…
  3. Why Python dependencies are just plain cruel
  4. When not to use recursion
  5. Fibonacci by linear recursion is better
  6. The tapering of technology
  7. The best what?
  8. The age of zombie apps
  9. Fortran Re-engineering: Debt repayment schedule (vi)
  10. Fortran Re-engineering: Debt repayment schedule (v)
  11. Why higher education needs more problem solving courses
  12. Can computers think?
  13. The conundrum of languages in a CS curriculum
  14. The value of a liberal arts degree
  15. Big-O and speed
  16. Vacations of the mind (or the burden of data)
  17. Big-O – Some examples
  18. Big O notation- What is it good for?
  19. Tail recursion – What’s so special?
  20. Amicable numbers in Fortran
  21. The origins of algorithm
  22. Algorithms are as easy as cake
  23. Wirth’s thoughts on the “new Algol” committee.
  24. Programming made easy (ix) – mortgage payments
  25. Recursion – the basics of tail recursion
  26. Thresholding algorithms: Bernsen (local)
  27. Programming made easy (viii) – carbon dating
  28. Is “for” the best term for a loop?
  29. Programming made easy (vii) – looping
  30. Programming made easy (vi) – making decisions
  31. Programming made easy (v) – input and output
  32. Programming made easy (iv) – arithmetic
  33. Programming made easy (iii) – data
  34. Universities not preparing students? Likely.
  35. Programming made easy (ii) – algorithms
  36. Programming made easy (i) – languages
  37. Not every algorithm works every time
  38. Are bootcamps the future for the software industry?
  39. Thresholding algorithms: Sauvola (local)
  40. Why isn’t CS pedagogy progressive?
  41. Chaos and bifurcation diagrams
  42. Thresholding algorithms: Niblack (local)
  43. If UFOs exist, what do they code in?
  44. Thresholding algorithms: Phansalkar (local)
  45. Image processing algorithms in Julia
  46. What is the Shuttle sort?
  47. The origins of Bubble sort
  48. Why new algorithms are hard to develop
  49. Recursive patterns – lightning bolts
  50. Governments making software “in house” is just a bad idea
  51. Fractal patterns – Barnsley ferns
  52. Recursive patterns – the Sierpinski gasket
  53. The origins of Fibonacci and recursion
  54. Why Julia is not great for novice programmers
  55. The Square-Diamond algorithm for 2D surfaces (ii) – implementation
  56. The Square-Diamond algorithm for 2D surfaces (i) – basics
  57. Midpoint displacement in 2D
  58. Generating terrain with midpoint-displacement
  59. Demystifying random numbers – Box-Muller Method
  60. Demystifying random numbers – Schrage’s Method
  61. Demystifying random numbers
  62. Fractal Brownian motion using random midpoint displacement
  63. Plankalkül – the first language (ii)
  64. Plankalkül – the first language (i)
  65. Recursion and Matryoshka dolls
  66. What’s wrong with CS degrees?
  67. Quora – adventures in stupidland
  68. Peasant multiplication algorithm (ii) : Recursion
  69. Peasant multiplication algorithm (i)
  70. A recursive Bubblesort
  71. Are computer science degrees archaic?
  72. Recursion – Listing Unix directories in C (alternative output)
  73. Recursion – The Hofstadter sequences
  74. Recursion (not) – Ackermann’s Function (iv) – iterative
  75. Recursion – McCarthy’s “91 function”
  76. The Babylonians upstage Pythagoras
  77. Recursion (not) – Ackermann’s Function (iii) – stacks
  78. Why blog?
  79. Why are most programming languages in English?
  80. Recursion – subfactorials and double factorials
  81. How to write a bad program
  82. Why academia is not as open minded as people think
  83. The Terminal Digits of 2^T
  84. The Wirth Trinity – Design and examples
  85. Recursion – Fibonacci using Vorob’ev’s Equation
  86. Recursion – structural versus generative
  87. Euler : The beginnings of a journey
  88. Recursion – What is a primitive recursive function?
  89. Recursion – Ackermann’s Function (ii)
  90. Recursion – Ackermann’s Function (i)
  91. Algol-W : A precursor to Pascal
  92. The black magic of casting pointers in C
  93. The Wirth Trinity – Oberon
  94. Understandability and compactness
  95. The Wirth Trinity – Modula-2
  96. The usability of Fortran
  97. Fun with C and Pascal
  98. Recursion – Sudan’s Function
  99. Testing Julia for Speed – 2021 update
  100. The Wirth Trinity – Pascal
  101. Myths about becoming a programmer
  102. C++ – The Cobol of the 90s
  103. When you could read about the whole Internet in a book
  104. Why C and C++ are dangerous languages (for novice programmers)
  105. Has programming language design become dull and soulless?
  106. The shell: Searching file contents with grep
  107. The art of over-commenting
  108. The shortcomings of C: (v) control structures
  109. The shortcomings of C: (iv) floats and ints
  110. The shortcomings of C: (iii) too many operators
  111. Legacy code and comments
  112. The shortcomings of C: (ii) undefined behaviour
  113. The shortcomings of C: (i) ambiguities
  114. Algorithm 35: The Sieve (in Algol-68)
  115. Zuse on academic theoreticians
  116. Things you should never do as computer science student
  117. C++ versus Ada for safety critical software (ii)
  118. C++ versus Ada for safety critical software (i)
  119. When designing a website, test *all* the browsers
  120. Why does no one write language critiques anymore?
  121. The caveats of Julia for image processing (ii) – the image structure
  122. Zero-based indexing considered harmful
  123. An insight into legacy systems
  124. Coding Cobol: A bubblesort
  125. The caveats of Julia for image processing (i) – overview
  126. Coding Cobol: Checking a file exists
  127. A thought on COBOL
  128. The Swiss Army Knife Syndrome and ALGOL 68
  129. The Zuse Z4: Computing at ETH in the 1950s
  130. Recursion – the Pascal years
  131. Recursion – local variables
  132. Recursion – Fortran finally gets it!
  133. Ditching a tricky arithmetic if
  134. 2D strings in Fortran
  135. Who were the best language designers?
  136. Why does NASA not allow recursion?
  137. Superplan – groovy!
  138. Is the software crisis chronic?
  139. Defensive programming: Validating input in C and Fortran
  140. Why APL floundered as a language
  141. The problems with Julia.
  142. Program readability and tricky logic
  143. The problem with implementing algorithms
  144. Is HTML easy to learn?
  145. Evolution of the assignment operator
  146. The Wirth Trinity
  147. Algol – Breaking the sequential flow
  148. Coding Ada: strings (iv) – unbounded to string
  149. What I really dislike about Julia? It’s scope.
  150. Julia is bad at recursion
  151. Recursion – Slowsort
  152. Fortran Reengineering: entombing legacy subprograms
  153. Why Python is horrible for recursion
  154. Explaining pointers – Pascal and C
  155. What makes a good online grocery experience in Ontario?
  156. Coding Fortran: contains (modularity)
  157. Coding Fortran: Interface blocks (modularity)
  158. Coding Fortran: subprograms (modularity)
  159. Coding Fortran: Validating input
  160. How to write a program specification
  161. Fortran Reengineering: arctan (iv)
  162. Fortran Reengineering: arctan (iii)
  163. Fortran Reengineering: arctan (ii)
  164. Fortran Re-engineering: arctan (i)
  165. Coding Cobol: reading a file of integers
  166. Why do some “technical” books cost so much?
  167. Programming isn’t software development
  168. Into the depths – infinite recursion
  169. Computer Science Pioneers: Konrad Zuse
  170. Coding Fortran: nested functions
  171. The subtleties of language elegance
  172. Coding Ada: strings (iii) – arrays of strings
  173. The power of the backup
  174. Why Algol bested Fortran (for a bit)

2020 135

  1. Examples of well designed e-commerce sites
  2. Some big-box retailers still don’t get e-commerce
  3. The irony of e-commerce
  4. If you want to do a PhD, here are some things you should know
  5. The dark art of defensive programming
  6. Sloppy coding? Try some defensive programming
  7. In the 1960s you had to implement your own compiler
  8. Recursion in APL
  9. Recursion – Fortran bends the rules
  10. Recursion – the trouble with early Fortran
  11. Recursion – the ALGOL60 years
  12. Nuclear winter – coding for fun?
  13. A exceptional article on the use of Cobol
  14. Image processing was once simple
  15. The advent of flexible learning
  16. Programming languages are like ancient script
  17. Learning linked lists (v) – deleting a node
  18. Imagination and tinkering
  19. Learning linked lists (iv) – inserting a node
  20. Learning linked lists (iii) – traversing a list
  21. How to become a good writer
  22. Why is Julia not more popular?
  23. The Great Beyond – the future of Computer science education
  24. Recursion – Decimal to binary
  25. Learning linked lists (ii) – adding nodes to a list
  26. Learning linked lists (i) – the low-down
  27. The craft of programming
  28. Want to learn to program?
  29. The pandemic will change the way technology companies operate
  30. Overloading of the mind
  31. On hiatus…
  32. So long, and thanks for all the fish.
  33. Musings on why the Towers of Hanoi is hard to comprehend
  34. Recursion and the human mind
  35. Programming is…
  36. Teaching Grade One’s to code – Are U nuts???
  37. The value of a humanities education
  38. Recursion – The Towers of Hanoi (iii)
  39. Don’t mention the “search”
  40. Recursion – The Towers of Hanoi (ii)
  41. The internet: Drinking from a hydrant
  42. Teachers aren’t always good learners
  43. Why a syntax-heavy course = lack of programming skill diversity
  44. Why we skipped the superfluous semi-symbol
  45. Too much information?
  46. Recursion – The Towers of Hanoi (i)
  47. Fibonacci and pineapples
  48. The new norm in post-secondary education?
  49. Why novice programmers end up hating programming
  50. Are arrays in C pointers?
  51. Time travelling with the post
  52. Why technology is a thin facade
  53. Explaining pointers – the basics
  54. Recursive patterns – the Cantor set
  55. What is elegant code?
  56. Does brace style matter?
  57. Programming made easy – nested loops
  58. Are programs beautiful?
  59. The conundrum of the tab
  60. Kernighan on C
  61. Programming made easy – loops (iii)
  62. Programming made easy – loops (ii)
  63. Programming made easy – loops (i)
  64. Programming made easy – if statements
  65. Are Dolphins smarter?
  66. Do droids have consciousness?
  67. Recursion and marking a rule (ii)
  68. Calculating π with Gregory-Leibniz (iv) – Julia just for fun
  69. Cobol is alive!
  70. Calculating π with Gregory-Leibniz (iii) – C by other means
  71. Calculating π with Gregory-Leibniz (ii) – Fortran
  72. Calculating π with Gregory-Leibniz (i) – C
  73. Live forever as a synth?
  74. Coding Ada: Bitwise operators
  75. Recursion and marking a rule (i)
  76. Recursion – Listing Unix directories in C
  77. Global variables and side effects
  78. Beyond the edge…
  79. Life? It’s all around us.
  80. To infinity and beyond
  81. Recursion (versus iteration)
  82. Unix and C living in symbiosis
  83. A cat by any other name?
  84. Why calculating Fibonacci using binary recursion is just plain moronic
  85. Coding Cobol: Recursion
  86. Unix – The most powerful OS?
  87. Programming made easy – how to learn the basics of any language
  88. A quick comparison of sh vs. csh
  89. Sally Sells C Shells, but what about Bourne?
  90. The shell: Stripping parts of filenames (in Unix)
  91. Removing a.out’s with a shell script
  92. How to develop a recursive algorithm
  93. Coding Cobol: Legacy if statements
  94. Coding Cobol: Replacing “go to” with a loop
  95. Coding Cobol: Replacing “go to” with perform
  96. Coding Cobol: Transfer of control in paragraphs and sections
  97. Coding Cobol: functions (external)
  98. Coding Cobol: built-in functions
  99. Calculating Babylonian square roots (ii)
  100. Calculating Babylonian square roots (i)
  101. Loading language syntax into the brain is expensive
  102. Removing goto’s that jump backwards
  103. Random integers in a range
  104. What is throw-away code?
  105. 7 Degrees of Correctness
  106. Coding Ada: Random numbers
  107. The world of unstructured programming, i.e. spaghetti code
  108. Usability confusion: Streetcar buttons
  109. The bustling evolution of languages
  110. Is goto evil?
  111. A Processing Example – The Archimedes Spiral
  112. If you want to visualize algorithms, code in Processing
  113. How efficient is your code?
  114. Fortran re-engineering: subprograms
  115. How to convert a decimal fraction to binary
  116. Fortran re-engineering: arithmetic if
  117. Fortran re-engineering: loops
  118. Floating-point precision in Fortran
  119. Is Fortran a weed, or an invasive species?
  120. The world of numeric errors
  121. Why 1/10 is not a precise real number
  122. Fortran re-engineering: data statements
  123. Converting characters to hexadecimal
  124. Fortran re-engineering: A small program for basic stats (iii)
  125. Fortran re-engineering: A small program for basic stats (ii)
  126. Fortran: character → hexadecimal
  127. Fortran re-engineering: A small program for basic stats (i)
  128. One thing Fortran won’t let you do (anymore, but C will)
  129. Fortran re-engineering: equivalence statements (ii)
  130. Fortran re-engineering: equivalence statements (i)
  131. Fortran is omnipotent
  132. Could you decipher this narly flowchart?
  133. The Fortran print statement
  134. Why Fortran is easier to learn than C
  135. An ancient math problem (in Fortran)

2019 54

  1. Sally sells C shells, but should she have?
  2. Learning recursion through visual patterns (ii)
  3. The dangers of technology in the home
  4. A simple Julia example – The Yorkshire Estates
  5. You could think like a computer scientist, but do you want to?
  6. Recursive patterns – the Koch snowflake
  7. Is a CS education meaningful?
  8. Recursive patterns – the Koch curve (iii)
  9. Recursive patterns – the Koch curve (ii)
  10. There are no 10-in-1 programming languages
  11. To learn how to program, you actually need to code
  12. Recursive patterns – the Koch curve (i)
  13. What we forsake for the sake of digital data
  14. Invention + making = resilience
  15. The truth about moisture vaporators
  16. What Dijkstra thought of AI
  17. Why blogging in academia is ok.
  18. A language, is a language, is a language
  19. Data, is not information, or knowledge
  20. Are we computing for computings sake?
  21. Why designing algorithms is hard
  22. Technology may be our biggest problem
  23. Principles of program efficiency
  24. Why teaching programming needs an experiential approach
  25. Hate OO? – read this article
  26. When Google translate fails
  27. A new blog!
  28. Semantics – human vs. programming languages
  29. Why human brains are so great
  30. Are programming languages really languages?
  31. Is HTML a *real* programming language?
  32. Teaching – We’re not in Kansas anymore
  33. Are 8K TVs useful technology?
  34. The fading light of technology?
  35. Computer vision, AI and the art of fruit picking
  36. Practicing problem solving with puzzles
  37. Coding Cobol: Calling C (ii) – arrays
  38. Coding Ada: Timing code and passing functions to functions
  39. Coding Cobol: Calling C (i)
  40. Human intuition
  41. Coding Cobol: Paragraphs, loops, and if statements
  42. Coding Cobol: A basic program
  43. The realm of real innovation
  44. Ada and goto
  45. Experiential learning in a food course
  46. Understanding history via experiential learning
  47. Fortran Re-engineering: Debt repayment schedule (iv)
  48. Fortran Re-engineering: Debt repayment schedule (iii)
  49. Fortran Re-engineering: Debt repayment schedule (ii)
  50. Fortran Re-engineering: Debt repayment schedule (i)
  51. A lack of problem solving in CS education
  52. Assume nothing
  53. Mediocrity in programming
  54. The [over] complexity of experiential learning

2018 131

  1. Machines don’t think, they process
  2. Too much schooling ? (or maybe just a different type)
  3. Experiential learning and failure
  4. The problem with programming is a lack of problem solving skills
  5. AI – the great abyss
  6. How the brain rewires itself…
  7. Deciding on post-highschool studies
  8. Computing – It’s life Jim, but not as we know it.
  9. A port, a port, my kingdom for a port!
  10. Cognitive load and arrays
  11. My “history of food” course in winter
  12. Pascal’s syntactic ambiguity and C’s ineptitude
  13. Pascal – a language for novice programmers
  14. Can an algorithm find the pattern?
  15. Why technology may not save us
  16. Why most institutions of higher learning are antediluvian
  17. Decaying apps
  18. Generating a recursive Romanesco broccoli
  19. Are great writers born?
  20. Is computing sustainable anymore?
  21. Is the world too complex?
  22. When algorithms may not be optimal
  23. Syntactic sugar and C : A report
  24. Recursive algorithm – The River Crossing puzzle
  25. Presto cards, and dodgy TTC software
  26. So I got 150Mbps fibre optic – what does that mean?
  27. Why Apple is king of the tech companies
  28. Quirky software in cars
  29. Away… for a bit.
  30. Human-machine interaction and the usability conundrum
  31. Art is about humanistic sensibilities
  32. Weird recursive algorithms
  33. What is Quickselect?
  34. My axe never needs an upgrade
  35. The new Loblaws self-checkouts – usability
  36. Stupid switch (ii) – Bad design
  37. Stupid switch (i) – Why B’s switch statement was better
  38. AI and Westworld
  39. Where did C arrays come from?
  40. Median image filtering: efficiency
  41. What ever happened to ideas?
  42. Recursive patterns – the Sierpinski Carpet
  43. Recursive patterns – the Sierpinski curve
  44. The recursive nature of baking powder
  45. Evolution of “if” in C
  46. Syntactic inheritance
  47. Learning recursion through visual patterns (i)
  48. A survey for computer science students
  49. The problem with Pi (ii)
  50. Parallelism in Julia (ii) – image processing
  51. The problem with Pi (i)
  52. Building a visualization of a sunflower spiral (ii)
  53. Building a visualization of a sunflower spiral (i)
  54. Using the “Processing” language
  55. TTC digital transfers – Is there something wrong with their Presto algorithm?
  56. Parallelism in Julia (i) – parallel loops
  57. Famous coding blunders
  58. Coding Ada: reading lines from files.
  59. Timing and efficiency in C programs (ii)
  60. Timing and efficiency in C programs (i)
  61. Coding Ada: Using an exception
  62. Why the Montreal Metro (subway) has good usability
  63. While C is a surfer dude, Ada is Thor
  64. Coding Cobol: dynamic filenames
  65. Are autonomous vehicles that important?
  66. C language: The good, the badly, and the ugly
  67. A weird C memory bug
  68. Coding Cobol: Basic re-engineering
  69. Coding Cobol: A program with loops (and an array)
  70. Coding Cobol: An alternate program
  71. Coding Cobol: What’s with those weird numbers?
  72. Coding Cobol: if statements (and reading from a file)
  73. Cognitive load and knowledge transfer
  74. Cognitive load in programming languages – loops
  75. Cognitive load in programming languages – the basics
  76. Coding Cobol: A more verbose calculation
  77. Coding Cobol: A picture is worth 1000 words
  78. Coding Cobol: A basic “Hello World”
  79. Memory in C – peeking at the HEX addresses (ii)
  80. Coding Ada: pointers (the extreme basics)
  81. Thoughts on becoming a good programmer
  82. Memory in C – peeking at the HEX addresses (i)
  83. Segmenting eyes through thresholding (ii)
  84. Segmenting eyes through thresholding (i)
  85. Programming languages are the interface to the machine
  86. Coding Fortran: file I/O
  87. Coding Ada: packages (+ records and file I/O) (ii)
  88. Coding Ada: packages (+ records and file I/O) (i)
  89. Why I like organic coding
  90. Coding Ada: strings (ii) – unbounded
  91. Coding Ada: strings (i) – fixed
  92. Coding Ada: declare blocks
  93. Coding Ada: arrays (ii)
  94. Coding Ada: arrays (i)
  95. Coding Ada: global variables
  96. Coding Ada: nested subprograms and scope
  97. Coding Ada: functions
  98. Coding Ada: procedures
  99. Give me an “A”, give me an “I”, what do they spell?
  100. Coding Ada: other loops (or “do you need a loop and a half?”)
  101. Coding Ada: for loops (and raising errors)
  102. Coding Ada: if-else (and some I/O)
  103. Coding Ada: datatypes and assignment
  104. Coding Ada: A basic “Hello World!”
  105. Autonomous vehicles… and the real world
  106. Why taxpayer funded research should be open-access
  107. Interoperability : Calling Fortran from C (ii)
  108. Coding Fortran: strings
  109. Interoperability : Calling Fortran from C (i)
  110. Partial re-engineering and frameworks (entombing)
  111. Arrays and memory in Fortran
  112. Coding Fortran: Allocatable (dynamic) arrays
  113. Character arrays vs strings in Fortran
  114. Coding Fortran: modules
  115. Coding Fortran: a sorting module
  116. Coding Fortran: Arrays
  117. Fortran re-engineering: Prime Number Generator (v)
  118. Fortran re-engineering: Prime Number Generator (iv)
  119. Coding Fortran: functions
  120. Fortran re-engineering: Prime Number Generator (iii)
  121. Fortran re-engineering: Prime Number Generator (ii)
  122. Fortran re-engineering: Prime Number Generator (i)
  123. Coding Fortran: subroutines
  124. Coding Fortran: loops (or rather the do loop)
  125. Coding Fortran: if-else
  126. A brief guide to Fortran Re-engineering
  127. Coding Fortran: A basic “Hello World”
  128. Does Fortran matter?
  129. Windows – 200 years in the future? I hope not!
  130. Recollections of programming in the 1980s
  131. Haiku

2017 194

  1. Is there something weird going on here?
  2. Why we should all share code
  3. Pupil segmentation with blobs
  4. What life means – and it’s not the number 42
  5. An example of the Hough transform – pupil segmentation
  6. How many logs can a woodchuck count?
  7. Image mean filtering (iii) – in C
  8. Where is static memory stored in C?
  9. I like simple code
  10. Creating photographic filters (i) – desaturation and saturation
  11. Image mean filtering (ii) – in Fortran
  12. Image mean filtering (i) – in Python
  13. The worst usability = washing machines
  14. Computer humour – “real” programmers
  15. The real world of software development is not in academia
  16. Making a colour-splash effect filter
  17. Reducing technology [complexity] for a simpler life
  18. Life – a universe of possibilities
  19. What is a closed-loop?
  20. Why physical usability really matters
  21. Software – a step back in time
  22. Coding? Why kids don’t need it.
  23. When things aren’t quite what they seem
  24. Apple and design
  25. The usability of old blenders
  26. Is blogging an academic pursuit?
  27. Writing a textbook ≠ get rich quick scheme
  28. Why learning to code is easier in Julia (iii)
  29. Why learning to code is easier in Julia (ii)
  30. Why learning to code is easier in Julia (i)
  31. The driverless train
  32. Free smart thermostats? – no free lunch
  33. Why AI should be avoided
  34. Learning to program (xi) – files in Julia (Julia 1.0)
  35. When Google maps gets it wrong…
  36. Learning to program (x) – usability (Julia 1.0)
  37. Valerian – my thoughts on the movie
  38. The material of software craftsmanship is the language
  39. On furlough…
  40. Learning to program (ix) – all about style (Julia 1.0)
  41. Learning to program (viii) – Julia strings and functions (Julia 1.0)
  42. Learning to program (vii) – Julia strings (Julia 1.0)
  43. Learning to program (vi) – Julia arrays (Julia 1.0)
  44. Learning to program (v) – adding a subroutine (Julia 1.0)
  45. Errors never cease to amaze…
  46. Learning to program (iv) – going loopy in Julia (Julia 1.0)
  47. Learning to program (iii) – an intermediary Julia program (Julia 1.0)
  48. Learning to program (ii) – an interactive Julia program (Julia 1.0)
  49. Learning to program (i) – a simple program in Julia (Julia 1.0)
  50. So you want to get a PhD?
  51. Learning to program – One algorithm, many languages
  52. Software craftsmanship
  53. Learning to program – throw yourself in at the deep end
  54. Debunking myths about programming languages
  55. Debunking myths about programming (ii)
  56. Debunking myths about programming (i)
  57. Life Skills 101
  58. Is it a subroutine, or a function, or a procedure?
  59. Eco-conscription anyone?
  60. It’s life Jim – but not as we know it.
  61. Test, test, and test again
  62. The problem with CS education
  63. Why image segmentation is difficult (2)
  64. A simple programming language
  65. Forward creative thinking
  66. Are we too reliant on technology?
  67. Calling Fortran from Julia (iii) : passing 2D arrays
  68. The art of tagging (ii) – describing cereal boxes
  69. The art of tagging (i)
  70. Simplicity is the key to robust algorithms
  71. Caveats of algorithm complexity (ii)
  72. Caveats of algorithm complexity (i)
  73. Ghosts in the machine: Why Fortran failed to maintain its hold
  74. Coding: A small note on Cyclomatic complexity
  75. Ghosts in the machine: Algol 60
  76. The recursive factorial began life as Algorithm 33
  77. Why Algol 68 was weird (and ultimately failed)
  78. Why software is pre-Neolithic
  79. Puzzles that programs can’t solve
  80. Why building things is good for you
  81. Abbreviations in programming languages
  82. Program re-engineering: code cocooning
  83. Indenting… why not use 3-space indents?
  84. Occupational hazards
  85. Fibonacci in Swift
  86. Experiential programming (with Julia 1.0) (ii)
  87. Swift fixes C’s “issues”
  88. Experiential programming (with Julia 1.0) (i)
  89. Why programming for non-CS students is different
  90. CamelCase or Underscore?
  91. The design of dead languages…
  92. History of the horrid switch statement (iii): C and beyond
  93. What’s in a name?
  94. History of the horrid switch statement (ii): Algol 68
  95. History of the horrid switch statement (i): the early years
  96. Coming out this July: Valerian and the City of a Thousand Planets
  97. History of the early algorithmic languages
  98. Apps that “improve” photos
  99. Evolution of if (iv): Ada and beyond
  100. The use of in-camera filters
  101. Computer science pioneers: Heinz Rutishauser
  102. Early years of the for loop
  103. Efficiency considerations in loops
  104. The evolution of if (iii): Algol68, Pascal and C
  105. The evolution of if (ii): Fortran IV and 66
  106. The evolution of if (i): pre-Fortran to Algol 60
  107. SURF, SIFT? What about ORB?
  108. Software is like Lego bricks… except it isn’t
  109. Python and its “dependency” issues
  110. A stylistic viewpoint on compressed code
  111. Building a contrast enhancement filter in Julia (ii)
  112. Why reading code is important
  113. Building a contrast enhancement filter in Julia (i)
  114. In the software world..
  115. Image binarization (9) : Why image processing involves tinkering
  116. A crazy command line
  117. A cool software engineering degree
  118. Why long computer science degrees are passé
  119. Image binarization (8) : An example of differing approaches
  120. Ada loves exceptions
  121. Why you *have* to understand memory constraints
  122. What is sed?
  123. Image binarization (7) : What about local thresholding algorithms?
  124. Automatic line numbering
  125. Nested functions and scope in Julia
  126. Timing a Fortran function
  127. Julia and nested functions
  128. Dynamic strings in Fortran
  129. Timing an Ada function
  130. Tales of cryptic Cobol: strings
  131. Plotting image histograms with Julia
  132. The usability of washing machine labels
  133. UPPERCASE to lowercase with Cobol (oh yeah!)
  134. Binary images: dark objects on a light background?
  135. How long should an identifier be?
  136. Why uppercase is not so good for programs
  137. Reading “dynamic” filenames in Cobol programs
  138. The humble semicolon
  139. Why 1-based indexing is *OK*.
  140. Image binarization (5) : A harder example
  141. Image binarization (6) : The pitfalls
  142. Python is fast enough
  143. Software glitches?
  144. Image binarization (4) : A simple example
  145. What’s wrong with image processing?
  146. A brief look at the utter madness of Algol 68
  147. Languages in Perspective: The Algol ”family”
  148. Don’t think legacy systems are real?
  149. Why you should become a multilingual programmer
  150. AI – Answers from the great beyond?
  151. Calling Fortran from Julia (ii)
  152. Fortran re-engineering example (6)
  153. Fortran re-engineering example (5)
  154. A nice error message?
  155. Calling Fortran from Julia (i)
  156. Image binarization (3) : What should be binarized?
  157. Fortran re-engineering example (4)
  158. Fortran re-engineering example (3)
  159. Fortran re-engineering example (2)
  160. Image binarization (2) : Art or science?
  161. Why some algorithms *seem* to work
  162. Image processing fun with FFT! (iii)
  163. Image processing fun with FFT! (ii)
  164. Image processing fun with FFT! (i)
  165. Image binarization (1b) : It’s all about the data
  166. Image Processing: Why Lena doesn’t matter anymore.
  167. Ada : Generic stacks (ii)
  168. Ada : Generic stacks (i)
  169. Image binarization (1) : Introduction
  170. Finding specific elements in a Julia array
  171. Calling C from Julia (ii) : 2D arrays
  172. Ada : building with blocks
  173. Why image segmentation is difficult (1)
  174. Calling C from Julia (i) : Simple arrays
  175. Why Ada matters.
  176. Fortran re-engineering example (1)
  177. Column-major vs row-major arrays: Does it matter?
  178. Real random numbers in Fortran
  179. Read your own punch cards
  180. Python’s Achilles heel
  181. Re-engineering loops for efficiency (ii)
  182. Quote from “The Mind of Mechanical Man”
  183. Backus on programming in the 1950s
  184. Re-engineering loops for efficiency (i)
  185. An artistic filter (in Julia)
  186. Simpler Japanese toilet user interfaces…
  187. How to process problematic images?
  188. Want to see a real legacy Fortran program design spec?
  189. Where did image processing begin?
  190. NASA’s image processing in the 60s.
  191. How many goto’s in old code?
  192. Don’t like pointers? Where did they come from?
  193. My periodic table of programming languages
  194. One of my favourite words.

2016 134

  1. Why universities don’t work anymore
  2. Software is not rocket science
  3. Xmas bug
  4. What’s up for 2017?
  5. What’s with technology companies?
  6. “Smart” homes – the dark side
  7. The F-35 : An exercise in what software shouldn’t be
  8. Will computers take over the world?
  9. A.I. – what’s all the hype?
  10. e-books take over the word… NOT!
  11. The art of searching for knowledge
  12. Grapheme clusters – YUM!
  13. The problem with evolving languages today
  14. Imagination versus skill
  15. Did old code have weird style?
  16. Where did the use of long variables in C come from?
  17. Living languages
  18. Why ulimit is not a cure all for stack problems
  19. I type, therefore I am – The conundrum of data types in languages.
  20. When did indenting appear in programs?
  21. Memories of memory
  22. Design of a string type for C
  23. How lucid is Lucid?
  24. The shortcut if
  25. Pascal’s Achilles Heel
  26. The devolution of usability
  27. Structural erosion in old code, i.e. rot
  28. The user interfaces of Star Trek – vocal
  29. Survival usability
  30. Are some people just clueless?
  31. Usability and online reviews
  32. Programming blunders
  33. McDonalds gets their touchscreen right
  34. Should the switch statement exist?
  35. Programming syntax and its analogy with English (ii)
  36. Never trust software
  37. Programming syntax and its analogy with English (i)
  38. Miracles You’ll See in the Next 50 Years: A retrospective
  39. The butterfly effect
  40. The cognitive load of C: arrays
  41. The cognitive load of C: functions
  42. The cognitive load of programming languages on the novice programmer
  43. Image processing in Julia (ii)
  44. What Star Wars teaches us about technology
  45. Overflowing the stack in Python
  46. Hubots and technology creep
  47. Thinking considered superfluous (part 2)
  48. Is legacy computing infrastructure to blame?
  49. Life is but a funny walk.
  50. On hiatus…
  51. Are computers morons?
  52. Memory in C – an example
  53. The biggest problem with Python?
  54. Image Processing toolbox for Julia
  55. Translating code to Julia
  56. Debunking TV technology: Reflections in the cornea
  57. The house of the future… in 1956
  58. The life of variables in functions
  59. What is code complexity?
  60. Machine code in BASIC
  61. Learning to code 1980s style
  62. Julia breaks recursion!
  63. Making a heterogeneous stack in Julia
  64. And now? A real craft.
  65. Why add a string type to C?
  66. Technology overload?
  67. Image processing in Julia (i)
  68. Testing Julia for speed (iii)
  69. Testing Julia for speed (ii)
  70. Testing Julia for speed (i)
  71. Programming in Julia – the caveats
  72. Julia – Design in the small
  73. Programming in Julia – First impressions
  74. A lesson in life
  75. Usability – When “updating” software goes so wrong.
  76. Is it possible to fix C?
  77. Removing tabs from programs in Unix
  78. Chef vs. programmer
  79. Origins of the for loop
  80. What’s with the “dangling” else?
  81. Why Pascal is a good language
  82. One programming book you should read
  83. What happens when the glass falls?
  84. Is the computer science degree endangered?
  85. Calling a C function from Cobol
  86. UPPERCASE 2 lowercase conversion made easy
  87. History of languages: 1990s – super blah
  88. Calculating π
  89. Why nested functions can be cool.
  90. Programs written in other languages: German
  91. Is code optimization evil?
  92. Classic computer science papers you should read.
  93. How smart is AI?
  94. Exceptions are the Wookiees of Ada
  95. Humans and the usability of avocado’s
  96. BASIC was, well… basic
  97. The evolution of language symbols
  98. C obscenities = versus :=
  99. Thinking considered superfluous (part 1)
  100. C obscenities – the shortcut operators
  101. C obscenities – three increment operators
  102. C obscenities – && and ||
  103. When software updates, do you question it?
  104. Interesting items from the Joint Strike Fighter C++ coding standards.
  105. The F-35 jet fighter is programmed using what??
  106. Efficient compilers = less need for optimization?
  107. Language design: the control structure “terminator”
  108. History of languages: 1980s – super freaky!
  109. Ada characters are tricky… or not?
  110. goto not always considered harmful (in Ada)
  111. Backus on designing Fortran
  112. The utility of sets (in Pascal)
  113. The programmers biggest obstacle: time management
  114. Re-engineering versus Refactoring
  115. Dijkstra on Ada
  116. Do kids really need to code?
  117. The evolution of programming languages
  118. Fixing the “dangling else”
  119. Best introductory languages?
  120. Why you don’t need dynamic arrays in Fortran
  121. Tower of Babel
  122. Playing with arrays in Fortran (Part 2)
  123. Playing with arrays in Fortran (Part 1)
  124. The evolution of arrays in Fortran
  125. History of languages: disco days
  126. An example of why goto is horrible
  127. Banishment of goto
  128. Quote from Niklaus Wirth
  129. History of languages: automatic programming
  130. History of languages: bohemian times
  131. I code, therefore I am.
  132. Predicting the future… in the 1950s
  133. Computer science and AI – Stop the madness
  134. History of languages: the freewheeling fifties

2015 78

  1. Want to learn about legacy programming languages and re-engineering?
  2. Programming moisture vaporators
  3. Star Wars and Valerian
  4. The heap – malloc() and free()
  5. Memory and C – how the stack works
  6. Memory in C – stack versus heap
  7. Memory in C – the stack, the heap, and static
  8. How to store large images in C without pointers
  9. How to store large data in C?
  10. Why does int = long in C?
  11. My kingdom for a stack.
  12. And last but not least – arrays of structs.
  13. What is a typedef?
  14. What about nested structs?
  15. structs and functions
  16. Simple structs in C
  17. Algol compiler with some interesting feedback
  18. Dijkstra on APL
  19. Sally sells C strings by the C shore
  20. AI in Sci-Fi robots
  21. The Life of Variables.
  22. Reeds
  23. Why numbers don’t add up
  24. Computer science education should come out of the dark ages
  25. Why floating-point numbers aren’t really real
  26. What is dead code?
  27. DON’T fix what isn’t broken
  28. Clang – YIKES – a C compiler with user-friendly error messages!
  29. Zen-like algorithms
  30. Simple things
  31. The computers of Star Trek
  32. Read some code today
  33. Artificial intelligence ??
  34. Hindsight
  35. The potential for AI, or building a brain
  36. The user interfaces of Star Trek – LCARS
  37. The = and == conundrum
  38. Ingenuity of …
  39. The computers of Star Wars
  40. Why “smart” homes may not be the best idea.
  41. Deleted files on Unix or “Speaking with the undead”
  42. Why user interfaces in space should be simple
  43. Debunking TV technology: Deblurring and enhancing photographs
  44. Logging on to a Raspberry pi remotely
  45. The wildcards in Unix
  46. Overflows in space
  47. Changing file permissions in Unix
  48. Basic file permissions in Unix
  49. Killing programs softly
  50. The software on Apollo missions
  51. Hackable cars are a reality
  52. Who wrote the software for Apollo 11?
  53. What about Swift?
  54. C++ as an introductory programming language?
  55. Organic software design
  56. The most evil programming language
  57. Internet of things? It’s probably foolhardy.
  58. Psst… got an a.out problem?
  59. Debunking TV technology
  60. Programming is… not magic
  61. How jovial is Jovial?
  62. Forgotten algorithms: Euclidean Algorithm
  63. Unmastered complexity
  64. Languages for image processing
  65. Why technology isn’t always better
  66. Image processing – contrasting things
  67. First programming language – multiple languages anyone?
  68. See recursion
  69. Why Cobol is feared.
  70. Don’t underestimate the power of the Forth
  71. History of languages – it starts with Fortran
  72. The first programming languages (aka compilers)
  73. Programming in PL/I
  74. May the Forth be with you
  75. Lego and imagination
  76. Quote of the day
  77. Pointers in Fortran (Part 2) – arrays
  78. Pointers in Fortran (Part 1) – the basics

2014 32

  1. Recommended reads – the writings of Jon Bentley
  2. First programming language – industrial vs academic
  3. When the Pi kills your program.
  4. Cobol – the elephant in the room
  5. FORTRAN is dead! Long live Fortran.
  6. The stack versus the heap
  7. One language to rule them all.
  8. C obscenities – weird array notation
  9. Why global variables are considered harmful.
  10. Code Tricks: Swapping values without a third variable
  11. Weird memory problems in C – or – “how to smash the stack”.
  12. Quad precision in C – make it a double double!
  13. C and core dumps.
  14. Infinite recursion and the stack
  15. History of Computing 101: Preparing a program… 60 years ago
  16. Why C is NOT a memory safe language.
  17. It’s a trap! – Inputting sentences in C programs
  18. Code Tricks: Strings of words with scanf
  19. Code Tricks: The * I/O modifier
  20. Code Tricks: Printing fancy characters in C
  21. The best language for a novice to learn programming?
  22. Software complexity and bugs in the code.
  23. Dijkstra’s musings on programming languages
  24. Quote on programming
  25. Using the Raspberry Pi in introductory programming
  26. Optimization in real-world apps
  27. Computer Science presentations for schools
  28. Dijkstra on Ada
  29. The training of programmers
  30. Computer science and the age of the app
  31. Computer science skills
  32. The history of computing

2013 31

  1. 2D array subscripts in Python
  2. Image processing in Python – code efficiency
  3. Does haze suppression really work?
  4. In Python loops can be lethal
  5. Why IDEs lead you to the dark side.
  6. Why comments are important.
  7. Billy bookcase + books = sag
  8. Crashing an in-flight entertainment system
  9. Why image processing can be perplexing.
  10. Origami and algorithms
  11. What is spaghetti code?
  12. iPhone 5s fingerprint reader hacked!
  13. Software and redundancy
  14. Why some testing is impossible
  15. The art of crowdsource-testing
  16. Is programming a craft?
  17. Debunking TV technology: Reflections in drinking glasses
  18. Why facial recognition shouldn’t scare you.
  19. Finding faces in a crowd: Debunking a TV myth
  20. Why internet searching is more like rummaging
  21. Software bloat
  22. Using Moore’s Law to solve program inefficiencies
  23. Does the number of pixels matter?
  24. Why building a better iPhone is challenging
  25. Why COBOL doesn’t cripple the mind
  26. Computer science is about knowing how to program
  27. Hoare on constructing software
  28. Kernighan & Plauger on software
  29. Memories of C
  30. Variable name mnemonics
  31. Dijkstra on testing