When learning a programming language, I often find myself looking for the syntax of something I already understand conceptually.
I know what I want to do, but I don’t always remember the exact syntax.
Should I use a pointer here?
How do I declare this type?
What is the syntax for a generator?
How should I structure a VHDL process?
What is the syntax for a generate statement?
Searching through different courses, documentation pages, and old exercises can become unnecessarily time-consuming.
So I decided to build something simple:
one organized reference file per programming language.
The idea
Instead of creating dozens of small examples, I wanted a single file that acts as a syntax skeleton and quick reference for each language.
Each file is organized by topic and contains syntax patterns ranging from fundamental constructs to more advanced concepts.
The three languages currently covered are:
C
Python
VHDL
The goal is not to write one program from beginning to end.
The files are meant to be ** read, searched, understood, and adapted.**
How it works
The idea is simple:
Problem or assignment → identify what you need → find the corresponding construct → understand it → adapt the syntax to your situation.
For example, if an exercise requires dynamic memory in C, I can go directly to the relevant section instead of searching through an entire course.
If I need a Python decorator, generator, class, or asynchronous construct, I can find the corresponding pattern in the Python reference.
For VHDL, the same approach applies to processes, architectures, FSMs, counters, generate statements, and testbenches.
The references also include quick-reference sections that connect common problem keywords with relevant language constructs.
The reference therefore works more like a map of the language’s syntax and constructs than a traditional tutorial.
How I use the references
The files are designed around a simple workflow.
First, I identify what the problem is asking for.
Then I translate the problem into plain language before coding.
After identifying the relevant concept, I find the corresponding section in the reference, understand the pattern, and adapt it step by step.
The references are not intended to provide complete solutions to exercises.
They provide building blocks and syntax patterns that can be adapted to different situations.
For C and Python, this can be especially useful when the concept is already familiar but the exact syntax is not.
For VHDL, the reference also encourages identifying whether a circuit is combinational or sequential before choosing an appropriate pattern.
Why a single file?
I specifically wanted each language to have a single, structured file.
That makes it possible to:
search quickly using Ctrl + F;
see the overall organization of the language;
compare related constructs;
keep syntax patterns in one place;
use the file as a companion while studying or solving exercises.
The examples are intentionally generic.
They are not designed to solve one specific exercise.
They are also not meant to be executed or compiled as complete programs from top to bottom. They are reference files containing multiple independent examples and patterns.
Beginner to advanced
Each reference starts with fundamental constructs and gradually moves toward more advanced concepts.
For example, the C reference includes topics such as:
- variables and data types
- operators and control flow
- functions
- arrays and strings
- pointers
- dynamic memory allocation
- structures and unions
- storage classes
- preprocessing
- multi-file compilation
- variadic functions
- callbacks
- C11 features
- low-level error handling
- generic programming with void*
- classic data structures
- multithreading basics
The Python reference covers concepts including:
- basic data types and control flow
- functions and data structures
- comprehensions
- object-oriented programming
- iterators and generators
- context managers
- decorators
- functional programming
- typing
- asynchronous programming
- modules and packages
- advanced collections
- metaclasses
The VHDL reference includes:
- entities and architectures
- libraries and data types
- behavioral, dataflow, and structural descriptions
- processes
- signals and variables
- sequential logic
- functions and procedures
- arrays and custom types
- FSMs
- counters and shift registers
- generate statements
- testbenches
The purpose is not to claim that these files replace official documentation or complete language specifications.
They are structured learning references covering a broad range of constructs that I am learning and using.
AI-assisted development
The concept, structure, and requirements for the repository were designed by me.
I used AI tools to generate and refine the initial syntax skeletons according to specifications I provided, then organized the resulting references around my own learning workflow.
I see AI here as a tool for accelerating the creation of a learning resource, not as a replacement for understanding the underlying concepts.
The repository
The complete references are available on GitHub: https://github.com/AmintaDiop/programming-language-syntax-references .
The project is open source under the MIT License, so the files can be reused, modified, and extended.
What’s next?
I currently use these references for the languages I am learning.
As I learn additional languages, I may extend the collection using the same structure.
The main idea will remain the same:
Don’t memorize every syntax pattern. Understand the concept, find the right construct, and adapt it to the problem.
