Is a compiled language preferred for web development or an interpreted one?

A web development project lifecycle is generally short and web pages change constantly.
Therefore interpreted language for RAD (rapid application development) is generally suitable for web development.
Interpreted language is also useful for client side development (browser, mobile app, etc.) where access to the client device is limited, while compiled language is mostly helpful at the server side for powerful processing and scaling up the web application.

This is a good discussion on feature and comparison.
My two cents; In large e-commerce commercial web sites, middle-tier code security is a major concern.
It is the place where all of business logic resides.
Compiled code promise that It will not break and interface access can be secured as well.
Interpreter languages are good for fast development and delivery but are vulnerable to code breaks and security breaches.

It all depends on what you are developing over web.
Think of the very first thing: HTML (Hyper Text Markup Language) is Interpreted.
JavaScript is Interpreted.
PHP Interpreted.
And all scripting languages are almost interpreted why.
May be they are suitable for web services.
But certainly sometimes you may be doing something for which you need compilation.
Here are some useful information across the web you may yourselves figure it out what which one should be preferred and when.
(I don't think any one will read the whole article here.
Took longer to explain :) ) Deployment Where and how you want to deploy the application.
If you need to be able to deploy the solution on any of dozens of different possible platforms, you may find that you're better off with PHP than Java (for example).
There are hundreds of thousands of Java hosting providers out there, but there are probably millions of PHP hosting providers.
This goes to OS as well.
Mono aside, .Net stuff is going to limit you to Windows-based deployment (or lagging behind the cutting edge and having to very, very rigorously test each and every3rd party component you bring in, to ensure that it doesn't have Mono issues).
Skill Sets The skill sets of the engineers in your organization.
Coming up to speed in an environment or language is non-trivial.
For most of us, picking up the basics is pretty quick, but you may not be making the best architecture or design decisions because you're (comparatively) weak on the environment/language.
Integration and Development What third-party components you want to integrate with or incorporate.
In your target area of development, which server-side components or packages will you want to integrate with? PHP has a vast array of things available for it, as does Java, as does C# or ASP.Net.
But they're different things (by and large), so you'll want to look at what you actually want to use.
Also you can do anything that you can do in an interpreted language in a compiled language and vice-versa - they are both Turing complete.
Both however have advantages and disadvantages for implementation and use.
Advantages and Benefits of Compiled Languages: - Faster performance by directly using the native code of the target machine - Opportunity to apply quite powerful optimizations during the compile stage - No compilation means the time from editing code to testing the app can be terminated - Compiled native code does not have the overhead of an interpreter and is therefore usually more efficient on time and space - Ability to support architectures the interpreter hasn't been compiled for (such as embedded systems) Advantages and Benefits of Interpreted Languages: - Easier to implement (writing good compilers is hard relatively to interpreted one) - No need to generate binaries for multiple architectures because the interpreter will manage the architecture abstraction (though you may need to still worry about the scripts handling integer sizes correctly, just not the binary distribution) - Can be more convenient for dynamic languages - Note that modern techniques such as byte code compilation add some extra complexity, what happens here is that the compiler targets a "virtual machine" which is not the same as the underlying hardware.
These virtual machine instructions can then be compiled again at a later stage to get native code (e.g.
as done by the Java JVM JIT compiler).
- No need to generate binaries for multiple architectures because the interpreter will manage the architecture abstraction (though you may need to still worry about the scripts handling integer sizes correctly, just not the binary distribution) - Another good reason is that on a big server execution speed is not so much an issue as the connection speed anyway.
Most of the time is spent sending and receiving data, not number crunching.
And actually in certain web services which do a lot of computations, the hard crunching is probably run as a compiled program.
- Plus interpreted languages don't need compiling (which on a large project can take time), thus it's more suited for the typically agile development of web solutions.
- Interpreted languages are portable across operating systems.
- Of course the great benefit is the productive boost you gain by using a modern language.
- Performance is of course important.
However interpreted or VM languages are getting better and better in this respect (with technologies like JIT compilation) and are approaching the performance of native code.
- - Also it isn't fair to compare only the time spent during execution process.
You need to measure the whole sequence such as reception of request from the server, delegation to the proper application, execution, return of results to the server.
- It is mostly because it is quick and simple to change them on the fly.
Compiled languages require a development environment that must match the server.
With a script you can use an ftp tool and edit the text directly and then save it.
This ability to do this from any computer of any OS or type do save your.
What Matters for Developments is: If you have a good overall architecture, it is unusual for the language to make much of a difference in website performance.
Usually most of the time goes to fetching data from however you've stored said data.
So I think it's less a matter of compiled vs.
scripted (interpreted), and more a matter of what's the best fit by other criteria for what you're trying to do.
However when it does make a difference, compiled languages are usually faster.
However this difference is not necessarily inherent in the nature of compiled languages.
With JIT techniques, theoretically interpreted languages could be just as fast.

interpreted language is preferred for web development .

We can't determent which one of them is the better that the other because every thing have have advantages and disadvantages and it depends on the kind of the website you are trying to build so this is a relative question, but let me give you some hints about when you can go with compiled language or interpreted ones (from my point of view).
As we know compiled languages is much faster than interpreted ones since that the compiled languages are dealing directly to the machine native language but at the same time it's need time to generate the compiled version code from the original one, that can directly dealing with machine code (i.e build step), so that will be good for the performance issues but on the production side but it's not a suitable way and it's annoying and wasting the developer time since he/she need to do the build step after any change on the code regardless of it's small or huge change so if you have a huge website this step will takes minuets of some cases for this reason most online websites was built using interpreter languages.
So the conclusion of that will be1) if you have a huge website and this website will have a permanent development or maintenance I recommend you to choose the interpreter language.2) else if you have a website that was built with completed features and no need a permanent changes like CMS websites I recommend you to choose the compiled language it will be faster performance.
But we have a creative third choose that is a hybrid website (i.e it's build using compiled and interpreter languages).
That will be by build the whole website by using interpreter language and build some fixed commands that will not need any changes on the future by using the compiled language by that we can benefit performance from the compiled one and flexibility and fast maintainability from the interpreter one.
Hope this helped.

Hybrid approach JIT(Just In Time) is the best like Java language, if you want an Enterprise application the is with high performance and scalable JEE is your choice.

Compiled programs generally run faster than interpreted ones because interpreted programs must be reduced to machine instructions at runtime

المفسرات اصبحت فعليا غير موجودة حيث حلت المترجمات محلها تقريبا وذلك لأن المترجمات اسرع في أدائها وتعطي اداء افضل بالنسبة للشبكة وللحاسب في نفس الوقت

It's Depend on what you need , the answer depended on the platform , and what is your project to serve

A compiled language is a programming language whose implementations are typically compilers (translators which generate machine code from source code), and not interpreters (step-by-step executors of source code, where no pre-runtime translation takes place).

It can be the mix of both, as these days we need to have a scalable, robust web sites or web apps with a minimal turnaround time.
I would go for the mix of Microsoft or Java Technologies with the power of HTML5 and jQuery.