In language, grammar is a set of rules for constructing sentences. In computer science, a formal grammar works similarly: it's a set of rules for generating valid strings in a language. A regular grammar is the simplest type of formal grammar, defined by its very specific and restrictive rules.

A regular grammar has four key components:

1. Non-terminals ($N$): These are placeholder symbols that can be replaced. They are usually written as uppercase letters, like $S$ or $A$.
2. Terminals ($T$): These are the actual characters or symbols that make up the final strings of the language, like a, b, or 1.
3. Production Rules ($P$): These are the rules that dictate how to replace non-terminals to generate a string.
4. Start Symbol ($S$): A special non-terminal that begins the string generation process.

The real power and limitation of a regular grammar lie in its production rules. Every rule must follow a strict pattern. In a right-linear grammar, the rules can only take one of two forms:

There's also a special rule that allows a non-terminal to be replaced by an empty string, denoted by $\epsilon$. This is how the generation process stops. A left-linear grammar is similar, but the non-terminal appears on the left side of the terminal: $A \rightarrow Ba$ or $A \rightarrow a$.

The strict rules of regular grammars give them a few distinct properties. Because they generate strings one character at a time in a linear fashion, the languages they can describe are predictable and straightforward. These are called regular languages.

Regular languages include patterns like:

• Strings that start with a and end with b.
• Strings containing an even number of 0s.
• Strings of alternating xs and ys.

However, this simplicity is also their biggest limitation. Regular grammars have no way to "remember" information. They can't keep track of how many characters have been generated and then match that count later. This means they cannot describe languages that require balancing or nesting.

For example, a regular grammar cannot generate the language of all strings with $n$ a's followed by $n$ b's (like ab, aabb, aaabbb, etc.). To do this, the grammar would need to count the a's, but its simple rules don't allow for such memory.

This inability to handle nested structures makes them unsuitable for parsing most programming languages, which rely heavily on matching pairs of parentheses, brackets, or begin-end blocks. For those more complex tasks, more powerful grammars are needed.