You’re partially right.

Lambda calculus is base for understanding how functional programming WORK.

Turing machine is base for understanding how imperative programming WORK.

Formal languages are ways of WRITING programms.

Lambda calculus and Turing machine are totally different, but both in some way do the same as sentence “if you add two and three, you get five” for math.

Formal languages are ways of saying “2+2 means ‘add two and two'”.

PS. @SK-logic: yes, you are right. This above is simplification, realy close to being false. Still, answer was written for complete newbie in topic, it was intended to give him SLIGHTEST idea, so he can choose what is more interesting for him, and where he want to start learning.

I got lost in all that theory, what I understood from all that is that
(any ..?) programming language is built on lambda calculus,

Not in the sense that a PL designer needs to know and start out with the lambda calculus, but see below.

are there any models other than lambda calculus?

Yes, sure. For example, the SKI combinator calculus. Or register machines (basically, the van Neumann model).

The point is that any turing complete system could serve as basic for programming languages. Or, to put it differently, you could explain any language in terms of any computational complete system.

if the languages shares the same model, can we use that to convert a source code from one language to the other?

It makes it certainly easier.
Yet, from what I said above, it is rather the case that we can convert any language to any other language. (It’s just not practical in most cases to do so.)

is my understanding correct?

Not really. Functional programming is more a set of features originally inspired by lambda calculus than a foundation for an entire language design. Some purely functional languages might come close but I suspect they’d still have to have some rules that don’t relate directly to lambda calculus. And of course not all languages have the features required for functional programming.

are there any models other than lambda calculus?

If by that you mean feature sets inspired by other branches of mathematics, then absolutely, without a doubt. Basic features implemented in most languages are tied directly to all manner of specific branches of math. But not all features necessarily are. Object Oriented Programming, for instance, is a concept meant to help programmers structure and model code more intuitively while avoiding some of the pitfalls people tend to run into in procedural programming. If it has a direct branch of mathematics analogue, I’ve never seen that pointed out anywhere.

if the languages shares the same model, can we use that to convert a
source code from one language to the other?

Well, what does “same model” mean. They follow all the same rules, varying slightly only in syntax? That would be easy enough. But a single core rule-change could make translating one to the other very messy. Strict vs dynamic types for instance. How would you write a JavaScript object’s methods to follow all the same rules as a Java object? Other features like how scope works, or the absence/presence of closures would require a lot of overhead to emulate in universal way between language paradigms.

I think the closest thing to a common link you could find between all languages is that ultimately they all have to boil down to instructions that can somehow be broken down and executed in machine code terms on a given system (and machine code varies depending on architecture too). The complexity inherent in making a universal programming translator would be both insanely hard, if possible, but also massively fail to produce legible translated code between languages without massaging and special libraries that would make it fail the ‘universal’ test. I wouldn’t be shocked if someone had proven this feat to be technically impossible.

I’m trying to understand if a programming languages design is built on some a theoretical model.

No unifying theory has surfaced, but different aspects of programming languages are studied separately and may introduce their own theories. To name a few:

• Type systems
• Exception handling mechanisms and models
• Co-routines
• Concurrency stuff (models and mechanisms)
• Macros
• Binding/composition/extensions (ex: aspects, subject-oriented, context-oriented, prototypes, traits, multi methods, predicate dispatch, etc)

I came across few links that was describing Programming Language Theory, Lambda Calculus, Formal Languages and Turing machine.

These are more used and appropriated to investigate limits of computation, etc. Though lambda calculus (and other calculi) is used as medium to model programming mechanisms to be used in practice.

I got lost in all that theory, what I understood from all that is that (any ..?) programming language is built on lambda calculus, that boils down to few language constructs.

Depends on how you interpret “built on lambda calculus”. Many language are not designed from lambda calculus (or any other formal system), that is, a designer does not start with lambda calculus and end up with, say, Go. These two just share a theoretical correspondence, and when you want to investigate computational complexity, you go to these systems which are better suited for such study.