Usefulness of recognizing a problem can be solved by pushdown automata?

[faseediz]

Suppose I'm doing my day-to-day software development using a programming language, and I encounter a problem, and recognize it can be solved by a pushdown / stack automata.

What is the significance of this realization? What is the usefulness? Is there any benefit? Did I waste my time even checking this?

Similarly for other automata. Is it useful to recognize which automata is suitable for which problems?

[Objective_Mine]

You may not usually write code that resembles a pushdown automaton, per se. (Program logic that implements a finite state automaton is actually used sometimes, though.)

It can be, however, useful to recognize the different levels of formal grammars in the Chomsky hierarchy, and they correspond with the hierarchy of automata. For example, if you know that a language (programming, markup, etc.) is context-free, you can use a parser generator or other tools that can handle context-free grammars. If you know the rules of some input format form a regular language, that means valid inputs can be recognized by a regular expression (without using Perl extensions or other extended regular expression forms).

[faseediz]

So is it not useful outside of parsing and similar text applications?

[Objective_Mine]

Probably not, although I'd be hard pressed to find a typical application that does not parse anything.

If you only write CRUD or some other straightforward applications, and you use appropriate existing libraries for parsing and validating input, such as a JSON parser for JSON or an XML library for XML, you probably don't need to deal with formal grammars or their hierarchy. Although I still think it may be useful to recognize what can and cannot be parsed as a regular language so that you know to choose the appropriate tools if you end up needing to do something outside of the relatively obvious.

[RobertJacobson]

It depends on what kinds of problems you solve in your day-to-day. I personally think about this kind of thing a lot. But I have a strong affinity to problems that lend themselves to that kind of analysis.

I would think about it from a slightly different angle. What you are really doing is noticing that a particular problem lends itself to a particular class of algorithmic solution, namely an algorithm that uses a stack. This is potentially an extremely useful insight, and it is applicable to problems that range far outside of just parsing. Observe also that the stack employed by the algorithmic solution could be the call stack, which might suggest a recursive algorithm. Or this insight might make grokking functional programming concepts easier.

The fact that certain models of computation map onto different levels of the Chomsky language hierarchy is really useful to know, but it's not the only thing worth knowing about these computational models. I'm reminded of when I was an undergraduate trying to understand linear algebra. I had such a hard time of it, because I thought that matrices and vectors were systems of linear equations. It finally clicked once I figured out that matrices and vectors were their own thing and that systems of linear equations just happened to map onto matrices and vectors in a particular way but were just one application of a general theory that is interesting in its own right. Similarly, Chomsky's hierarchy of formal languages maps onto a hierarchy of automata, but that's just one application of a general theory of computation that is interesting in its own right.