Win a copy of Serverless Applications with Node.js this week in the NodeJS forum!
  • Post Reply Bookmark Topic Watch Topic
  • New Topic
programming forums Java Mobile Certification Databases Caching Books Engineering Micro Controllers OS Languages Paradigms IDEs Build Tools Frameworks Application Servers Open Source This Site Careers Other all forums
this forum made possible by our volunteer staff, including ...
Marshals:
  • Campbell Ritchie
  • Liutauras Vilda
  • Bear Bibeault
  • Jeanne Boyarsky
  • paul wheaton
Sheriffs:
  • Junilu Lacar
  • Paul Clapham
  • Knute Snortum
Saloon Keepers:
  • Stephan van Hulst
  • Ron McLeod
  • Tim Moores
  • salvin francis
  • Carey Brown
Bartenders:
  • Tim Holloway
  • Frits Walraven
  • Vijitha Kumara

Compiled over Interpreted  RSS feed

 
Marshal
Posts: 6634
443
BSD Linux Mac OS X VI Editor
  • Mark post as helpful
  • send pies
  • Quote
  • Report post to moderator
One of the advantages of compiled languages over the interpreted, that you actually build systems quicker.
 
Saloon Keeper
Posts: 5341
143
  • Mark post as helpful
  • send pies
  • Quote
  • Report post to moderator
Hmm... the boundaries between compiled and interpreted are rather fuzzy in many languages, and in some interchangeable. What effects are you referring to, specifically?
 
Bartender
Posts: 20576
121
Android Eclipse IDE Linux
  • Mark post as helpful
  • send pies
  • Quote
  • Report post to moderator
I determined many years ago, that - possibly excepting assembly language - the amount of time spent on an enterprise project is going to be about the same no matter what language platform you based it on (so much for "Silver Bullets"). What actually happens is that the various (design, coding, testing, production support) phases stretch and compress, with the sum being pretty much constant.

Scripted development systems like JavaScript, Ruby, Python, et. al., make you look more productive, because you can get visibly displayable results faster - thus making Management happy. But that just shifts a lot of the dirty work to later stages in the development process. Stuff that compilers can catch and report don't get caught until you actually start running code. Worse, in interpreted systems, you're far more likely to have rake-in-the-grass bugs that only get detected under uncommon use cases such as panicky year-end on Leap Years.

Since i prefer my embarrassments to be private, not visible world-wide, I'd rather use compiled code for most serious projects. But, like I said, Management likes to see "progress", so I'm often berated for that.
 
Liutauras Vilda
Marshal
Posts: 6634
443
BSD Linux Mac OS X VI Editor
  • Mark post as helpful
  • send pies
  • Quote
  • Report post to moderator

Tim Moores wrote:Hmm... the boundaries between compiled and interpreted are rather fuzzy in many languages, and in some interchangeable. What effects are you referring to, specifically?


Sorry it took so long to reply.

In particular and mostly, I don't like the lack of type checking, what is seen in dynamically typed languages, which in most cases are interpreted at the same time. That cycle of running code and seeing whether you got details in agreement (i.e. data types right) is painful, unless possibly you know the language and all its libraries fairly well.

All sort of things seem to be fine, until you actually run the code. Well, after few days hands-on exercises you kind of start getting used to, but that is still unintuitive for me. I find code more difficult to read as need to infer in the head some of the details, which aren't obvious right away.

Perhaps the language which is a combination of dynamically+weakly typed is easier to use than dynamically+strongly typed, because in the case of latter you don't get support from compiler on the type checking, while the language at run-time is pretty pedantic.

I'm quite surprised people say intepreted languages are easier to learn and to start with. I think they add more confusion why things don't work when you'd expect them to work.

It isn't the case that I don't like interpreted languages, I'm aware that there are right tools for the right things, but to work with interpreted languages (when I have to) I don't find myself being a more productive, but that maybe because I have less experience using them.
 
Ranch Hand
Posts: 1325
3
Java Netbeans IDE Spring
  • Mark post as helpful
  • send pies
  • Quote
  • Report post to moderator
With an interpreted language you can do things that cannot be done in a compiled language. For example, interpreted programs can modify themselves by adding or changing functions at runtime. On the other hand, I also prefer
compiled languages, at university they used to give us Python at the very beginning, my impression was that it was in fact much easier because of there was no need of declaring context variables for example, but actually it gets more confusing when the program gets more complex.
 
Tim Holloway
Bartender
Posts: 20576
121
Android Eclipse IDE Linux
  • Mark post as helpful
  • send pies
  • Quote
  • Report post to moderator

Liutauras Vilda wrote:That cycle of running code and seeing whether you got details in agreement (i.e. data types right) is painful, unless possibly you know the language and all its libraries fairly well.



Actually, I'd argue that a large part of the danger of weakly-typed (hence usually interpreted) languages is as much in remembering what your own modules are up to, since there's no automated cross-checking.

Liutauras Vilda wrote:I'm quite surprised people say intepreted languages are easier to learn and to start with. I think they add more confusion why things don't work when you'd expect them to work.



I think the primary reason for that is that interpreted languages generally have a "type-and-try" mode where you can type in an expression and see it immediately displayed - or rejected, if there are syntax errors. Compiled languages require compiling and often linking and frequently attaching other resources to get even a simple "Hello, World!"

As for things not working as expected, though I think the prize-winner was an example I saw long ago in PL/1 (a compiled language!) where by using different values of "1" and the "+" operator, you could get really wild results as the compiler automatically (and silently) converted operators from character to binary, binary to character and maybe even a little floating-point!
 
If you open the box, you will find Heisenberg strangling Shrodenger's cat. And waving this tiny ad:
global solutions you can do at home or in your backyard
https://www.kickstarter.com/projects/paulwheaton/better-world-boo
  • Post Reply Bookmark Topic Watch Topic
  • New Topic
Boost this thread!