Alright, here's a quick syllabus for programming:

Intro

• Variables: Assignment, accessing values, swapping values between two variables.
• Data types: Overview of the general concept of different types of data.
• Numbers: Arithmetic operations, difference between int and float.
• Conditionals: If/else statements and logical operators (AND, OR, NOT, etc.).
• Repetition: For loops and while loops.
• Strings: Simple string manipulation, comparing strings.
• Arrays: Creating, assigning values, retrieving values, iteration.
• I/O: Accepting and processing input, producing output.
• Variable scope.
• Functions: Defining, passing values, returning values.
• Algorithms: Basic sorting, searching, counting, accumulation, other simple and common tasks.
• Common errors: Infinite loops, exceeding array boundaries, comparing strings (lexicographical order, string stored as an object, etc.), logical vs. bitwise operators (e.g. using & instead of &&).

Basics

• Recursion: Base and recursive cases, concept of the call stack, simple algorithms like recursive Fibonacci.
• File processing.
• Determining algorithmic complexity (big-O notation).
• Objects: Defining, instantiation, methods vs. functions, storing data, private vs. public properties/methods, comparing objects.
• Algorithms: More advanced topics e.g. recursive sorting and searching (e.g. binary search).
• Data structures: Binary tree, dictionary, linked list, queue, stack, etc.
• Databases: Basics about relational databases, joining tables, columns and rows, foreign keys, performing simple queries.
• Regular expressions: Understanding pattern matching.
• Binary: Basics of binary representation, bitwise operations, simple conversion of integers to binary and vice versa.

Intermediate

• Memory management: allocating and freeing, pointers vs. addresses, memory leaks.
• Basic architecture: understanding CPU operations and assembly, pipeline stalls, basics of optimization (e.g. loop unrolling), caching, registers, Moore's law, architectural hierarchy, relative speeds of storage mediums, etc.
• Data types: Lower level representations, e.g. strings as pointers to multiple characters.
• Binary: More advanced subjects e.g. bit shifting, IEEE representation, floating point representation, negative bit, etc.
• Recursion: More advanced recursive algorithms e.g. depth-first and breadth-first searches, traversing general tree and graph structures.
• Concurrency: Threads, synchronous vs. asynchronous, mutex locks, synchronous data structures, race conditions.
• Compilers: Stages of program compilation, static vs. dynamic linking, optimization levels, etc.
• Program state transitions.

Advanced

• Operating systems: Software layers, task scheduling and different strategies, paging, thrashing, segmentation, processes, inter-process communication, process forking, interrupts, signals, deadlock, producer vs. consumer, semaphores, critical regions, address mapping, user vs. kernel mode, context switching, IO-bound vs. CPU-bound processing, etc.
• Algorithms: More advanced subjects e.g. Dijkstra's algorithm, dynamic programming.
• Data structures: Much more advanced structures e.g. auto-balancing tree structures.
• Grammars: Differences between regular, context-free, and context-sensitive grammars (allows you to e.g. determine whether or not you can use a regular expression to find a pattern or if you need to utilize a stack structure and perform more complex parsing).
• Networking: Basics of IP addressing, DNS, packet switching networks, protocols, request methods, ports, NAT.
• Security: Basics of SSL/TLS, encryption, hashing, firewalls.

Most people are fine after the Intermediate section. That's enough to give you a pretty solid foundation and make you a fairly decent intro level programmer. The Advanced section, however, is highly recommended for anyone. Understanding how your operating system works in particular can help you unearth the root cause of a problem with some tool that's malfunctioning. Even the largely academic parts like auto-balancing tree data structures still help to provide valuable insights into different approaches and tools that are available for solving problems you may end up running into.

I've likely missed some pretty important topics here. I may have even miss-categorized some of them. I've kept subjects of purely academic value down to a minimum. I've tried to avoid domain-specific subjects as much as possible (e.g. nothing specific to web programming). More than anything, I highly doubt there will be universal agreement with this list overall. This is based largely on my own personal experiences as both an academic and as a professional and is thus subject to bias. Still, I feel that it gives a fairly powerful set of fundamental subjects that a programmer can make use of in a variety of situations and that the skills you develop learning these subjects are the most transferable between programming languages and problem spaces.

If anyone has any feedback on this list, I'll be sure to hear you out and make any changes where appropriate.