Slashdot Mirror
What Makes a Powerful Programming Language?
A not-so Anonymous Coward queries: "My company is about to start development on a new project, and I have to decide on a language and development environment. My boss gave me a set of criteria which needs to be filled: intuitive and easy to use IDE; simplified GUI design and event handling; advanced error handling; advanced object oriented design including multiple inheritance, abstract classes, and garbage collection; full support for operator and function overloading; and portable (at compile-time) across various platforms. I have already looked at C++, Java, C++, C#, Eiffel, and even VB.net; I may be missing something but as far as I can tell all of these languages are missing something from this list. Is there a language available that has all of these features? I thought that someone from Slashdot would be able to point me in the right direction?" If you were to design a language from the ground up, what features would you include and why?
Why doesn't java fit the bill? *blinks*
I SURVIVED THE GREAT SLASHDOT BLACKOUT OF 2002!
I'll take VB over C++ anyday
If I were to design a language from the ground up, I wouldn't do it.
The whole idea is to use something standard so that it's simple to bring new people up to speed and apply techniques that other developers have discovered.
It would be akin to building a bridge using a completely new, untested building material. Not my idea of a good engineering decision.
Dirk
It's good that you checked C++ twice :-)
Eddy.WriteLinux.Com
Why did he look at C++ twice, I'm not sure it deserves a first look, let alone two.
I demand a million helicopters and a DOLLAR!
Micro$oft. Put a bunch of cash behind something, and everyone's bound (forced?) to pick it up, powerful or not.
"Joan of Arc, up top!" - Ghandi, Clone High
You know, Pure Fcking Magic
I Heart Sorting Networks
What is java missing from the criteria?
I'm a writer, a poet, a genius, I know it. I don't buy software, I grow it.
All those features used together is going
to make a big mess, IMHO. I think your
boss needs some education in computer science.
I'd recommend you look at Java and Python.
Operator overloading is not a good idea I think.
it's all question of compromise... ;)
you will pretty much _have_ to ignore ore try to acheive some other way one of the features you wanted...
just try to find the one that gets ur project done fastest
FP
More importantly, what is the project, and why is your boss specifying language features rather than project design goals?
Do all features need to be included in the language, or is an addon a possibility? C++ has all but one. Garbage collection, but that can be found in a 3rd-party library. Java lacks only operator overloading, which isn't really necessary. It is purely syntactic sugar. I cannot speak for the other languages, as I have little experience in those areas. You perhaps should have your boss prioritize the requirements, and pick the one that most meets the goals.
Hype! hype makes a language powerful! The IT departments are run on hype. It's a hell of a lot easier for business types to understand 'buzz' than actual code. Right? Of course right!
___
It's the end of my comment as I know it and I feel fine.
Out of what is available, fast, and readily supported. C++ is probably your best bet right now.
O.
How does Java NOT meet those criteria?
Well, I'd try to get your boss into a discussion with the (unstated) goal of trying to learn what language the boss has already decided is the correct answer.
When people have a long shopping list of specific details, it almost always means that they have decided and have set up the requirements so that only the one answer is correct.
This is, of course, a conventional way of doing "open" hiring or purchasing. You just write up the specs so that only one person or product can fit. It works just as well with software.
Those who do study history are doomed to stand helplessly by while everyone else repeats it.
We'll I don't know one that fits ALL those criteria. I think you should narrow some of your criteria. For instance, C++ has many easy to use IDE's, does NOT have simplified GUI, it does have multiple inheritance, abstract classes, and some garbage collection. It also supports function and operator overloading. However, its not certainly not the most portable, especially if you do GUI. In fact, good luck if you do GUI.
Personally I'm a java developer so I'd recommend java. It doesn't have multiple inheritance or basic operator overloading, but you could argue that you don't need those. It does have a lot of very easy to use IDE's (many of the best are free), it does have very easy and integrated GUI support, and it defines portability. Garbage collection and abstract classes and interfaces are there too. I'd recommend this for anyone doing a program that has a GUI and needs to be used on multiple operating systems.
As for VB.Net and C#, well, supposedly they will be portable (sure microsoft we believe you) but the fact remains that they aren't even finished products yet. Your choice.
Hope this helps,
HexGhost
...but there's people out there who design languages for fun, you know. Take a look at the languages on the esoteric programming languages ring or maybe even subscribe to the mailing list, but only if it all interests you.
I don't like trolls and mod against me if you like, but I'd prefer if you'd reply.
... is Smalltalk. In its standard form it's missing multiple inheritance, but is powerful enough to tackle just about any OOP task, even without MI. What the IDE is like depends on the environment you get; but I hear great things about VisualAge.
N4st0r, trixx0r h0bb1tz0rz! Th3y st0l3 0ur pr3c10uzz!
http://srd.yahoo.com/business/publications/softwar e/compilers/languages/whitepaper/itf/2001/november /crossreference/compilers/engineering/top.pdf
Your query is so vast that it demontrates a complete lack of planning or thought. Post more details, or hire someone else to figure them out beforehand.
This is what pisses me off. If you would put some thought into the product and the design abstraction, this would be an easy question. Instead, people charge off with grandiose ideas and big buzzwords (event handling, GUI, object oriented).
People wonder why there is so much crap software out there. This is one reason: sitting around discussing the language without discussing the problem.
I know I'm being kinda mean, but it's how I feel when I read such a newbie question from someone claiming to be attempting such an important task. I hope this post lasts long enough for discussion before being modded down to -1.
https://www.accountkiller.com/removal-requested
Objectice C on OS X and Project builder would work.
GNUstep and Objective-C
Don't know of a GUI as nice as, say, VS.net, but here are few in the works that look quite promising. Other than that, Ruby fits your needs quite well.
Java is the blue pill
Choose the red pill
I would go with Java. It is really object-oriented and clear structured, there are many implementations out there (Sun's Official, gcj, IBMs), it is cross-platform and if you tweal it a little it can be fast.
Boycot? Blackout? Subscriptions?
I don't care!
What makes a good language is a language that's open to all OSes. Since it can be used on any system, its potential is really really high. Now, if you make it easy to program in, customizable, and able to have direct access to hardware if needed, or go through an interpreter...it starts to become a good programming language. Of course, no programming language would be good unless it was tested and recognized, meaniing, a compiler and basic help would have to be released free at first, like it should be anyway. All those ingredients combined, and you have the perfect mix for a good language.
Job? I don't have time to get a job! Who will sit around and bitch about being broke and unemployed then?
Less than 20 comments and already I see three(over +1) that say, "Java does all that!".
You may feel that java is the answer for the poster, but it doesn't meet the criteria. Even ignoring the vague, flame-provoking concepts of "intuitive and easy to use IDE" and "simplified GUI design and event handling"... Java doesn't do multiple inheritance or operator overloading.
Perhaps you think that no project needs these... great, at least tell us why in your response, rather that spouting, "Java... Java... Java"
/* CDM */
1. Its what "everyone else" is perceived to be using,
2. Programming cannot be suitably be turned into a MacJob until the variance in the toolset is reduced.
Microsoft's .Net and Java are going to occupy 70% of the brainspace for programming in the next ten years, and these languages conform to my description above.
Sure, Lisp is cool - its also dead in the market, so stop trying to resurrect it based on its coolness. No one cares.
He abviously didn't look deep at the Java/J2EE development environment. You can a free IDE ( Eclipse or NetBeans) and a strong OO Design tools (like TogetherSoft).
W.
Unless you have pretty strong performance requirements, Java is your language.
I think it fills all the requrements, except for the somewhat misplaced "full support for operator and function overloading".
Why operator overloading would be a mission critical feature for a language beats me. It was excluded from Java for a reason! I assume the reason is how hopelessly confusing it can be to read code where + or && doesn't do what you'd expect them to do. It should be clear when a function is called and when it's not.
Smalltalk should do everything asked for.
Seems like an asinine list though. You're looking at the language from a functional level (what it does) rather than from your requirements level (what you need).
Why is this person even in charge of a project when he doesn't know what he is doing?
Seriously, it is very difficult to meet all of those criteria. For example, I would instantly recommend Python, except that it fails the criterium of IDE (there are a number of IDEs, but nothing I would bother using). It also technically fails "abstract classes", but that's pretty much a non-issue in Python.
Since you are obviously willing to put the time in to learn a new language, you may as well go for one which is easy to learn, easy to write, easy to read (incredibly maintainable) and which has one of the best online communities of any language (comp.lang.python).
It really sounds like your manager has a specific language in mind, and is trying to get you to read his/her mind.
...on what you are writing. I use Java for a lot of work, but I wouldn't use it for anything that needed a *lot* of speed, or low level hardware access. However, Java does have a rich API and good portability.
The best solution is ultimately probably using two languages - perhaps Java for interface work / portability, but also C for anything that needs to interface to hardware, or needs the performance. I'm only using Java and C as examples - but other languages are the same.
Most languages can't do everything. Pick the best for the task required and the skills available.
I think that there are 5 main elements that make a programming language powerful.
Simple sequence
Do While
Do Until
If Then Else
Case
Of course I'm from the school of thought where anything can be solved by using the logic. But what do I know? I'm not even 25 yet.
Starkle, starkle, little twink.
Objective C and the Cocoa framework provided with Mac OSX is quite possibly the most powerful API I have ever encountered. You can also use Java with Cocoa is you don't want to learn some weird syntax, but I'd reccomend sticking with Objective C since it provides some small and useful benefits over Java.
Also, all the development tools come free with the operating system(OS X). Project Builder and Interface builder are first rate development tools. WebObjects(not free. 700 bucks) also provides a great medium towards database driven web based applications.
Obviously this depends on whether or not you want to limit yourself to OS X. Who knows, maybe they'll port OS X to x86 =).
-Jacques
jc@cs.washington.edu
This sounds like a job for Python, or maybe Java.
I have found that Python is very easy to use as a GUI builder, and it seems to have most of the features you are looking for! It is also really easy to learn.
Although it may add a level of complexity to your work, you can always try to code different parts in Python, Java, C/C++, and even Perl, and find ways to mesh the various modules into a coherent app!I found the Perl/Python:GUI on top of a C/C++ backend model to be very useful when I was doing Genomics and DNA coding
C++ happens to be a great cross platform choice, in its self it was designed without any system specifics. you can easily port from one os to the next through changing basic references and the iostream.h, etc. Before badmouthing C i suggest youi actually do some learning about it first.
My sausage tree didn't grow, does that make me a bad mommy?
"If you were to design a language from the ground up, what features would you include and why?"
Since we're in a complete fantasy realm here where all of use have the brainpower, patience, trust fund, and buckets of countless free hours required to even BEGIN such a task...
...can I have a pony?
------
Today's Top Deals
I don't get it; what's wrong with good ol' C++, according to that list?
I can only see two possible deficiencies according to your requirements. The first is the lack of a truly portable GUI library (though you can get libraries like Qt that are reasonably cross-platform in some cases). The second is the garbage collection, but (a) you can use a garbage collector for C++ (if you must...) and (b) using the right basic tools and techniques, garbage collection is largely unnecessary in a C++ program anyway.
The biggest problem with C++ is getting people who program it, as opposed to C-with-bolted-on-classes-here-and-there. But if you've got a half-decent team and someone with smarts in charge, all of your concerns should be non-issues.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
In the post, the user specifies multiple inheritance is a requiment the language must have.
In my opinion, multiple inheritance is something to avoid. It adds confusion when attempting to determine which method to execute and (If you're using an interpreted language) can make the method lookup take longer.
I believe Java is a use-able OO language for most projects. There are several derivatives of Smalltalk that are also very functional to develop in.
It would be nice to have information on why each language evaluated didn't fit the bill. That would help us help the person with the question.
Operator overloading is just fine. As long as you follow the logic of the other uses of the operator. Sometimes you don't even have to do that.
Look at the '+' operator for strings in the C++ standard library. That is definitely an overloaded operator, and it does something way different. I think that this operator is definitely a good thing (sure beats the pants off of strcat).
I think operator overloading is a good idea. Just use the power wisely.
Java isn't truly entirely portable. At least two years ago, the gui libraries were different enough to cause problems running on different systems.
We still use a java applet that works fine on one browser buy horribly on another, and both are for the same damn operating system. And it's a commercial applet, too.
You should first analyze the requirements of your project before deciding which language is most suitable for the job. Just going by 'as many features as possible' will get you in trouble.
That being said, I think Python fulfills almost all the requirements your boss had. (I am not a Python programmer myself, but I'm interested in language design, so I have read some articles about Python...) On the other hand, if you really have a very complicated problem domain (like AI), Common LISP might be what you're looking for. If you want rapid prototyping above all, maybe Smalltalk is your best bet - If you want performance, write in C or C++, if you want portability you can do a lot worse than picking Java -- You get the picture...
The interactive way to Go -- http://www.playgo.to/iwtg/en/
Making a list of neat features won't do you any good. It's this approach to problem that causes bloatware. If a product is guaranteed to solve all your problems, you can be assured, it will solve none. It's all marketing!
Too big to fail? Does that make me to small to succeed?
For commercial or "enterprise" applications, a widely adopted language can often prove to be the most powerful. The more popular the language, the easier it will be to find mature or talented resources to keep the product going. Going with a relatively obscure language, even if it is somewhat better suited to the task, might only serve to hinder the evolution of the product.
I have used lot's of programming languages and Delphi just is the easiest to use.
:)
It's a nightmare when occasionally doing some ciding in C(++).
Oh, 1 hint, don't use API's. Kylix kicks a$$ to !
Or brainf*ck
Many of the things you have described are not features of the language you're using but of the programmers you're employing. Keeping a good handle on how the programmers are organizing their code is more important than any features a language can provide.
Have you determined that you need all that stuff to complete your project? It sure sounds like what I deal with everyday ... someone walks in with a checklist of stuff, of which they only use 10% of the criteria. Most of the time, they would be far better off using something that does their high priority criteria exteremly well, instead of choosing something that does everything not so well.
I have already looked at C++, Java, C++, C#, Eiffel, and even VB.net;
You said C++ twice.
We like C++.
"Oh, and by the way, make sure it is high-performance, self-maintaining, self-documenting, and can be self-taught in 21 days."
Your boss sounds like a "buzzword-compliant" type. Ask him why each feature is necessary so that you can decide what you really need and what that actually exists is closest. Note that even if you find some research language like Haskell (no disrespect) that meets all these features it will not do well on real-world criteria like "good supply of programmers who can use it".
If you are presented with a feature list and explanations for why each feature is necessary are not forthcoming, you may be working for a dangerous idiot. Consider transferring or finding other employment.
You can write code to handle all the things that it doesn't do. ;)
This is why C/C++ is so powerfully. You want to do something thats not part of the "default" syntax, write a class, or function(as per your needs) that does it.
VB is not cross platform.
C# is propritary.
Java is also propritary.
There are IDEs for C++ on all major platforms.
There are quite a few developer that know c++. heck, some of them even understand it!
The Kruger Dunning explains most post on
...I can honestly say you won't find any mainstream language that meets all of your criteria. Java is your best bet. The only things on that laundry list that it doesn't have are operator overloading and multiple inheritance. To be honest, since I switched to Java I haven't really missed either of those anyway. Install the JDK, Eclipse, and CVS, and you'll be one happy camper. Everything you'll ever need will be *free*, and most of it OSS at the same time. You can't beat that.
You can do cross platform GUI building using the QT library. It supports all major platforms.
--xPhase
The following sentence is TRUE. The previous sentence is FALSE.
just read this
(It's not like I want to spend an hour pimping a language when there's a site devoted to it.)
No Zen is good zen
It's strange that your boss has so many requirements for the language but yet he didn't want chose the language himself.
You have the difficult choice to buy a car in any color, provided the color is black.
You say it must be object oriented with an easy to use IDE (and so on).
What specifically do you want to do? Why does it have to be a GUI? Why OOPS? Maybe Python would be a good choice if you really need to get the app out fast, maybe you have other requirements that demand C++. Possibly a two language combo would be best.
You have to consider the other developers also, are they able to code OOPS style or have they only done curses with C? You must consider their skills and learning curve.
'nuff said.
Here's a thought - what langauge would your current programmers feel confident producing the final product in? Barring that, what do they want to work with? Happy programmers working in a familiar environment yield way more productivty than any langauge change will ever give you - even if that means F77 or SNOBOL (Ok, perhaps that's a little extreme).
As for myself, I would choose Java as you can get the best features of MI through Interface MI, and I've always found operator oerloading to be overrated (though handy in some spots). But again, you should what best suits the situation and the people there.
And here's a personal plea from users all over the earth - whatever you pick, please design the GUI to handle resizing correctly!
"There is more worth loving than we have strength to love." - Brian Jay Stanley
1. It's a OO programming langugage that's been around for a while and its mature.
:-P
2. The GUI is sweet.
3. It's cross platfrom (Kylix for linux)
Go right ahead and flame me, I don't care
Yes Francis, the world has gone crazy.
I think the best answer depends on your boss' knowledge of CS. If he truly knows much about programming, you know he's fucking with you, (because he's asking for the world). If he's an idiot who only read about the buzz words, then you tell him to use C#, (because by the time he figures what if C# fits his requirements, you'd already have retired).
Python has all you need, If I were to design a language from the ground up it would act and look alot like Python, that said, there is already something there and no need to push the edge of insanity writing my own language again, I did when I was younger, in the early 80's. No enough caffiene on the planet to try it again.
:)
Python will, if designed properly handle any load you could want to throw at it, it is portable as it gets, its easy to debug.
I cannot imagine what you are writing, or your boss thinks youre going to write that needs all that in one place at the same time. My bet is this is a buzzword hyped dude that has no Idea of the actual functional requirments. He wants an IDE and RAD, Im assuming so any 12$ an hour lackey can help support it at a later date as well as speed initial development. If portablity is the least of your concerns(in short term) VB.net would be the choice. In about 2 years VB.net programmers will be like VB programmers are now....a dime a dozen. That has more value than you can imagine on a large scale project whose lifecycle is indeterminite.
Screw em all and write it in assy, dont let em see any progress and then unleash it upon them complete, debugging is easy, if its wrong it dosent run. Its portable, from same architecture to same architecture(snicker), it actually will scale(buzzword insert)BUT THE SINGULAR MOST IMPORTANT PART is Youll have a job for life, at whatever you want em to pay you to maintain it
Sig went tro...aahemmm.....fishing........
Just stick to a language that already works and has a following. C++ is a great bet because lots of people use it and there are plenty of tools out to support it.
I gave up on the perfect language. Doing so is doomed to failure. Make it powerful, and you miss out on simplicity. Make it simple and you can't use it for much. Try to make a good balance for power users that fits your spec, and you'll end up with something that looks like a mix between C#, C++, Java, and Eiffel, slightly better designed, with different syntax and no actual support from anybody but the language creator.
Plus, there are some who believe that no language is complete without functional programming and/or aspects. Some big and cool projects have been done using modern functional languages.
Your best bet is C++ with a cross-platform GUI library like wxWindows or qt. If you want, you can try using one of the garbage collectors for C++ that's available and then you'll have most everything. Or you could just use bounds checker and manage your memory by hand.
Gentoo Sucks
An IDE is not a feature of a language.
Define "advanced". Having done lots of C, and C++ pre-exception-handling, I think try-throw-catch is pretty neat...
I think most people have given up on operator overloading - and for good reason. Once you've seen it abused, you'll never want to go near it again.
Tom Swiss | the infamous tms | my blog
You cannot wash away blood with blood
Thank the good lord above for the creation of perl!
RWD 2002, Fear the Retards for we are Legion
xfbs fuif hfscj mt p guifo jhi u
Also, keep in mind that the language is just one part of the equation. What about the underlying technologies? Application servers? Database APIs? In my experience those things factor in as much as anything else, along with the company or client's ability to support a system long-term that was developed using a given language. Many Wintel shops will not go for VC++ simply because it's a lot harder to find a decent C++ coder than VB or Delphi or whatever developers.
The way I've gotten through it is to find out what the project really is, and figure out what tool is best for the job, and figure out why the features not in that tool aren't needed for the project. Then my boss can get through the meeting where they have to present the technical solution.
For instance, if you're looking at languages and find that you like what C++ has to offer but you need garbage collection it can sometimes be reasonable to write a memory manager which takes care of that for you. If programming resources are an issue, or if writing a memory manager is just too daunting (no shame there, that's a tough problem) there are third party memory managers available in the world.
This is true for at least some of the other features you listed as well. The language doesn't have to do everything natively, you just have to be able to get it done somehow.
Also, some things that might be missing are really there, just with different names. For instance, multiple inheritence may not exist in java, but it does have interfaces, which sure a very, very similar purpose. Just because it's not multiple inheritance doesn't me it won't meet your needs.
Ultimately it sounds to me like you boss has heard too many buzzwords recently. It might be helpful to ask him why he chose to put each of those requirements on the list. Knowing what needs to be accomplished rather than how he thinks it should be accomplished might just help you find a solution which will actually meet all the needs of the project.
Behold the Power of Cheese!
"Must have multiple inheritance!" That reeks of someone spouting buzzwords. Complex inheritance hierarchies are probably one of the biggest factors working against OOP. Polymorphism is great, but when it takes 20 min to figure out which base class resolved the function call, something is wrong with the design. My favorite cross-platform UI dev environment is QT using KDevelop. No garbage collection, but you can't have everything. BTW, Java does not support multiple inheritance, but its support for interfaces usually does the trick.
You try doing proper generics without it. :-)
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
This has to be the dumbest, most trollerific Ask Slashdot ever. What's next? 'Which operating system is best?' 'What's the best text editor?' 'Is Bill Gates Cooler, As Cool or Less Cool than Linus?' .... They must be having a really slow news day there over at OSDN.
- undoware.ca
"If you were to design a language from the ground up, what features would you include and why?"
I figure I'd address this question...
Since I'm not really working in the industry as of yet, quite honestly, the one major feature I'd omit in my building a programming language (see... thing is I'd be doing this for myself so I could write programs and scripts for me and not really much else) is an overly elaborate stable GUI system, just on the basis that personally, I really prefer working at the command prompt level.
Thing is this wouldn't really serve the general world at large too much... But so be it... Like I said, I wouldn't be really writing it for other people...
I guess I got indoctrinated from learning to program via LPC and my graphing calculator... Heheh...
Karma: Non-Heinous
I would choose Java. Specifically for Garbage collection and Multiple platform support. The multiple inheritance issue can be easily wrapped and simplified. I would first do a UML outline diagram of what EXACTLY you want, and find the language from there. I think you will find Java to suit your needs the best though.
Here are some Ada links:
It is very doubtful that your entire program will need all the features named in this list. A better solution might be to develop your program as a set of components, which can be written in whichever language is suited for the purpose. However, this could present problems with the portability (until .NET for *nix is released ;).
Ask your boss what the project is going to do, and what it really needs out of a development environment, instead of just giving you a long list of buzzwords.
The list of requirements he's given you reads like a job description that's been through the HR department. The first thing you do when responding to a job ad stating "Position requires at least 5 years C/C++, Java, Perl, and SQL experience on multiple platforms," is ask "What do you really want?" The same applies here.
- Doesn't allow you to make dumb mistakes (i.e. doesn't let you assign an invalid pointer)
- Allows you to catch errors as close as possible to the exact line number where the mistake was made
- Allows you to write self-documenting code the reads close to English (this does not mean "natural language" just well-structured and logical)
- Doesn't force you to reinvent the wheel.
- Doesn't tie you to a specific platform (Note that Java ties you to the JRE, whereas C can be recompiled into any machine language, yet Java is more portable. Think about that.)
- Either is garbage collected or has really good memory-leak detection tools.
A good (again, general purpose) programming language lets you "think" about the task you are trying to accomplish and does not force you to think about implementation details.
Not that implementation details aren't very interesting, but you don't get paid for doing implementation details, you get paid for the final, reliable, on-time product, regardless of how you developed it.
Of course they're all missing something! No One Language can be all things to all people. In particular, "intuitive and easy-to-use IDE" and "simplified GUI" is a hard mix. (I'm not going to call Visual Studio intuitive.)
You probably ought to try to weasel more requirements out of your boss.
That said, the closest match to your problem is almost certain Python. The only "bullet point" missing is "abstract classes", but in Python, the term "abstract class" is nearly meaningless; they aren't necessary. But if it makes you feel better to create them, do so. Some people do for stylistic reasons.
Functions are overloadable, you just have to do it by checking types. For paying that price, you also get some cute stuff with *args and **kwargs (look at the docs for those things until you understand them), which can be lifesavers when you want them.
As for the "simplified GUI coding", you get *many* choices: Tk ships by default, and while ugly, is fast and effective for many uses. wxWindows is well-supported (in all senses of the word), looks native on all supported platforms, and is extremely flexible. (I'd rather program in wxWindows then MFC, even if I were doing a Windows only program! And it's a rare MFC program that couldn't be done in wxWindows.) Various IDEs are available for these things; you often don't need them. And there are many other choices as well.
If Python lacks the Hype Veneer and you think your boss cares about that, then you've probably got to go Java, along with the purchase of an IDE. You don't get simplified GUI programming, but I don't know of *any* hyped language that has simplified GUI coding.
If you're looking for good, portable, cross platform GUI development it's hard to go wrong with SpecTCL. It is a Tcl/Tk visual development environment which can generate code in Tcl, Perl, Python, Ruby, and Java. There are versions of SpecTCL available on Windows, Mac, UNIX and any other platform on which you can get a working Tcl/Tk environment. There is a related project SpecTix which appears to provide a more complete IDE, but I've not used it. I'm also really (really!) impressed with Apple's new IDE, Project Builder. If you've not seen a demo, you need to ask someone with a Mac running OS X to pop in the developer CD and try it for yourself. It allows you to do rapid application development to the Cocoa APIs in C, C++, Objective C and Java. What's cool about writing to the Cocoa APIs is that they're not only available on OS X, they're available on most UNIXes via the GNUstep implementation. I'd really love to get some time to find out just how portable Project Builder's resulting code is to other OpenStep implementations.
Brandon D. Valentine
Some of those requirements seem a bit out of place. If you're at a stage where you're looking for a language to write a project in, why is operator overloading in the list of "must haves"? I can almost understand that multiple inheritance might be listed as necessary in such a case, perhaps if the entirety of the project exists as UML and whomever put that design together did something weird and required multiple inheitance. But still...
You have language requirements which for a large part can be considered arbitrary. They're looking at the way the language is used as opposed to what it's used FOR. And while I know this is going to make me sound redundant, shouldn't your choice in language be on the requirements of how it runs, where it runs, or what it can run-- as opposed to how you would accomplish a given task in it?
Why not toss in a requirement that the language must use BEGIN and END blocks instead of curly braces. Or require that it uses # for the comment character.
Smalltalk seems to fit your criteria, and IBM has an IDE that can run on Linux (there may be others.) The real zinger in your requirements was that "multiple inheritance" thing.
If you want the power of Lisp (it also satisfies your language requirements) with an IDE, checkout Franz's Allegro Composer
Regardless of whether operator overloading is a good thing, it's still purely a syntactic device. Having operator overloading does not make the language any more powerful. There's nothing you can do with overloaded operators that can't be replicated with similar amount of effort by other language features. It does make code look nicer if used properly though.
Does everything in the list except multiple inheritance - and prompts the question of why that is needed? And the broader question, that others have asked, why spec the language rather than the requirements? Note my obvious bias, and check this news site: http://www.whysmalltalk.com
Steve Cline http://www.clines.org, http://www.objectbap.com
cLive ;-)
-- Trinity in high heels carrying a whip: The donimatrix - there is no spoonerism
operator overloading is really important? so
this + that
is so much better than
this.add(that) ?
multiple inheritance is really important?
i really question your approach to this? we don't even know the domain, is it engineering, text-parsing, web-based, server-side, client-side, both?
how about if you find a solid, proven language with a lot of momentum. python or java come to mind.
Certainly looks like one to me.
I think I'll submit an ask-slashdot: "I'm looking for a new editor. Which should I choose, vi or emacs ?"
Duh.
What would Lemmy do?
He's not asking what WE'D like in an IDE, he needs something that already has all those features, and I don't think the project he's talking about is writing a new language/IDE.
But to answer the real question as best I can, I can't think of anything that has all those features. But what I'd do if I were you, is to rank the importance of each of those features as it applies to the upcoming project.
Based on my experiences, I'm quite happy with Delphi. It doesn't have multiple inheritence or operator overloading, but it does have function overloading at least. These features aren't generally show stoppers though. I haven't tried Kylix yet so I'm not sure how smooth the transition would be to linux.
In any case, what it comes down to is just pick an language. They ALL have shortcomings and nuances that will take time to learn and overcome if you aren't already familiar with them. So just pick something, code some sample projects, possibly code a prototype of your project if time persists. You can always use this as a chance to learn something new to add to your resume.
...and you're right, none of those programming languages will fit all the bills.
I haven't been programming as long as some, but in my experience I've never come across a particular programming language that covers all the bases. You might be better off deciding which of your specifications is of the highest priority before giving weight to any language.
Also, since no one programming language fits all these specs, you might want to start documenting (or digging up documents) on which ones support the most of your specs.
Just from what you've asked for here, I'd say you're asking more for something like C++ than VB/VB.NET. You've thrown "simplified GUI design" into your specs, and, aside from Java, that's almost always anti-portability. Assuming you go with the most widely-used simple GUI language, VB, you're pretty much locked into MS OS's. Since OS-lock-in seems to be a polar opposite from what your other specs aim for, I'll say you don't want to use VB.
Ruling out the simplified GUI design as the highest priority, I'd say you're best off with C++ or Java. There are C++ compilers and Java Virtual Machines for a variety of platforms (that's an understatement). I lean towards C++ - what with it's pointers, truly compiled code, etc - but that's mostly personal preference. I've got some experience with Java and I've got mostly good things to say about it. But all my C++ apps have outperformed my Java apps, so the optimization geek in me leans to C++.
My sigs always suck.
"My boss gave me a set of criteria"
Hold your horses! Have you really taken the time to understand the *problem* yet? This post is just a laundry list of various programming language features and buzzwords. Choosing a programming language is not like choosing a car, and just adding on all possible accessories and upgrades. More features does not a better language make. I'd have your boss clarify the reason for each and every feature (and yeah, "programmers are familiar with this" probably is a valid response - but there should at least *be* a response). Does your boss even know what multiple inheritence and operator overloading is, and why one would even want it? Until you can justify the features you want, there can't be a debate on "what is the most powerful programming language?". It's like "what is the best religion?", or "what is the best color?".
It's 10 PM. Do you know if you're un-American?
It sounds like C++ and/or Java is your best bet based on the list of requirements, and what your boss probably wants. However, how important are each of these items? Different languages have different levels of support for all of these, and different ways of accomplishing the same tasks.
...
:)
For example, garbage collection in Java or Perl is generally not very good compared to a modern Lisp / Scheme interpreter. C++ has templates, while Scheme has functions as a first-class type. Scheme and Perl have closures, which can be used to build complicated object-oriented systems from the ground up, while Java has inner classes, which is not quite the same
Also, please realize that object-oriented programming, multiple inheritance, garbage collection, and operator/function overloading are all very powerful language features that require careful design and consideration to use correctly. There are times when each of these is a massive help to the programmer, and there are other times when they can each create intractable messes.
So figure out why you need each feature, and what its role is in the project, and if you could use other language features to fulfill the same roles. The language you're looking for probably doesn't exist, and even if it does, there's no guarantee you'd want to use it.
Also, if you really want this (imaginary) language, I'm sure you can write it in C; that's what they do for all the other languages I've mentioned.
pb Reply or e-mail; don't vaguely moderate.
Oh and here is Why Java will always be slower than C++
A couple other languages/environments you may wish to look at are:
I don't have much experience with Delphi 6/Kylix or Object Pascal, but Perl 5 will handle most of your requirements.
Personally, I would go back to your boss and ask why he needs all these features. The list of requirements sounds more like a buzzword-compliant list of programming language features that a typical PHB would come up with than a real requirements list. For example, if a design document hasn't been created, it's likely that this list of requirements is bogus.
NOTE: I found Cliff's question appended to the end of this story very confusing. It's orthogonal to the original question, at best. At worst, it's going to cause two entirely separate topics of discussion which will be difficult to distinguish when reading comments.
HTML?
And pick the language that best supports the most important criteria.
.jar files under windows 2k that go to Linux. We use most if not all of the features of Java (JSPs, EJBs, Servlets, standard Java, and have yet to have a problem).
- "intuitive and easy to use IDE" - this depends on the industry around the language. Java has more than most languages - NetBeans (based on Forte, which is Sun), Eclipse (Open Source, by IBM), Intellij, Visual Cafe (Symantec, I believe), JDeveloper (Oracle/Borland), Visual Age (IBM) - all by big companies
- "simplified GUI design and event handling" - Java has clean event handling and GUI design, and implements most of the design patterns that the software gurus talk about
- "advanced error handling" - Java has great exception handling
- "advanced object oriented design including multiple inheritance, abstract classes, and garbage collection" - Java has all that except multiple inheritance (Gosling considered it, but found that it was under-used, and was evil); there are work-arounds for multiple inheritance
- "full support for operator and function overloading" - Function overloading, sure, but not operator overloading. There is talk of this in an upcoming version (via templates)
- "portable (at compile-time) across various platforms" - Java's bread and butter. We use compile once, run anywhere - we build in Linux, push to Solaris and Windows 2K. I build
You should also add to your list - good networking support (Java has it), good server-side and client side (Java is better at the server side), good web-based support (Java is OK - I don't like JSPs or PHP, etc - CURL is the best IMHO).
Where does Java fall down? It doesn't tie in to the host OS with enough depth. Also, because you require a JVM, you are saddled with your bugs, plus the bugs that exist in the Virtual Machine.
Still, my choice of a language if you don't need to squeek the most out of every CPU cycle (and most don't).
Isn't this like saying, "I want to build a car. I haven't defined what this car is or what its performance should be, or even any of its requirements. But all of the tools I use should be purple, and have a lot of snap-on components."
Choose the best tool for the job -- but first, figure out what the job is.
Why, given a new project, should your boss focus on language features? Much time is wasted masturbating over the technology used rather than how it is supposed to actually solve business problems. I would advise you to tell your boss where to stick his feature list, and concentrate not on language wars but how to provide the best solution in a pragmatic, cost-effective and timely manner.
Quite frankly your boss just sounds like he selected a list of buzzwords from a trade magazine and compiled them into a "the language we pick needs this". What you, or someone needs to do is prioritize the needs of the project and
pick a language based on that instead of a laundry list of "requirements". All the things
you listed are nice and all, but which do you really _need_, and which are just nice. Do you need operator overloading with the same urgency you need code maintainability and being able to find programmers that can code whatever language you pick? Garbage collection is nice, but it tends to slow things down a bit. Do you need top-notch performance more than you need garbage collections? There are trade offs to be assesed, and it doesn't sound like you've done that. These are the kinds of questions you should be asking.
No, but when developments come to pass, be it in the field of programming languages or building materials, they are tested and applied in ways that approach their potential. If this didn't happen, and wasn't supposed to happen, we'd have nothing more than COBOL, FORTRAN, and LISP (forget about one of the nice lisps, like CL, MacLisp, ISLISP, Scheme - just the original). Maybe Algol-60, but with your reasoning, we would've just stuck with the first three.
Working toward a usable PDA environment in the spirit of Newton OS: Dynapad
This situation is obviuosly fake. The author is just trying to stir up a debate about which is the best programming language.
Why would you boss ask you to find a language that supports multiple inheritance? If he knows what advantages multiple inheritance brings to the project, then surely he can quickly choose a programming language himself.
Anyway, how many managers have got a clue about the pros and cons of multiple inheritance?
I really like the "don't constrain the programmer" philosophy of C++/Perl, but personally I've never found multiple inheritance useful. OTOH I /have/ found single inheritance useful (any class you write automatically get's a certain set of methods, typically useful for debugging).
You may want to look at case studies of apps similar to the one you wish to develop and see what they used. Weigh the pitfalls/advantages others have already encountered.
Without knowing whether you're writing web-based or desktop I'd say consider:
- Ruby
- Python
- Java
- Maybe C++ (but no garbage-collection will hurt development time)
That would be the order I'd consider them personally...
Later . . . . . . WebBug
Python is certainly cross platform, and the wxWindows gui port to it provides a cornicopia of functions that are available in that application-framework.
http://wxpython.org/
Why not do both? Java has a portable GUI. And C++ if properly written can do the back-end.
Mike http://thenextgenerationofradio.com
If the boss knew, he would have given out a set of criteria that actually defined an extant language, instead of a set of imnpossible criteria.
I would go back and engage him in a discussion on which of these goals are most important, with the (unstated) goal of trying to convince him that whatever language you think would be best really is best.
Istead of looking at his criteria, look at the project and the goals, and make your own decision. It seems as though he wants a good language that's also easy enough for all of the programmers to use, so if you randomly pick C++ or java for instance, you could convincve him that it would do fine because almost everyone knows it well enough to code in it anyways, and it fits the requirements as well as any of the languages do. (This isn't an endorsement of C++, Java, or of any other language.)
I'm a concientious
Before you don't even have a clue WHAT EXACTLY you want to program...
Your boss gave you requirements that only the programming languages in Star Trek can match.
--Martin
First of all, if you want portability, C is the only way to go. C is a mature language with a mature standard. Other languages, such as Java and C++, have such convoluted and (in Java's case) nonexistant standards that you basically end up being tied down by whatever development tool you choose. Have you ever been able to take a nontrivial piece of C++ code (that uses exceptions, templates, namespaces, etc.) and recompile it using a different tool with no modifications? I didn't think so. Good C code, on the other hand, can be moved from platform to platform with the greatest of ease, so long as it adheres to ANSI and POSIX standards.
As far as OO goes, C is not the easiest language to do OO in, but it can certainly be done (look at the GTK+ framework for an example.) You have to jump through a few more hoops to do it, but basically all it amounts to is a few pointer casts. If you do that, you've got far more power and flexibility than C++ or any other "OO" language can give you. If you've ever wondered why KDE/Qt is so much slower than GNOME/GTK+, it's because the former is written in C++ (slow) and the latter is written in C (fast.)
Python? Perl? I hope the people suggesting these are not serious. Perl is a fine language for doing text processing, and Python works okay for prototyping, RAD, and dog-and-pony shows, but I think he's looking for a production-quality language here. I don't have anything against Python other than the fact that it is dog slow. A Python app on my 1.4 GHz P4 runs at about the speed of a comparable C app on my old 133 MHz Pentium. You might want to look at Python is speed is not a consideration, but otherwise, stay far far away.
Bottom line is that C is the most established language for a reason. It is fast, reliable, and as long as you know what you're doing, safe. There's a reason why the Linux kernel is written in C and not C++ or Python. If it's good enough for Linus, it should be good enough for you.
The primary criteria is that there exists a local
engineering pool for the language chosen. The
programming language 'concurrent euclid' might
be great but if you can not hire anyone who knows
it, don't even think about it.
First, get a manager who knows something about
hiring engineers.
The set of criteria is just wrong, i.e. its worded such that you pick the solution that he already picked for you. (Visual C++ from the list).
;)
Instead, the manager should focus on the business features that the language should have:
- RAD features
- easy to maintain and read
- produce high-quality code (high availability, high speed, etc.)
From the above list, I'd suggest Java if you are creating a client/server with a web based UI. Otherwise use C# if you can convince someone to buy a version 1.0 product from Microsoft.
I'd stay away from Microsoft C++, Unix C++ is good and with toolkits like Qt or Gtk it's also good as a RAD tool (make sure you use Garbage collectors libraries with your C++ programs).
I don't know much about Python and the rest in terms of how good their IDE is to generate GUIs.
Phil
PS I like C#, but I can't get my bosses to get us to develop something in it until the industry decides to buy it too. Chicken and egg
You can have all those features and many more if you use a commercial Lisp implementation (the free ones have no decent IDE or GUI yet).
If you have a serious budget, take a look at Allegro Common Lisp. The other choice would be LispWorks, which is a little cheaper and without run-time fees.
They both have an excellent IDE and come with Interface Builders using CLIM, meaning your apps run under Windows, Macintosh and Unix (Motif) without a big hassle using native widgets.
-- The plural of 'anecdote' is not 'data'.
I think your boss is having fun at your expense :) Seriously, that is a bunch of requirements you're asking for, I'd even dare to say conflicting requirements. I will not recommend any language because I'm a Java fan and would probably try to fit the requirements into the language and not viceversa.
Honestly though, this seems like a silly way to deteremine language requirements.
.NET (C#, VB.Net, managed C++) do not support multiple inheritance. It would be nice to have but it is a bitch to implement in the VM's so it was put off. In practice you will find that most of the languages available are compromises between the ideal language and what can be implemented in an economical amount of time.
If you are a computer science professor, the list sounds great. In the real world you are a little more limited.
JAVA and
I would base my decisions on other issues. What are you developing for? server or workstation? Is this a Windows, Unix/Linux, or other type of platform. If this is going to run in a Windows environment then it doesn't make much sense to go with anything other then Visual Studio. If this is a server based Unix system then start looking at IDE's for JAVA development.
I would stay away from obscure languages and language implementations. You will find more bugs in the compilers, IDE's, whatever. Support will be more limited and most importantly no one else will know what the hell you are talking about. C++, JAVA, VB, etc all have large developer communities. You are more likely to find help on the net and it will be easier to hire experienced developers.
I don't know about operator overloading. But Java provideds the concept of Interfaces, which is far more porwerfull that Multiple Inheritance, IMHO.
--
Adam Sherman
Freelance Geek
Let us take a look at how C++ compares.
Intuitive, easy-to-use UI, check. This is a stupid requirement for a language, though, as any reasonable language should allow your choice of UIs. I've used Visual Studio for C++ as well as emacs and, currently, KDevelop, which I like quite a lot.
Simplified GUI design and event handling. C++ does not determine how GUIs are handled but we use Qt which works very well for what we want. Visual Studio lets you do GUI design inside of it, as does Borland C++ Builder.
Advanced Error Handling. Define advanced. C++ gives you try-catch, etc. and provided you put a big of work into it, can be pretty good at error handling.
Advanced object oriented design including multiple inheritance, abstract classes, and garbage collection. Well, C++ is the language most people think of when someone says OO. That said, C++ does not have any built-in garbage collection which is in my opinion a shame. Still, you can plug in garbage collection if you want, though the URLs escape me. In my experience, this has slowed down the execution of my C++ applications considerably but that said, my applications tend to allocate and deallocate memory quite frequently.
Full support for operator and function overloading. Yes, C++ provides this.
Portable (at compile-time) across various platforms. Well, C++ is NOT, in my experience, as portable as Java is. That said, if you use a platform independent GUI library such as Qt and you are smart in how you code, you shouldn't have any great problems. Gnu Autoconf, Automake, and Libtool, published by New Riders, will help you out here.
So is C++ the language for you? That is impossible for me to say. The two major things it is missing is a GUI library (though Qt is excellent for this) and garbage collection (though this may not be a big issue). Personally, I find it easier to code in Java, mostly because Java does not allow things like multiple inheritence or operator overloading. Don't get me wrong, there is good reason to use these (and my C++ code occasionally does) but on the other hand, it can lead to much hassles. Very few projects really need multiple inheritence, for example, and MI can lead to all kinds of nasty problems. Do you really want to sink to the level of virtual inheritence, for example?
Really, though, we cannot help you out all that much more without knowing what kind of project you are working on. Your requirements seem to indicate this is not a small project. As a result, I'd advise against VB.Net, having spent a year working in VB on a project about a third of a million lines of code long. C# has potential (it is a blunted-scissors version of C++) but really isn't mature enough at the moment. Eiffel I have no experience with. Java is great in SOME circumstances but I'd hesitate to recommend it to you without more information. And then there's C++, which I have spoken about in great length here. But C++ is a tricky language to use correctly.
Oceania has always been at war with Eastasia.
Actually, Java ITSELF overloads the '+' operator; therefore, it's obviously a good thing just so long as no one ELSE can do it.
That's one thing I dislike about Java; it intentionally cripples the features available to the user whilst using similar features in the design of the language. For example, you wouldn't want to write Java in Java, because it just isn't functional enough to do a decent job.
pb Reply or e-mail; don't vaguely moderate.
I agree. From the 12 languages I know, Ruby is one of the cleanest and most powerful languages out there. I tried it, and somehow everything I code just works at once. It works exactly as you expect it to, which makes communicating with your computer a lot easier than with e.g. C++/Java. Try it, you won't be disappointed and learning a new language doesn't harm anyone.
I know powerbuilder has it's problems...but seriously it has everything you are asking for..
Basically the best way I've ever been able to describe it is that powerbuilder has the ease of design like VB but the power of VC++ behind it. For those who don't know it's sybase's baby, and I'll admit it does have bugs (but honestly what software doesn't).
But it's what we're using at my job and I'm happy with it.
You don't start with language, you start with requirements.
If this is a one shot project that won't need much maintance, then use whatever the majority of your devolpers know best. C/C++ have a large number of experts now for low level embedded work. VB has a lot of experts in the graphical front end area. Pytohon/Perl for (unix) scripts. If you are hiring new programers those are your choices.
GUI frontends are tools. If you do'nt like the ones you can buy write your own. In C vi vs emacs wars have been going on for years with no winner. In the mean time MS has sold a lot of compilers that use their IDE. There are dozens more in the free/shareware area, not to mention some compercial compititors. However I always have to ask WHY whenever someone writes a requirement to use any particular one. I can see saying that you will use MS's compiler for instance, but to require their tools is a mistake. Let the programer use their own, with the warning that you only support the offical ones. Make sure though that you can bypass the IDE you chose.
If this is projet that you intend to support for years, then there are a lot of C++ experts, which is a good arguement for using it, since you will have to deal with turnover. OTOH, a good programer can learn any language quick enough, and there are a lot of C in a C++ wrapper programers.
What you REALLY need to think about in your project isnt simplified IDE, and the rest on your list. You need to think about who can maintain, improve and initially create your code. If you pick a language because it has a nice IDE and it seems easy to use, you are living 5 years from now.
.net you are taking a risk because it is new. It is new and the people who know the most about it dont know enough yet. They may have studied it every day since it has been out, and they may have done multiple rushed projects, however there are always problems that come out with time.
You should be concentrating on how easy it is to bring in a developer that knows nothing about your project, bring him up to speed and have him pump out a new modification or continue where the previous one left off.
After that consideration you must also think about how much support there is out there for your choice.
If you pick Java, you will find millions of sites with help, and many excellent open source projects to offer reference by example. You will also be working with one of the most modular languages in existance (mainstream), so that whatever technology your project uses will be easily implementable. There are also many unemployed Java developers sitting around, and even the least capable of the group can most likely grasp the piece they will develop.
If you pick C++, you will be working at a lower level than java, you will have a longer development time, and your developers will need to know more about anything their program will interact with. The advantage to C/C++ however is the efficiency. However it doesnt sound like you are writting drivers, DBMSs or Device Drivers.
If you pick VB, you be working with a much simpler and easy to use language, however modularity in this language is not as easily managed as java.
If you choose
Dont make the mistake that a lot of companies make and just try to control everything about their project. Control is only good when you are making the best decisions. If you see a developer with 10 years of experience in your choice language who knows what he is doing and has done similar things before...
Listen to him, not your boss.
As for VB.Net and C# [...] the fact remains that they aren't even finished products yet.
Sorry, but I've gotta call "Bullshit!" on your post. Now comes your opportunity to explain yourself.
Oh, and as for the part of your post that I omitted with the ellipses, you don't need to believe Microsoft about any portability claims of C#. Unlike Sun's Java, it's an open standard, which is a big reason why Miguel from GNOME is working on an implementation for Linux.
Common Lisp has all the above features and more.
Software vendors:
www.xanalysis.com
www.franz.com
They have powerful gui which allow to add and test widget without compiling. Please note that you can deliver your apps compiled in Linux elf or windows compiled format.
So, did your boss bother to tell you about the actual system requirements, or does he just want to play "Guess which language I've already decided you are going to use?"
--
You sure got a purty mouth...
Unless your development team is a bunch of seasoned object oriented pros, multiple inheritance will probably cause more problems than it solves. Other items on the check-list may present similar "user error" problems.
You boss's check-list is a common phenomenon in the tech world. Each person has their own preferred techonological hammer they like to throw at every problem they come across, without considering what it the best fit.
Your boss sounds like a language-feature elitist. I know it's not your concern as much as his, but those features come at a cost. Unless he has budgeted for his discerning tastes, your project may very well be over-budget before you start.
Use the simplest thing that could possibly work.
There's a reason why all of those are missing something. The only one of those languages with which you won't have to modify your code for Interface development is Java, and Java code executes the slowest of any of those languages. I guess that's the price you pay for portability. Off hand, I'd recommend Objective C, if you're doing Mac and *nix versions, but you'd have to create a GTK version and an Aqua version, even if you used the same back end code. This also would not be the way to go for Windows development, which is too bad, because Cocoa comes with an awesome set of frameworks, and the OpenGL support is superb. I guess you have to prioritize your list and decide which of those elements is the most important. There is no "Holy Grail" language. Otherwise, everyone would use it all the time. You can do it right, or you can do it quick and cheap. VB won't port well. I'd say that if you use C++, you'd be best off, because all you'd really have to do is change OS specific function calls, and it's not as bloated as some other languages. I personally don't know anything about Python though, so it may be worth inspecting. Of course, you could always take the Adobe approach and build your own system of OS independant frameworks ;)
Karma: Ran over your dogma.
Every time there's a discussion about which language is the most powerful, flexible, extensible, or whatnot, everybody seems to forget the one single feature that makes A Powerful Language© powerful:
There, I said it. In order to get the most out of a programming language, whichever it is, you've got to put a good programmer behind it. Really, what is a programming language worth if the programmer sucks? A Good Programmer© will choose the language that best fits the task at hand, based on experience/familiarity with the language/bias/etc. And, since no two Good Programmers are entirely alike, chances are they won't always choose the same language, but the results will almost always be the same.
In Soviet Russia, Jesus asks: "What Would You Do?"
"When all you have is a hammer, everything looks like a nail."
;).
It's just plain silly to ask "what's the best programming language." That's like asking: "which is better, a hammer or a screw driver?" The reverse of the proverb is also true. If you have a diverse toolkit, and nothing but screws to drive, then everything in your kit looks like a screw driver.
It comes down to using the right tool for the right job. It's not a simple question to ask, mind you, but your question is too vague to be answered at all. If you are doing text processing, use Perl (ignoring the argument that Perl does everything, of course) or some type of stream editor. If you are writing an operating system, use C. If you are doing artificial intelligence, use Lisp or Prolog. If you're writing a document, use HT/SG/XML or LaTeX. Building a GUI app *really* fast? Use Tcl+Tk.
Let me rephrase your question with more specifics. "Which is the best programming language: Perl, C++, LaTeX, CSS, Japanese, or ASM?" That's nonsense (although everyone knows that Perl is better
It still baffles me how such stupid questions get posted as Ask Slashdot topics. The editors are genuinely retarded.
Why bother.
Power. Lots of power.
It lacks an intuitive IDE, but it has all other Python features (and some of them are better) and offers near-C performance.
This looks like a poll topic if ever I saw one
Anonymous Coward - 0, Yeah, I know the score. FOAD.
English.
These requirements are terrible. Requirements should not specify implementation details. While abstractly saying things like Object Oriented Design with good GUI tools that supports event handling and good error or exception handling is fine, saying we HAVE to be able to have ths syntax: object1 + object2 is ridiculous.
1) Advanced OO design.
Ok, I can understand wanting OOD/OO Programming constructs explicitly supported. Abstract classes (and/or) interfaces and inheritance, etc. are all good OO constructs. But REQUIRING multiple-inheritance? Why? There are many good OO languages that don't do multiple inheritence. And GC has nothing to do with OO - while it might be a good criterion on its own.
2) Operator overloading.
This is such a crock. Is there anything that can not be accomplished without Operator Overloading? There are many arguments against using operator overloading in fact even in languages that support it. (Non-intuitive nature of it sometimes, the failure to implement all operators including comparisons, etc.)
If you take out the 2 dumb requirements above, you open the door to all kinds of languages:
Java, Python, Smalltalk, etc.
Then you can truly evaluate them on the availble RADs for the language, performance and suitability to the end project requirements.
Fire your boss!
That's your whole list.
Your boss has obviously taken a bunch of buzzwords with no clue what they mean and is making them requirements.
For example: "simplified GUI design and event handling;" Simplified compared to *what*? Xt is simpler design and event handling than Xlib. Tk is (imo) simpler than X.
Why does he know that he's going to need garbage collection or operator overloading?
The real thing he needs to do is look at the requirements of the project, the skills of the available designers, budget and time and go from there. I'd be really annoyed if my boss came to me and said "You're not supposed to be using C++ because it doesn't have garbage collection built-on."
So why not use Perl?
Personal preference, perchance?
Make someone else pick the language, and be sure to work like a dog on it.
You won't get blamed if the project ends up in the dumpster, but you will be recognized for trying to make it work.
If the project goes well, then you'll be remembered for you contribution but the person who picked the language will be forgotten.
Cynical, yah, but what do you expect when most managers have pointy-hair.
Good news for people who like NeXTSTeP and its excellent OO dev environment, the GNU people are cloning it and are almost done with in a few years it will be complete and mature as it has been in development since the release of the Open Step spec. We will see free tools and frameworks for all unix like OSes and possibly for windows.
From the: Mind-Behind-The-Project Dept.
The real power of the language exists in the hands of the maker. The programmer. I've seen people take languages like BASIC and make a masterpiece out of it, better than a C++ programmer could have done.
Certain functionality is often needed for management reasons. Sure, you could use a language that doesn't support functions (hello, Applesoft BASIC?), but it'd be a pain to maintain. You could use a language that didn't have portability but if you're cross-platform, you're screwed.
However, make sure you have good people on the job. If they don't know the language, they should be able to pick it up quickly and have good technique. I'd give a hundred bucks more for a programmer that knew his shit with a crappy language than someone who was a newbie in the latest buzzword language.
Blog,Twitter
i'll give you a suggestion like a friend, choose C++. Freak langs might give you the illusion to be able to grant a shortest ETA, but, if you'll get stuck on something that depends on JVM, lang dep. libraries, etc.. You're _fried_ ( and probably fired ) ...
How the hell did your boss get to be a manager? If he's technical enough to know all those buzzwords (operator overloading, multiple inheritance, etc.) then he ought to know without having a subordinate do research that, for instance, C++ does not have garbage collection.
It makes more readable and modular as well. I would much rather work with overloaded operaters than trying to figure out what function name Joe Bob used for that addition.. oh well.
Since you actually looked a VB even though you should have known that it doesn't fit any of the categories mentioned, let me suggest Borland Delphi / Kylix.
It does have an easy but powerfull IDE with simple GUI design and events, is fully object oriented and with 'interfaces' it also does have some kind of multiple inheritance. Of course it supports abstract classes (which are called 'interfaces') It also supports function overloading but alas not operator overloading.
It does not have garbage collection (but I never understood why g.c. should be a feature?) and cross platform development is limited to Windows and Linux/i386.
I doubt that you will find any language that has all the features on your list. If your boss insists on them, he either does not know what he is talking about or he has already made up his mind and only lets you do this search so he can say he covered the alternatives and they aren't any better.
What is relevant is this: does the language support all the right abstractions so that the programming solution to a given problem within a given domain can be expressed using elements that closely correspond to the ideal objects understood by the experts in that problem domain.
Now a language that does this may be very domain-specific, and not flexible at all for solving problems in other domains. Or it may be very flexible so that it allows abstractons to be created to new domains that were not even known when that language was created.
So, returning to the vague notion of power, when can we at least tentatively say that one language is more powerful than another? When for a large body of different problems, that language can rise to the occasion and provide the ideal abstractions for expressing the solutions for those problems, whereas the other language fails to do so, and only for a few, if any, problems the reverse is true.
Lastly, what does it mean to have the ideal abstraction? It means not to worry about managing the representational or procedural details of the computation that are not relevant to the solution domain, or having to transform, rename, reshape, reinterpret anything. Unfortunately, this rules out nearly all languages whose only abstraction-making mechanism is making class or function libaries, because not every abstraction in a problem domain neatly corresponds to an object with methods. Only languages which are programmable---meaning that they allow you to write your own sublanguages and provide them as easily as function libraries to other programmers---can support this shape shifting, to produce abstractions to unforseen domains. People can develop custom sublanguages for anything: solving logic problems, querying databases, composing music, generating markup, whatever. You can do these things with object frameworks, but then you lose abstraction; the object programming gadgets rear their ugly head with details like what to instantiate and how to hook it up to something else, etc.
Think about your while() loop in C or Java. The while loop is an ancient abstraction of control flow that someone had to invent. Yet your objects are not powerful enough to implement even this simple abstraction from scratch; you can't make a ``WhileClass'' whose instances do the job of a while loop.
It doesn't work to base criteria upon what a given language can do or not do. That are only specific to language researchers. Instead you should look at what you _really_ need in the language.
Operator overloading tends to clutter the language if used incorrectly. Used to implement mathematics in the language can be acceptable (a complex class for instance). However, to use operator overloading for common tasks makes the code _less_ readable.
Multiple inheritance can be dangerous to implement. It has been removed from java, since it has no real power in most applications. Instead, java uses interfaces for the somewhat same result.
What do matter is the size of the standard library too. Given languages with big standard (3rd party) libraries, you can be much more productive over time.
Another thing is if the language is statically or dynamically typed. There are advantages of both approaches. Dynamic typing tends to give faster development, whereas static typing is a bit more safe, as the compiler can catch more errors.
If security and stability is very important, the functional paradigm might be even better to explore (Scheme, SML, ocaml). It all depends on the actual task. If writing a compiler, functional languages might be _the_ langauge to use.
IDE and RAD tools are overrated for development. Where the GUI frontend can be implemented in these, the backend is often better made seperately. FFI's of different kinds can make a hybrid between more than one language a powerful choice.
Accept that there is no ``perfect language''. Instead, one should look into the specific task and learn which langauges have which powers and weaknesses. Then the choice can be made correctly.
even Visual Basic has it's powers.
The interactive way to Go -- http://www.playgo.to/iwtg/en/
yes, that's right. The programmer is what makes any programming language powerfull. You might as well ask what color is prettier. It all comes down to the opinion of anybody who uses any particular programming language. There are those that will say Java is better, others will say that C++ is better, and still others that sneer at the C++ crowd and say that C is better. Just pick one that fits most of your criteria that you and/or others in the shop are most familiar with. It would be idiotic to go with a language nobody there knows just because it fits all the criteria since the time spent learning the language well enough to make something good with it will end up costing more than the project is worth.
Steve's Computer Service, Hobbs, NM
Your boss has read too much marketing babble, lots of sexy-sounding buzzwords look exactly like that.
Some of the features listed here (IDE, GUI) are not integral part of any language that is sufficently widespread for large scale commercial development.
Some are outright bad (multiple inheritance, even operator overloading) and should be avoided. Multiple inheritance is THE way to mess up your class model, MI and "advanced" OO design cannot be mixed without trouble.
If we look at the other points brought out, I'd recommend Java and/or C++ (yes, it's sometimes useful not to limit your projects to a single language).
...does have those features. Crawl out from under your rock and have a look.
Please mod this post only if you think others should/n't read this. I have enough ego^H^H^Hkarma. Thanks!
The meta-title for this thread could just as well be "What makes a powerful flamewar?"
As others have mentioned, the expressive power of a language has to be weighed against the availability of tools, developers, etc. However, there is another dimension to this: What sort of developer is proficient in a particular language?
Lisp is a powerful and flexible programming language. Lisp programmers can often accomplish quite a bit in a short time. Is this purely due to Lisp, or to the programmers? If the programmers who end up learning Lisp tend to be a cut above the norm, then the productivity we see from Lisp programmers will tend to be a cut above as well.
I think your boss has been reading too much M$ C# Sales spiel (those 'specs' sound like a MS quote to me). Do what most tech do, agree with management, and pretend your implementing all the their 'tech strategies'. Then do it how it should be done.
;-)
I assume you grew up on a language and know what your doing (well at least know how to RTFM to find out)
Their are planety of web sites out their that report they're running ISS, but if u look closely it they also report Linux as their OS. ie boss told tech to use MS ISS and they just edited apaches conf
-Trevelyan
Operator overloading made baby Jesus cry.
Malike Bamiyi wanted my assistance.
On a large project you will have backend, middleware (sometimes several layers), and a front end. there is no reason these need to be the same language.
Remember the OSI model (which isn't always best). You should be able to take your top layer, running on Appletalk over token ring, you should be able to change it to IPX running on Hyperchannel without changing your application code at all.
You should be able to write your layers in several independanat parts, and change. Most programs are written in a language, but scripted in a different one. VB is a poor choice for time critical high speed data movement, but excellent for scripting a windows application (even if it is basic). Hand coded assembly is poor for user interfraes, but when you need fast code in little memory nothing beats it. (assuming good programers)
ps, brownie points if you know what hyperchannel is...
Language: C++
IDE: Emacs
GUI toolkit: GTK
GUI designer: Glade, Libglade
It all works; it's all free (in both senses of the word).
BTW, GTK, in my experience, works just fine with C++, despite the fact that it's written in C.
You see this so often here on /., an article that seems designed to get the different UI/OS/License/Programming Language camps at each other's throats. Clearly the /. editors think controversy is a good thing.
I would tend to agree with that, except that I am still stinging from the response to a recent /. post where I opined that open standards and competition are better than the the alternative.
The surprising thing for the above article? Seeing the Python people (who I tend to agree with) and the Smalltalk weenies speaking up more authoritatively than the Java contingent. Cool!
Jack William Bell
- -
Are you an SF Fan? Are you a Tru-Fan?
take a look at WxWindows. It's also been ported to work with other languages such as Perl and Python. IMHO it's prettier-looking than Tk and nicer-feeling to code in (more OO).
News for Geeks in Austin, TX
Java should meet most of your needs. Other than proper garbage collection. But a good JVM and some clean coding practices will fix that.
The major problem is finding an IDE that isn't chock-full of totally useless widgets and features. You know, something that's lean and fast?
Well, for minimalist coding in an Oracle environment, including the ability to auto-deploy an entire EAR or WAR to different servers.. I'd have to say Oracle JDeveloper 9i is a good bet.
But for everyday programming in Java? Nope. Sorry. Try asking the folx @ limewire what they like.
Did your idiot boss deign to tell you the actual requirements of the system being written, or did it occur to you to ask him? The system requirements should drive the choice of language, platform, etc., not some masturbatory desire to use a language that is buzzword compliant.
You've convinced me.
Write me a C compiler in Python.
Thanks.
Everyone is suggesting Python, but Perl and Python have very similar semantics -- so, if you're considering Python, why not consider Perl too?
Java doesn't overload + even though it fakes it. The compiler replaces string concatenations with uses of the StringBuffer class before generating bytecode. There's no actual +(foo1,foo2) operator being called. If you want to argue that that's operator overloading, then you'd have to include any language that supports macros or source preprocessing as supporting operator overloading.
You're going about this the wrong way.
If this is going to be a product developed by an existing company, the first questions I'd ask when selecting a language are these:
Do we already have programmers on staff? If so, what languages do they already know and are proficient at? If not, am I picking a language that is so obscure there are only 7 people on the planet I can hire?
I want a new quote. One that won't spill. One that don't cost too much. Or come in a pill.
Your boss needs to re-examine the requirement for multiple inheritance. I've got 15 years experience OO development experience. MI is something that looks good in the design but is a maintenance nightmare. Avoid MI at all costs.
intuitive and easy to use IDE
Bourne shell, vi, make, and compiler-of-choice (this is the language-universal IDE, and it really is the easiest IDE--all plain text all the time)
simplified GUI design and event handling
Qt (C++), Swing (Java)
advanced error handling
not too sure about this one; error handling tends to be on a per-application basis.
advanced object oriented design including multiple inheritance, abstract classes, and garbage collection
C++...no, Java...no, C++...
full support for operator and function overloading
C++
portable (at compile-time) across various platforms.
C++ (Yes, C++ really is portable, if you aren't a slouch)
Healthcare article at Kuro5hin
How about a free language, created to work on the chipsets of the world, to which you can add whatever high-level language you desire, which ever one will fit the job?
it's called Linux. it's supported on the chipsets of the world. you can add whatever non-abstract language you want, or use asm. if you're making web apps, there are lanugages; if you are making console apps, there are languages; if you're making hardware apps, there are languages; if you're making apps for other OS-level languages, like windows, guess what, there are languages.
AntiChristX
Daring to remain below 5 karma indefinitely
For the criteria you list, the answer is either Lisp or Smalltalk. However, I think you are probably asking the wrong question. This is from a hard-core Lisp programmer who has done virtually everything in Java for the last 3 years. Yes, Lisp is by far the most productive language I've ever worked in, all other things being equal, but all other things are never equal. Java is almost certain to get you to your ultimate goal more quickly because of the wide variety of frameworks and components and tools you can start with. Look at jakarta.apache.org or the sourceforge java foundry for examples.
To answer your first (and less religious) question: .NET, which hopefully makes this even easier.
Why not code the GUI in a fast language like VB or perl, then connect it (using COM/CORBA/...) to a main app coded in a more capable language like C++?
Or wait for
Or, if you want to stick to one language, use Delphi/C++-Builder, which may make porting easier (using Kylix).
No sig to see here. Move along.
You pick the right tool for the job, not the other way around. Unless you're a language designer, I guess, and you're trying to figure out which jobs your language is well-suited for....
:).
Okay, here are a few choices I can think of:
1. Try to figure out which language(s) actually support all of those features. Maybe some interesting research there. I've always enjoyed looking into different languages, anyway.
2. Try to figure out what answer the boss wants (C++ seems likely). Note, it may not be the boss, it may be his boss. This is one of those check-your-political-climate scenarios. It's the opposite of #1 -- instead of going by the technical merits of the languages, you go by the wishes of the boss.
3. Try to figure out what language(s) are well-suited for the project in question, and give him one of those as the answer.
4. Talk to your co-workers who are going to be on the project, and ask them which language they'd like to use (or think is best).
5. Talk openly and honestly with your boss about a better way to select tools for development. This can only succeed if you happen to have a boss who is able and willing to learn from the people he manages.
6. Make up a name for a new language. Don't actually bother with creating the language itself. Naturally, your new language has all the required features. When the boss asks why he can't find out anything about it, just tell him it's brand new and there isn't much information about it yet
Some of these options are "less than honest". If that bothers you, well, I don't blame you, because I wouldn't choose them myself.
At any rate, good luck -- and I'm sure we'd like to know how it turns out for you.
-Thomas
It generates temporary objects that are created and deleted behind the scenes.
Note that if your operator is inlined and the compiler is reasonably smart, these temporaries are often optimized away. Usually when they aren't, the cost of the copy is low compared to the overall cost of the operation.
Ooh, a sarcasm detector. Oh, that's a real useful invention.
... the MCF (Mongolian Cluster Fsck), which sadly occurs when a committee gets together to decide things.
It's Linux, damnit! Pay no attention to renaming attempts by self-aggrandizing blowhards.
A similar thing can be said for multiple inheritance. Is this truly a necessity of your design? BTW, Java *does* support multiple inheritance, but only on the interface level (eg, "myInterface extends X, Y"). That aside:
-far, far less multiplatform issues, by far
-extensive tool library included. This is better than it may seem at first: if you want to someday interact with some 3rd party application (or vice versa), integration is magnitudes easier if you're all building off the same tool set.
-builtin i18n, if you need that kind of thing
-nice GUI IDE environments: skip JBuilder, try NetBeans/Forte, IntelliJ, etc.
Now that aside, before choosing a language, make sure that your design is always given the upper hand. The language should be a mere tool for implementing the design; it should not dictate important aspects of the design.
A student asked Daigon, "But, does that not apply directly to Java with respect to multiple inheritance?" Daigon stepped to the right and said, "There is no multiple inheritance."
At that moment, the student was enlightened.
To answer the subject (rather than the submitted question), a language is made powerful by being turing-complete.
A language is also made dangerous by being turing-complete, since useful things like knowing if any given program will halt immediately become impossible.
To me, a good language would be one which has two modes: turing-complete, and turing-incomplete. If you need to write an operating system, go for the turing-complete mode, and code very carefully; if you're writing application software, turing-incomplete mode should be sufficient, and the compiler should be able to alert you to all sorts of bugs (eg, finding all possible infinite loops, deadlocks, race conditions, et cetera).
Tarsnap: Online backups for the truly paranoid
Wow, wrong on both counts.
1) Programmers create the temporary objects, not operator overloading.
2) Of course they can be made virtual. They are just syntactic sugar for:
obj.operator XXX(parms)
VB.NET doesnt support everything C# does. I would go with C#/Visual Studio.net
Borland Delphi has good report from Peter coffee. It has great IDE and great debugger. The language itself is powerful. True object oriented language and it handles event programming nicely.
If you want to download the Enterprise version, Borland provides a trial version.
I would strongly recommend Borland Delphi.
"advanced object oriented design including multiple inheritance"
In my opinion, the complexity it adds outweights the benefits it provides. I like the Java and C# approach of allowing inheriting from one class while allowing multiple interfaces.
Sounds like what your boss really wants is something like SML or Lisp. Granted, these might take a while to get people up to speed on, but projects featured here in the past (sorry -- i'm lazy and this box is short on ram or i'd dig 'em up) seem to indicate that once the project is going development time is short and maintenance is easy.
And if they claim the languages aren't object oriented, point out that everything is a first order object -- including functions.
The errors of Enron occured under Clinton's watch and it was Clinton's watchers that enabled Enron. Enron called the Whitehouse and asked for a favor; it was denied. Enron called Clinton's admin for a favor (India) it was granted. Robert Rubin, a Clinton man all the way, tried to influence the Fed to extend credit to Enron. Enron began falling apart on its own before GW took office.
Your .sig has no basis in reality.
What are the requirements of your project?
What are the requirements of likely projects for your group in the next 6 years?
Define those requiremnets FIRST before starting to do any logical design and make design choices.
Also, will you be doing the entire project in house? If not, what libraries or packages might be availabe to help your project succed? What restrictions do they place on your choice of languages?
What about your staff? What types of languages do they know? How easily do they learn new languages? Say you decide that the best language based on your features list is SOAR. That would be quite pointless if half your staff go crazy trying to learn it and cannot maintain it.
The art of design is a balancing act between many elements. It behooves you to get the broadest views possible at the outset and avoid commiting design choices until as late as practicable.
Its time to do some analysis of desires and necessities. It sounds like a wishlist of everything you will *conceivably* need. Do a little design work and decide where you need what when and start leveraging the features of several languages/runtimes. Step away from the keyboard. And tell your boss to get a hobby, Christ.
BIG downside for C#: Not yet in any way proven that the platform will meet expectations (no longtime testing yet).
Java has no operator overloading, but no one will need that. Many people discourage operator overloading, because C++-syntax is already symbol-loaded enough and everybody will have other intuitive expectations what an operator should do over a type, you'll bet.
Java and C# offer interface inheritance (mix-ins), that produce much clearer code than multiple inheritance in C++.
Besides: C++ meets many of these requirements, too. But more often than not using C++ would increase the needed effort to achieve the same goal. Rule of thumb: Twice as many devel time as in Java (so the same for C#).
Python could do the job, too. It's the feature-richest (in concepts and paradigms) of all. But for app devel in a commercial environment it seems to be a bit misplaced, so basically it stays with Java and C#.
What I can't understand is why you don't use Java. It has everything you need.
"What Does the Powerful Programming Language Make?"
Only by answering this question, can you really make a informed decision on the language to use. Neither OO or functional programming alone is a cure-all. They each have their boons and setbacks. IMHO, the more volatile the field of your application is, the better off you are with a RAD tool. An example in this case would be using Perl/PHP for an internet application. And for large development teams, I would recommend an OO tool (read easier delegation)
What I would love to see in a language is something merges the power of Perl (mainly regular expressions) w/ something like Visual C++ (OO + GUI), AND allows easy distribution (doesn't require a special runtime module, and is not a pain in the neck for Joe Blow to install on his machine)
-jc
choose the language that most of the developers know.
Of couse, with Java, the situation is even worse.
Programming can be fun again. Film at 11.
The Fazigu ODK does all of the things on your list. Check the link, your boss may already be familiar.
thank you
Ever heard of GLUT? It's an OpenGL toolkit that provides a simplified GUI API which will compile on a variety of different platforms. Granted, it is written in C (not C++), but I believe that people have written C++ wrappers for GLUT.
The main problems with this approach would be:
1.) no nice IDE (no Borland Builder GLUT IDE:( )
2.) Event handling is kinda tricky (you hafta use callback functions, and there aren't really that many of them for you to write)
OCAML is much more expressive and safer than C++. Think of it as always programming in templates. It has an IDE too called Cameleon. I guess the one thing it lacks from your feature set is operator overloading.
Why operator overloading should be in that list isn't clear. It's useful for math work, but confusing for almost everything else.
Ahh but Java doesn't have a preprocessor either; either way, they're cheating. :)
...
I'd love it if they did, though, because I'd #define away their ridiculous verbose names into something short and memorable
pb Reply or e-mail; don't vaguely moderate.
I think that you are overlooking the fact that operator overloading is not considered a proper or "advanced" technique in OOD. It also reduces the readability of code by changing what a overriding not a method or function of a parent class but a fundamental operator of the language. It is interesting to me how much focus the poser of the question placed on "features" while ignoring some more foundational facets such as reliability and maintainability. It looks like this project will produce Yet Another Buggy, Unmaintainable Program (YABUP!). I imagine that a serious evaluation of the requirements (rather than the guessed-at features) would suggest Ada or Eiffel, or even Objective-C for use. Undoubtably these languages will be ignored for their lack of hype, however... ;P
C++ probably comes closest to hitting your list of the major candidates. If you use C++, use a CASE tool and load up your toolset with every lint-like tool and style checker you can find. C++ and tarpit tend to go together unless you are very smart. Then it's fine.
Not only that, but solve as little of the problem as possible. Someone else has probably already solved much of your problem and made available library/framework code that you can build on. The perfect language isn't if you have to re-invent every wheel with it. I do try to follow my own advice -- the availability of a partial solution for one of my problem domains is why I use Tcl a fair bit despite hating the language. OTOH if you want a language with cool features for the sake of coolness, I'd go with O'Caml.
is the The PERFECT LANGUAGE!!! ™
The perfect language is the compiler suite that writes the code for you. You just type in the requirements and it writes the code! Additionally you can buy the speech module and just say the requirements to the computer. Can't figure out how to describe the program to PERFECT LANGUAGE ™ then buy the mind reading add-on. GUI design is simple as again the PERFECT LANGUAGE!!! ™ creates the perfect gui. For those of you who worry that if your product is perfect the first time and that you won't be able to make money off of upgrades don't worry. The PERFECT LANGUAGE ™ incluse the MS feature. This will introduce a number of bugs into the program that can be fixed when you want to produce an upgrade. So, in short there is no reason why anyone wouldn't want the PERFECT LANGUAGE ™.
really, it does.
Paul
You need to find out what the real requirements are. That thing from your boss is just a list of every language/environment feature and buzzword he has ever heard.
Compare C/Java SLASHDOTSLASHDOTSLASHDOT
dotproduct = FixedAdd(FixedMultiply(u_x, v_x), FixedMultiply(u_y, v_y));
with C++ SLASHDOTSLASHDOTSLASHDOT
dotproduct = u_x * v_x + u_y * v_y;
I would certainly find the latter nicer.
(hee hee)
Jack Valenti and the MPAA are to technology as the Boston strangler is to the woman home alone
Hi,
do yourself a favour and take a look at
Objective C and the typical Frameworks
like Openstep or even more recent Cocoa.
As a converted Linux, now Mac User I recently
discovered those goodies and I really don't
understand why they didn't take off in the past
(NextStep has been around since the 80ies).
Objective C is such a powerful dynamic language
and it is real fun to write programs with it.
You have a clean and lean Smalltalk-in-C object
oriented syntax and are able to use all those
low-level C APIs... I don't know any better.
PS: For the use with Windows try to get one
of the OpenStep 4.2 packages one often find
at ebay. Besides the native Next/Sun/i386
OpenStep OSes it includes a devkit for
the use under WinNT... If use ever had to
use COM and alike, you will really, really love
OpenStep....
PS: There is even a GNU implementation of the
OpenStep API... -> GNUStep
Pointers:
http://www.stepwise.com
http://www.gnustep.org
Although it's an ANSI C IDE, I highly recommend National Instruments LabWindows/CVI from the people who brought us LabVIEW. LW/CVI is my preferred IDE; drag-and-drop GUI design, excellent debugging tools, a full-featured API to cover everything from event handling to SQL to advanced data analysis, excellent documentation, excellent online and phone support, excellent training seminars around the country, and portable across Windows (even 3.1), Mac, Sun/HPUX, Sun Solaris, HP-UX, and Linux. Don't overlook this product for its automated test applications, it is very capable of applications of any kind.
I used to program in C++ but wound up reverting back to ANSI C years ago, the aggravations were not worth the gains. Especially after digging deep enough into MFC code only to find the old ANSI C Windows API calls underneath all that bloat!!!
Eternity: will that be smoking, or non-smoking? I Corinthians 6:9-10
hrmm...
I think that:
obj++;
is more readable and maintainable then:
obj.what_ever_func_the_developer_chose();
Often it simply doesn't pay to use a minority language, even if it seems better suited to the problem.
Closest thing today is C (though it doesn't do hetrogenous arrays naturally... you can certainly typedef them though)... with Java etc... being a close second (if not for the stability factor - please don't flame... it's getting there)
You should check out OCaml. It is a modern functional programming language. It has parametric polymorphism, as well as subtyping polymorphism and dynamic dispatch, is garbage collected, features an advanced module system to help you structure code, and ports are available for all the usual platforms.
In addition, OCaml interfaces well with Gtk (including using Glade to design GUIs), has database libraries, as well as all many other libraries that one would expect.
OCaml can be either compiled to a portable bytecode, or directly to machine code. It compiles to very efficient code, and it is popular folklore that it can easily match C in terms of execution speed in many circumstances.
The language is at a good point in its evolution right now to be used in commercial circumstances. It has been around long enough that it is well-understood and a lot of useful libraries are available, and its compiler is very robust, but at the same time it is not so old that a lot of the really new and interesting developments in language design haven't made their way into it. Although I prefer Haskell for small one-off programs, I would use OCaml for large projects.
Another language which has had great success in industry (especially telecom equipment, as it was developed at Ericsson to write million-line switching software) is Erlang. Although I have not used it myself, its proponents swear by it as the best tradeoff between elegant PL theory, and the reality of writing large software.
You will note that my recommendations all have a functional programming slant to them, and this is only due to my own preferences. I have not kept up with developments in OO language design, and so I cannot recommend one readily.
If I may step on a soapbox for a moment, however, I would like to say that especially for the design of large systems, a strongly-typed modern funcitonal programming language with a good module system is a very good solution, to rival OO Design Patterns. As modern type systems allow you to express very precise invariants about your modules' behavior, they can be used to help many programmers together write large pieces of code that can then be checked at compile time to behave in a consistent manner. This can save both development time and money. Those are good things.
--
Not exactly correct. If a product is guarunteed to solve all of your problems the odds are that it will solve a great many of your problems, but less than optimally.
There will be *some* problems that that it cannot solve at all.
It wall also solve *no* problems optimally.
The same largely applies to any purely mechnical device that claims to be "self adjusting and/or maintainence free." They always are, until they need adjusting or maintainence, which you then discover is impossible.
KFG
The requirement's don't say that the libraries must be free. I'd assume that if they were looking at C# and VB.Net that cost is not an issue in this case.
--xPhase
The following sentence is TRUE. The previous sentence is FALSE.
example:
---------
std::string a = "hello", b=", ", c="world", d=".";
std::string e = a+b+c+d;
std::cout << e << std::endl;
---------
No c++ compiler can optimize the temporaries out. Each temporary created calls the default allocator for string, which usually is malloc and free which are usually dead slow in an smp/multithreaded environment.
In this case, using strcat is many many times faster that operator +.
--Jeff
ipv6 is my vpn
The best language is the one *you* know.
I don't mean know in the sense of 'having read the most about it', but the one you did a real project in. There simply is no perfect language, there are just languages that you know how to work yround its shortcomings.
Yes, some languages are better suited for certain tasks, but what good is that for you if you have to look up each command in a book? It takes a few month to get 'fluent' in a language. Do you have that time available to get your project finished? If you skip this learning time you will redo much of what you did in the beginning, just because you are ashamed of the ugly code;-)
Regards,
Tobias
Regards, Tobias
Why don't you take a look at haskell.org.
Haskell is a purely functional language, with pretty much all the features you want, even a GUI lib. Compiles on all types of Unix, as well as Windows and MacOS. Agreebly, moving to a functional language after years and years of writing C-style code can be a rather odd experience, but you catch on quickly.
If you have to have all those features, then you should be using C++ and instead of useing the normal memory allocation routines, just use a C++ Garbage Collector library. They are free, just use google to find them. C++ is the most supported language. It has every feature, and just because it has them doesn't mean that you should use them.
Personally I think that you should go with java, then only features that it doesn't have is operator overloading and multiple inheritance. Java has good graphical IDE and the code is more portable then C/C++
I know this might seem a bit off, but the list of things you mentioned needing actually matches up well with smalltalk. Its still one of the only pure object languages, with an intuitive IDE, garbage collection, simple GUI use and portability to rival Java. The tradeoff for all of this is that the syntax works under a different paradigm than the standard C, C++, Java stuff. Takes a bit of time to get used to. The code compiles, so in many tests the final code is a bit faster than Java.
If you're coding small things, then it's pretty easy -- any language strikes the right balance for you of being fast and easy to maintain, and can do the five following:
.NET until somebody's built a killer ap with it. Java's still pretty good for delivering binaries that need to run on more than one platform. Don't know enough about functional programming languages to comment on their usefulness. You might want to stay away from lower-level languages if you need to dynamically build strings.
1. Accept input/Produce output
2. Read from memory/Write to memory (arguably the same as #1)
3. The ability to repeat actions
4. The ability to make decisions
5. The ability to do complex math
So, basically, it can be any godawful thing you want, so long as it doesn't need lots of eyes looking at it (in which case you might want something with a larger common-demoninator (eg: not pure assembly or something you cooked up one drunken evening with lex and yacc)). Chances are, if you documented it well enough, then if you get hit by a bus someone could either come in and pick up where you left off, or redo the thing in their language of choice.
If you're coding for a group or a large project, though, your demands are going to be different. Modularity will be necessary, and it probably wouldn't hurt to consider OO for any sort of data construct that might get reused more than once or twice throughout the project. Languages that offer that would be a better choice (C++, Java, etc.).
If you're looking at distributed programming, consider getting a language that works well with CORBA. ORBit's a free implementation that you can play with, although last time I checked it was mostly C-based and meant primarily for Linux & GNOME.
If you're looking at a visual-based environment, go with something that builds interfaces easily and can glue into more complicated components (Visual Basic with ActiveX references, or maybe Python/TKinter with C++ components, or whatever). It would also help to mess around with a language that already has a large common base of libraries so you don't have to reinvent the wheel for printing reports or whatnot. As computer speed continues to outstrip inefficient coding (with apologies to the purists) there are fewer and fewer arguments against Visual Basic.
If you've got to patch into databases alot, there's very little that's cleaner -- and can produce prettier output -- than PHP, although that restricts your interface options somewhat. Fortunately most languages have APIs that can let you work directly with SQL statements.
Avoid
For text parsing, consider something that works well with regular expressions (ie: Perl). Also, don't underestimate the benefits of learning shell scripting in general, especially if all you want to do is automate some system tasks.
If you're doing something that involves getting the highest performance possible, you need to go with assembly, C, C++, or some combination thereof. You might want to fork over for a better compiler too, if it's that important to you.
--------
Bleah! Heh heh heh... BLEAH BLEAH!!! Ha ha ha ha...
on a Turing machine with an infinite length of tape...
My recommendations:
1. Use a language and tool that you and your staff already know pretty well.
2. Use several languages or tools if necessary.
3. If nothing that that you know fits the requirements, determine which one are essential, then look again.
5. If nothing that that you know fits the essential requirements, don't bother learning a new language for the project. Let someone else handle it.
No data, no cry
How does everyone feel about Delphi? I personally have taken a liking to it. Object Pascal is a pretty and mature OO language. It's obviously short on some C++ features such as operator overloading, but in combination with Delphi's GUI designer and it's portability (kylix!), I think it's an excellent business tool. I've always been a fan of Borland stuff though, maybe I'm biased... What do you think?
ascii art
on the above may well serve to illustrate my point.
KFG
Your boss is most likely a tech ignorant (or worse tech wannabe) that has no business diticating a list of requirements like this and, from the sound of it, has no experience shipping software. If all of these are hard and fast requirements, then C++ fails to make it on the Garbage Collection and advanced error handling, Java fails on the multiple inheritance and operator overloading, and VB.not and C-Hash fail on the cross platform (unless the M$ shills in the audience can point me to the respective Mac || *NIX compilers for them AND assoc. libraries). Don't even get started on the IDE issue - nothing like a three way flame war between DevStudio sheep, Emacs evangelists, and VI virtuosos. If you're even thinking about dictating an IDE for developers to use, you're going to be in for a real fun time.
Languages/platforms don't even get chosen in for-profit software endevors because they meet a laundry list of requirements like this. For better or (usually) worse, there's the practicality of developer experience, cost of maintainance (inc. compiler/ide licences), and above all market perception (just try to go off and sell that great tool written in Sather with TCL/TK UI bindings that runs on any *BSD desktop).
Despite this, it's not the things ON the list that disturb me, it's the thinks left OFF the list. No specification of multi-threading support? No question about parsers for XML? Don't need a networking library? How about ODBC drivers? What about support contracts or consulting rates if you run into a big problem and need a hired gun? And dear GOD why the HELL is there no mention of automated build and testing harnesses for any of it?!?!?
See what you can do to get a boss who's been through an actual product lifecycle. Otherwise, get ready learn what "deathmarch" means firsthand.
*** Sigs are a stupid waste of bandwidth.
...is FORTRAN! Anyone who says otherwise has clearly never used FORTRAN.
The java compiler is written in java so I really don't see what you mean by "Java in Java". Now perl, for instance, is an example of a language that can't build itself.
development.lombardi.com
You don't need multiple inheritance--IMO it is a fundamentally unworkable concept. See the "diamond problem."
In a singly-inherited language like Java, you get much more flexibility by simulating "mixin-style" multiple inheritance by using multiple interfaces and delegation.
This example stolen from Joshua Bloch's excellent book Effective Java:
public interface Singer {
AudioClip sing( Song s );
}
public interface Songwriter {
Song compose( boolean hit );
}
public interface SingerSongwriter extends Singer, Songwriter {
AudioClip strum();
void actSensitive();
}
// My own addition
public class Debutante implements SingerSongwriter {
private Singer _singer = new ConcreteSingerImpl();
private Songwriter _songwriter = new ConcreteSongwriterImpl();
public AudioClip sing( Song s ) {
return _singer.sing(s);
}
public Song compose( boolean hit ) {
return _songwriter.compose(hit);
}
public void actSensitive() { }
public AudioClip strum() { }
}
Hi,
My opinion is that large projects tend to require a multitude of tools to solve. If you divide your project into subtasks, you might find out that there are different languages that apply to each of those, and that interfacing is simpler than chopping a task to fit in a language.
And don't forget, you also have to make a good choice for the source management system (like CVS), and the building enviroment (as make).
snoopyaddr@hotmail.com
Choosing the language is a huge economic decision in any project. The language that is most suited to solve the problem may not be the tool that most
is the most economical in the long run. Take some exotic minority languages - C#, Java, Python, etc. Sure they may seem appealing for solving a group of
problems, then you realize that since harldy anyone practices them for a living anymore, you are paying 2x for support over its lifetime, if you can find
staff at all.
Often it simply doesn't pay to use a minority language, even if it seems better suited to the problem.
I don't think there is anything that will satisfy each and every item on your laundry list. No offense, but it seems like a lot of buzzwords linked together. If your boss has any idea about the technologies available, he would not have put this list together. Looks like someone read too many "IT for managers" articles.
Seriously, how do you know you will need multiple inheritance? Or garbage collection? You have to do a very thorough analysis of your problem before you can come to these requirements.
MSN 8: Now Microsoft even has bugs in their ad campaigns.
I'm surprised to see that there has been no mention of one of the only true object oriented languages available, Ada95. Using Ada would meet every one of the criteria that you specified, especially the parts about operator overloading and inheritance. Not to mention it is quite possibly the only language with built in multi-threading, no operating system dependant calls required.
Perl!
Whenever anyone asks you what language is best to write a program in, smile, and say "Perl".
So, here's my list
Does such a thing exist??? Every language has an IDE. Visual Studios, JBuilder, Emacs, KDevelopers, etc.
Well, this really depends on the operating system. Java's the good place to go here. If that can't be done, GTK and Qt are good libraries and they use the standard X style callback mechanism which is so much nicer than message based systems. What your really looking though is for a WYSIWYG GUI designer so I'd recommend Glade or whatever comes with the IDE you go with.
Such a buzz word... Java and C++ both use exceptions. Good error handling has more to do with a projects design though and not really the particular language...
Lets get our terminology right
IMHO, MI is necessary for advanced projects but Java interfaces _almost_ make MI unnecessary. You may do well to evaluate whether you truly need MI. What really matters, is how good your development team is.
This really should be in Java if you ask me but it isn't. You really don't need it. You could use interfaces instead. Of course, C++ support for operator overloading is great. Again though, you should really evaluate if you truly need such an advanced feature. If you just going to use it to concat strings then you don't need it.
Java or GCC. C++ is portable as long as it's GCC on both platforms
I think I'd have to agree with the general sentiment that you really need to evaluate your requirements because they are extremely unjustified and appear to be either (1) a bad manager, (2) pressure from employees to obtain "resume builder" skills, or (3) a very complicated project which you are not providing very much required information for
No language can satisify all your requirements perfectly. C++ comes closest. A combiniation of C++ and Java would do the job nicely.
int func(int a);
func((b += 3, b));
C++ has everything you need when it is combined with STL (now part of Standard C++). The generic programming feature alone (templates) makes C++ a more powerful development language. In the past my main problem with C++ was the requirement that the programmer manually manage memory through malloc, free, new, delete etc. In this regard I often wished C++ had an automated memory manager. However, this problem had effectively been solved by implentations of smart pointers, which take care of all the messy issues of allocatiion, deletetion and sharing. Specifically, I use Boost libs (www.boost.org) boost::shared_ptr.
l ).
C++ is a powerful language. In the hands of an experienced programmer it can be used to produce portable, standard, efficient and elegant code. It's not an easy language to master, but for me, I like this aspect. Indeed, with C++ you never stop learning. I just finished reading a book that discussed some very clever and innovative generic programming paradigms that would be impossible to implement in a language such as Java (Modern C++ Design: Generic Programming and Design Patterns Applied http://cseng.aw.com/book/0,3828,0201704315,00.htm
I've used Java a lot, it has its uses, but C++ has more features and is open. Remember guys, Java is a closed proprietory language controlled by Sun.
First off, gently tell your boss he's nuts to choose an implimentation language or environment by that list. Second, use C++. I don't like it, I don't know many that do like it but it is the standard. When the project is old and dusty there will still be C++ people who can hack on it. When you hire a new programmer, it will be easy to find one that knows C++. When your boss complains that the language and IDE's may not have all those features built in then explain to him that it is more valuable to have competent programmers with "good" tools than idiot programmers with "excellent" tools. If your boss can't see that using either C++ Builder or VC++ for Windows or the myriad options (GCC!) available for UNIX and kin then he isn't the least bit practical and you have to try to get someone else to grandfather a decision into your workgroup (e.g. a higher up boss says: You will use Borland!).
If you truely feel in your heart that your project would better benfit from Perl, Python, Java, Lisp, etc. and that benefit would last the lifetime of the project then make the case for that language or environment to you boss.
That laundry list of features is a bunch of bologna. Be practical.
I'd say drop that requirement and go with Smalltalk!! Post a few questions to comp.lang.smalltalk to get more details. It's proven, reliable, syntactically very easy and there's smalltalkers available to staff up with.
Why spend time solving language issues when you can solve the problems people are paying you for?
Just my cents: 2.
managers...why god invented purgatory
" Operator overloading is just fine. As long as you follow the logic of the other uses of the operator."
Exactly. That's why some places have code-reviews - insane uses of overloading can be caught early and the culprit educated.
Python.
Check it out, you won't be disapointed.
*wave*
for functors, allowing you to write generic code (OK so generic OO but it's still cool).
it's object oriented, operator overloading, function overloading, multiple inheritance, garbage collection, portable across various platforms (more so then java), no need for abstract classes 'cause of the way the language works but I guess you could have it if you really wanted to.
Interestingly I make my living providing this type of support to organizations. So here is my standard lead in... "There is no silver bullet." Okay, it is cliché, but it is so for a reason. No product does everything for everyone all the time. Those that get close are often ineffective because the overhead of running them is unexpected costs (system resources, training, or response time).
Are you planning to retrain your team to the tool and language of choice? Have you prepared for the cost and lost time due to incorporating a new tool and language? Are you prepared for the "first timer" punishment or will you be bringing in experts? Do you know how to tell if they are experts? Can you identify the difference between a consultant and contractor?
You mention support for multiple-inheritance. Some people argue that if it exists in an application you did not understand what you were doing. Are they correct? How would you know? "portable (at compile-time) across various platforms." Do you know which platforms? Across Linux, SUN, and AIX will be a different list than across Windows, AS400 and MVS. Support for "advanced error handling" and "advanced object oriented design". How would that differ from "standard" version? Does your organization understand how to weigh these features against their long term support and run time costs?
My experience has been when people ask questions like this, the building is on fire, and they hope someone will have a "tool" to fix a project that is 15 months behind schedule and $3 million over budget. Even if that does not describe you today, it may in 24 months. Determine your project feature needs, consider where you want to be in 5 years, look at the resources (people, $$$, hardware, software) in both cost and availability. These determine your potential for success. Then try to match products against the project.
If this describes your organization and you are taking this approach I strongly advise reading Rapid Development : Taming Wild Software Schedules It will provide the hard data to show your organization why you cannot tool out of a project issue.
When the time comes to choose a tool, the significant key is choose something that does not lock you in to anything. As you saw in your initial scoping of products, something will always be better in one product over another. Just avoid the position that a tool vendor must survive for your company to survive.
That's the way to go!
What platform are you planning to develop for? Your description of the constraints imposed imply that the project itself is secondary in importance to the tools being used. Objective C might fit your bill with some adjustment, although C++ is also a pretty good fit and Python mostly meets your requirements. It sounds like you want to tie the project to a single language. . Does performance matter? What environment will you be running in, ie, large enterprise or hidden in a closet somewhere?
If my boss came at me with such vague requisites and no real game plan beyond what language to use, I'd give him a snooty lesson in computing science and good business practice, demand design parameters, then specify ASM for the job. Pointy-haired bosses deserve no respect.
However, operator overloading is simply syntactic sugar and can be supplied either through an advanced IDE (I may look at jEdit to see how hard it would be to implement there) or through a preprocessor (jpp is one such preprocessor, though it seems hard to find on the net these days).
When doing operator overloading, it would be good to eliminate temporaries if possible. If a 'c' array object already exists before the assignment, it would be nice if "c = a + b" generated "c.assign(a.plus(b))" rather than the naive "c = new Array(a.plus(b))", which causes heap thrashing and unnecessary overhead. My guess is that this kind of optimization would be easier with an IDE type approach. (I hope that made sense!)
299,792,458 m/s...not just a good idea, its the law!
Galileo: "The Earth revolves around the Sun!"
Score: -1 100% Flamebait
Any temporaries in something like A = B + C will typically be optimised away if the operators are properly written.
More significantly, some of the most advanced techniques in C++ (expression templates) use operator overloading for precisely the opposite effect, leading to some of the most efficient output code of any language going. It would be possible to achieve this without operator overloading, but it would rely on the programmer knowing exactly what he was doing. With operator overloading, the class designer can do the hard work, and the programmer just uses + and * as usual, getting great output without having to know why.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
I think someone (probably more than one) mentioned the Cocoa development framework for Apple's Developer tools. This will only work for Mac OSX development. BUT, the cocoa framework is simply a slight reworking of the NeXT Openstep programming environment, which has no such platform limitations. I would look into it, because the Objective C language extensions and Openstep frameworks actually fit what you asked for pretty well.
I think your boss is either pulling your leg or a complete numbskull. Franky, it sounds as if he listed every buzz-word in his vocabulary and then said give me something with one of all of these.
I think you need to look at the product you're building and decide what features you need or want to build it. I would recommend thinking more along the lines of what do you need at a minumum to complete this project. Using features just because they exist or sound coool is the road to hell. You need to understand what these tools are for before deciding to use them (or not to use them) and clearly your boss has no idea what he's talking about.
I recommend you get an idea what the project is about and try to lead him down the right path, ignoring his uniformed request.
emerika
Umm..no Coaco!
Aren't these the exact goals of Kylix? I haven't used it myself, but from what I've seen it is an intuitive programming language suitable for general application development, with a nice GUI system.
-John
Yes, actually, they can; see "expression templates". I don't know of any major library implementation that currently does this, but the leading ones are all looking at the possibilities.
That's not true either, I'm afraid. Modern string implementations now use much smarter allocation strategies to boost performance well beyond a naive malloc/free approach. There are a few dragging their heels, but it's unreasonable to judge C++ by its worst examples.
That's rather unfair; this is a quality-of-implementation issue, and C++ library developers haven't included the state of the art tricks in optimisation across the board yet. Play fair and give them a year or two; C has had a couple of decades' head start, after all!
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
BASIC.
Assembler.
Your list reminds me of a statement that can be applied to cars (and most other things including software.
Fast, Cheap, Good
Choose 2 of 3
While I have a personal bias (Java) I'd suggest taking a step back to evaluate/group the requirements: business, technology, total cost of ownership, existing development skills, operational infrastructure etc.
.NET, HyperCard and Java all began with strong business justifications in addition to technological. This puts more responsibility on the engineer to understand the problems the languages are solving from the customer's perspective. Lastly, I'd strongly recommend adding one final evaluation criteria: the availability of libraries/components, etc. which can be integrated into the project to limit the amount of custom development. In many cases this will have a much greater impact than the language itself.
It easy to see why a customer would care about the platform requirements. The development team may care about the IDE. Your company may have already spent $500k on AIX that they'd like to continue to take advantage of. The project itself may benefit or be hindered by using garbage collection because of its uptime or concurrency requirements.
The most critical factors that I would use to select a language would be, in order of importance:
1. Meets the business requirements
2. Leverages existing skills of the existing team
3. Leverages existing infrastructure (hardware and software)
As an aside: you can benefit from using something you know well even if it isn't the "perfect" solution just because it is less likely that you're going to make a novice mistake. There's plenty of software that I've written in Java even though it was easier to write in Perl just because I knew I'd get it right the first time using something I knew well.
I share the opinions of many others on this list that operator overload is both a useless evaluation criteria for selecting a language and generally a bad idea that causes more problems than it solves.
As the field of software development matures I'm finding that the languages themselves are starting to align with different business initiatives. ADA,
Sig:Why copyright isn't a fundamental human right
One language environment that has all of that, (though it's not very good for creating optimized code that has to execute a lot of calculations really quickly) is REALbasic. (I hear the groans) RB is not the most powerful language for calculation heavy programming, but the language does support everything you mentioned, and the IDE is about as easy and intuitive as you can get. If you don't need speed demon development, look into it.
In a production system, you are probably only going to spend 5 to 10% of your total time coding. Something that doubles or halves coding time may only add 5% or subtract 5%, respectively, to/from total project time.
Most important language traits (to me).
So, frankly, Ruby is probably a better language than java. But java wins on four of my five criteria and ties on the remaining one. I wouldn't try to deploy a system right now with anything other than java or C++, unless it is going to be a very small project, or you are brave. :)
Unfortunately, many of the people who promote using various obscure languages have good results just because they are very intelligent people. Unless you are really really smart (and I know that I, for one, am not), you might just want to stick with the herd. :)
Jack Valenti and the MPAA are to technology as the Boston strangler is to the woman home alone
I've been working in PHP and Perl for about a year and a half now, and all my university classes are all taught in Java. While there ARE regex libraries for Java, they aren't standard, and therefore aren't used when testing student submissions. I find myself pulling my hair out time and again when I run up against a problem that could be solved easily enough with a regex, but requires, due to the language, that I solve it the hard, long-winded slow way.
If you're gonna write a new language, make regexes native!
The best language of all is Common Lisp.
99.9% of you are too g8dd8mn dumb to understand it.
That was all I had to say, goodbye you sorry a88 punks.
way nobody says Delphi?
One more thing about the language which may be a drawback for you, the programming environment only works on a mac, BUT it automatically creates the code to run on windows, too. So if you don't mind working on a mac for programming, you can quickly develop cross platform apps.
Ada 95 is Object Oriented, has operator overloading,memory management and all the other buzzword compliant stuff.
Of Course, if you actually use Ada 95, you probably need your head examined...
Jono
I thought both the Java compiler and the JVM were written in C.
"It take 9 months to bear a child, no matter how many women you assign to the job."
BTW, the ONLY languages that cover the entire set of design criteria listed are Allegro Common Lisp by Franz, Inc. or LispWorks by Xanalys. But something tells me that your boss isn't interested in hearing that answer, either.
That is all.
Rather than looking for a buzzword-compliant language, might i STRONGLY suggest that you read "The Pragmatic Programmer", by Andrew Hunt and David Thomas? The clear, solid, *useful* ideas in that book will maybe, just maybe, cure you of your faith in buzzwords - or at least your willingness to blindly march over the cliff your PHB just sent you to investigate.
Language features will not in and of themselves make for a successful programming project. I'd argue that they're merely a convenience for good programmers, and often and impediment for poor ones.
That being said, look at a multi-language approach to development - an interpreted scripting language (Python, Perl, VB(ewww)) mixed with a stricter compiled language (Java, C++(ewww)). And don't forget SQL, which is a respectable language unto itself, and very important if your project involves a database.
Good luck, and may the God Murphy Goddess Eris have mercy on your soul.
Hand me that airplane glue and I'll tell you another story.
[Sorry about the ugly plain text formatting, but it's sometimes the only way to get code examples in properly on SlashDot.]
:again
:again))
,expr) #'(lambda () ,@body)))
I hope it's obvious to you how inferior this is. The real while loop doesn't require you to package up your test and body as a function. When you do that, you have introduced a problem of context, which breaks the abstraction.
By the way, in Common Lisp, you CAN implement the while loop as a function, and yet provide it as a ``language-level'' abstraction as well. Here is how:
(defun while-func (expr-fun body-fun)
(tagbody
(cond
((funcall expr-fun)
(funcall body-fun)
(go
(t (return-from while-func (values))))))
(defmacro while (expr &body body)
`(while-func #'(lambda ()
So you can now write something like this loop, which prints numbers from 0 to 9:
(let ((i 0))
(while (< i 10) (print i) (incf i)))
Note how the while body can still refer refer to the local variable i, even though our implementation choice was to package up the expressions and use a function. This is the crucial difference, which sets this apart from the solution that uses functions only. Nobody would use your proposed while loop class, because they would have to carve their program into functions in a completely stupid way, with no access to local variables. Even if you had closures in the language, people wouldn't use it; if you gave a Lisp programmer the above while-func only, he or she would find it necessary to invent the while macro to actualy make it easy to use.
Now to respond to your comment:
> But since there's already a built-in while, what was with the stupid fake example?
Sorry that I touched some sore nerves. I just wanted to pick a very simple example of an extremely simple control abstraction that cannot be implemented in these languages; it's not relevant that they already have it, because the implication is that it's impossible to make other abstractions that they do NOT have.
>What are you trying to prove? That these languages are geared towards efficiency and
>readable syntax instead of generalized object-oriented programming? Well, if so
>you're right.
Not at all. The point is that they have limited abstraction-making ability, because you are stuck with one rigid syntax. I won't respond to your remark about efficiency, whatever you mean by that. (Execution efficiency? Programmer efficiency?)
When you have a rigid syntax, the language is good for certain domains. When you try to solve certain problems, though, the rigidity will get in your way. You may have readability at the microscopic level, due to the use of a small repertoire of built-in syntactic forms, but that readability will be drowned in the morass of code that you will have to crank out. Remember, assembly language is readable too. You have a few instructions, a few addressing modes and everything is in nice columns. But once you crank out a large body of assembly language, it may still be readable, but it's not *grokkable*. Whereas the corresponding C program may be quite grokkable.
Sorry, but you've got me completely there. How is the result in any way "unspecified"? (Please don't throw Mickey Mouse arguments about overflowing at me; I won't be impressed.)
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
AMEN TO THAT. Someone mod him up +1 zillion insightful.
Java is a language for typists, not programmers. one brain, many code monkeys.
Looks like what you're actually looking for is Common Lisp.
Keep in mind that like anything else, in software development you need the right tool for the right job. If your looking to create a cross-platform application with a mature and well supported tool-kit, then I would say look at the Qt cross-platform application framework library from Trolltech. Most people here will be most familiar with Qt as the library that KDE was built with. If you are coming from a Win32 background, Qt can be compared somewhat to MFC. Except Qt is MUCH MUCH easier to use (I've been part of a couple large projects that used MFC, so I understand it's many pitfalls). Qt is portable across Windows, Linux, and Mac. It's on version 3.0 so it's mature. It has a free evaluation version, so download it and give it a try. For Linux (I've only used the linux version so I don't know if there is a Windows version, I've never looked into it) there is a GUI IDE that makes application programming using Qt with C++ just like Visual Basic. In so far as, you drag and drop your controls onto your template app, then add event haddlers and whatnot.
Now... let's discuse my consulting fees.
Treknetix, for all your coding needs
Check out my podcast: DreamStation.cc Video Game Show
You are really asking somethings that really is impossible to answer unless you are much more specific about the project you are to implement.
Some of the requirements rules out each other when coming down to the different languages. The only language that really seem to fit you descriptions close is C++ and then you'd have to select a GUI toolkit to go with.
You havn't said much about what the average experience of the developers on the project, how many there are and which platform they will be running their IDE on. If there are many that run windows it would be wise to go with ( f.ex ! ) Visual C++ as it has a basic IDE. Porting to different platforms could be done by some of the more experienced developers.
On the subject of porting, C++ is really terrible if you want to use language support for large scale project. Mozilla has quite a few notes on this, dont't remember the URL but I'm sure you'll find the page on their homesite.
I also find it very disturbing that you mention all the hyped up features of languages. Please note that a computer language exist to solve a problem and different languages have different solutions to them.
Another interesting rumour I've heard ( very unconfirmed so take this with a grain of salt ! ) is that Lockheed is to build Joint Strike Fighter with C++ as the main language. The reason seems to be that there isn't enough Ada developers out there ( shame on you ! ). This might be a consideration if your project is big enough ( welcome to the real world )
As a little round up : you should try to concentrate on the functional specification of the problem and try to come up with a prototype design. Then you will probably get a good idea which language to use. If you don't have a history in your company ( or whatever org. ) with a language you are best to put of this decision for some time. Not too long, then it become a risk item ! Remember that it takes alot of time to train developers in new languages if they tend to among the average.
Good luck, you'll need it !
What is it that is so efficiency-enhancing about IDEs? Not a troll, am really curious.
I think I would consider getting another job if my boss forced me to use something other than vim for my coding. I have heard that vim can be used within some IDEs, so that might be acceptable. Any info on this?
...the job to be done is properly defined. It probably has to include maintenance, provision for the programmer's leaving the company, and so on. In other words, it's more than just performing the task at hand, it's the long-term objective that the tool you're creating is trying to achieve.
"Biped! Good cranial development. Evidently considerable human ancestry."
The real question is: How do these arbitrary requirements tie to anything that actually matters to a stakeholder? Start off with, "Why should we build this thing?" And move from there.
Requirements like "including multiple inheritance" or "operator overloading" have nothing to do with the usual reasons we build software and should always be questioned. You should go back to your boss for clarification on how these features are expected to add value to the project. His reponse might be an actual requirement if you make him be specific. "Such as the system will have to be reused by ignorant monkeys." In which case you can suggest that only COTS (Commercial-Off-The-Shelf) software be used.
The only exception to this rule is if you are currently working a government project. (Which is what this sounds like.) In which case your boss has already made the decision to buy not build and is stating this in language sure to make procurement agree with him.
[-- Trust the Monkey --]
Believe it or not, PHP might be a good option on a technical level. There are a few really nice IDEs available for PHP, and with the new release of PHPGTK, its really shaping up to be a good all around programming language.
Skiers and Riders -- http://www.snowjournal.com
Still, given your feature list, CommonLisp may be your best bet (the CMU CommonLisp implementation for Linux is pretty good). It's a very expressive language and compiles into reasonably good code, although it doesn't have much static type checking, the language definition is messy, C-like performance can be hard to achieve, its C interface is a bit cumbersome, its libraries are less than stellar, and its user community is tiny. Bigloo, a compiler for Scheme, interfaces more nicely with the rest of the world and generates reasonably good code, but lacks threads and has a less expressive object system.
If you want something statically typed, O'Caml is a great language, combining object oriented and functional programming. It generates good code and interfaces reasonably well with C. However, you don't get overloading.
For great libraries, reasonable performance, and good standardization, Java can't be beat, but the language itself can be a little tedious. C# fixes some of the tedium of Java, but its libraries and performance are nowhere near as good yet, and it's pretty much Microsoft-only for now.
And don't forget about C++. For complicated numerical algorithms that need to run fast, there is nothing better than C++. For complicated GUIs, and interactive applications there is almost nothing worse, however.
So, overall, there just isn't a single answer. Every language is an engineering tradeoff. Learn many of them, and you will benefit both from the experience and the choices you have.
Trying to sound as unbiased as possible: I would have to say that C++ would most closely match your requirements. To make it match more closely. Use C++ builder which has Cross-Platform support for Win32 and Linux. It also has a very advanced IDE and API for Rapid application development including extremely quick creation of GUI's. It also has a great event handling framework.
stdcallsign
... "Ask Slashdot" to be renamed "Bait Slashdot"
Screw you all! I'm off to the pub
Ruby!
All of the above in sensible doses. Plus it's more fun. And a prettier colour. (-:
BTW, XP isn't a cheap ripoff, just a clumsy one. I suspect that the TCO will work out noticeably worse than WinME. Windows started life without scaleable elevators (to pick a known example) because one William Henry Gates III told the developers to take them out again so that it looked more Mac-like. Dilbert of a few days ago is fitting commentary.
Dons asbestos undies, prepares to duck...
Got time? Spend some of it coding or testing
Here's a language idea: "SE", short for "Supports Everything". And if you want more, call its successor "SE++".
No data, no cry
Get good programmers, get their input on your implementation language and tools, declare whatever you decide upon as your shop's standard and get to coding.
I'm trying to teach myself to set people on fire with my mind... Is it hot in here?
I'd definately go for GNU-Script.
Now, just click that link, and you won't even have to make the choice any more. GNU-Script does that for you.
May we live long and die out
"Fashionable programming languages don't equal useful software" - Eve Andersson
Slightly off topic..... but not at the same time....
-Tripp
Ada95. Only missing the MI thing (and maybe the IDE, but that's irrelevant, IMHO).
All the other posters have pretty much nailed your problem: The Boss(tm) is specifying implementation, not requirements. You need to determine what you're trying to do before you actually spec out the language(s). And <AOL TYPE=ME-TOO>your boss is simply throwing in every single buzzword he's ever heard.</AOL>
Further, who says you need only ONE language: Example: in a previous life, we had to do some Windows code, using a custom third party ActiveX control. Hence, we did the UI in VB, and the backend code in C/C++.
Fascism starts when the efficiency of the government becomes more important than the rights of the people.
I know about expession templates, and also know why they are not used in std::string. The allocator I am not worried about - if there are no unnecessary temporaries, then there is no need for unnecessary allocations. However, at this point, many stl's are still doing this.
So, in summary, yes now it is slower but maybe not in the future.... Is that fair to say? Does that mean c++ is not ready for prime time? of course not, I use it all the time. But you gotta know when to forgo the syntactical sugar that causes c++ to be unnecessarily slower than C (even when the C is coded safely).
--jeff
ipv6 is my vpn
It's like walking into Home Depot and asking the contractor's desk, "Excuse me! What's the best tool?"
;)
.... using Qt with C++ doesn't have one point on your list of criteria that i failed to mention: No garbage handling, because no mananged environment. But real programmers delete their own allocated memory.... right?... err.... ok... nevermind.....
Check out my podcast: DreamStation.cc Video Game Show
What a pain in the ass. I click the box to filter out "Ask Slashdot" posts, then Cliff goes ahead and files this under "Developers". Thanks a lot, Cliff.
...I'd #define away their ridiculous verbose names into something short and memorable ...
Instead of writing unreadable code, maybe you should check out a new text editor. If you start using xemacs, for example, you can use Meta-/ to fill out the rest of a word. So, for example, if you have ever typed the word "SimpleDateFormatter" and you want to type it gain, you can type in "Simp" and the editor fills it in for you.
While I agree that a preprocessor would be useful in very, very limited circumstances, introducing things like "I don't like the name of that object so I will #define it to something else" is exactly the reason java doesn't include one. We don't want each developer to make up his own standards, much less his own names for things.
-Mike
Folks seem to be missing sheer idiocy and irony of this.
.bombs (and I assume this company is now on that shortlist) who could fill endless pages with buzzwords sometimes without actually knowing a thing about anything.
We have a CLASSIC boss who just wants to be buzzword compliant. I mean, look at that list. Reminds me of all the
So make *SURE* your boss who is making these technical decisions really has the CS degree he has to have to make them.
There are countless books out there on doing it right. Some key points are:
- Reuse knowladge of your team.
- If you think starting from scratch with 300 buzzwords will make a better product, think again.
- Reuse work that has gone before. If you've listed every major language and found they don't have what you want, perhaps there is a reason. Perhaps folks who designed Java/C# actually thought for a few minutes before they designed the language.
- Boss can make the decisions about goals, money etc. Make sure the folks making the technical decisions are stakeholders (ie, have to live with it). Why is the boss making this vs the lead developer. He'd better be the guy who'll be coding the most.
- If you specify the tool you're going to use before laying out the problem, if you pick a hammer you'd better hope the problem is nailing nails and not playing Bach.
- Give standardized/open source languages a shot (C++/C#/etc) before propriatery (Java etc). - They've renamed Ask Slashdot to Ask to Be Called a Fool. Why? Because folks posting in tend to be. You'll get great advice though, especially with respect to programming/development.
Sounds like this company is virtually certain to built the garganutan pile of multi-inheritance pile of crap folks who end up having to maintain will loathe. I happen to dislike multi-inheritance except for a relatively limited arena of problems. That's just a personal opinon though.
Well Delphi might fit your bill. It offers Multiple Inheritence, Object Oriented reusable code. Plus has the advantage of being able to be compiled with Kylix so you can run your app on both a windows an linux machine.
It may be just me, but after readint hrough the list of replies, I didn't see Delphi suggested anywhere...
Delphi has many, if not all of the language features that were requested. I've programmed in Delphi for a good 5 years or more, and other than the general lack of enthusiasm for the language which seems to be so widespread, it has always been my favourite. It allows rapid development with minimal overhead, and one of the coolest features I think, is the way it packages the final project. In most cases you can develop applications which have nothing more than just the executable.
Give it some thought, its one of the most commonly overlooked languages as of late... but one of the most powerfull on the market for rapid application development...
Thomas A. Knight
Author of The Time Weaver
You don't want a powerful programming language unless you have a significant budget (say, $2000 US and 1-2 months per person) to train all the would-be developers. The biggest problem with C++ is how little of it most alleged "C++ programmers" really know about the language! Java may be no better. (Larry O'Brien: "Claiming Java is easier than C++ is like saying that K2 is shorter than Everest.")
If I was picking a programming language from scratch, I would pick a very simple language, such as Python (which actually meets most of the boss's criteria) or Smalltalk.
Like most everyone else, I advise you to ask the boss what he really wants, or at least what's behind his wish list.
Stupid job ads, weird spam, occasional insight at
You forgot to mention that with strcat, you are responsible for buffer allocation/deallocation.
For C++ you can write
--------
std::string a="hello", b=", ", c="world", d=".";
std::string e;
e.reserve( a.size() + b.size() + c.size() + d.size() );
// or e.reserve( SOME_APPROPRIATE_CONSTANT_VALUE );
e = a;
e += b;
e += c;
e += d;
std::cout e std::endl;
--------
Modern C++ implementations wouldn't create a temporary in this case because the target buffer has already been made large enough for the source data. The only reason you don't have to worry about it (and strcat seems faster in your mind) is that you have already made the multiple calls to strlen to make sure that the target buffer is large enough or you have chosen what you consider a large enough target buffer (which is subject to buffer overrun errors in some circumstances).
And it's still easier to use than strcat. AND this probably isn't your program's hotspot anyway. Premature optimization and all that.
- I don't need to go outside, my CRT tan'll do me just fine.
Is anything sufficiently complex enough to emulate any other language. Roughly this is the Church/Turing hypothesis for maximum expressibility... if you can't express another language, then you're language isn't very powerful.
People who quote themselves bug the crap out of me -- Me.
Well, anything that can be implemented in a HLL can be implemented by writing machine code.
But we like higher level constructs.
I have a dream, that one day people will know what they are talking about before they spout off like morons.
autopr0n is like, down and stuff.
I've worked on several projects that were coded in multiple languages ... whether it was a client coded in Python and a server coded in Java, or a series of programs coded in C++ and Perl all tied together in one big Perl script, or whatever.
Given the criteria that you laid down, I'm not sure that ANY language will meet your criteria. However, you might want to explore using a combination of Python and C++, where you use Python to do the majority of development (including GUI development) and C++ to write the 20% of your code that runs 80% of the time. GUI development in Python is a snap, and it gets even easier if you use GLADE. The one major disadvantage to this technique is that you don't have a single, simple IDE; you may end up with two IDEs, such as Visual Python and Codewarrior C++.
Just my two cents, probably worth less than that.
Finding God in a Dog
"Java 2" has been out for quite some time. Ever since JDK1.2 was released with a hugly expanded API. It goes like this:
JDK1.0 - Java 1
JDK1.1 - Java 1
JDK1.2 - Java 2
JSDK1.3 - Java 2 (JSDK = java standard dev kit, but everyone still calls it JDK)
JSKD1.4 - Java 2
etc...
autopr0n is like, down and stuff.
Use PowerBuilder! hah. Right.
Use it, use PHP.
Use PHP GTK for GUI/UI, use PHP-SDL for any gfx/sound.
bye
"If you were to design a language from the ground up, what features would you include and why?"
Easy. My language would have only have three commands:
DEFU string -- define who the user is
RUMM -- read user's mind into memory
EXECM -- execute program in memory
The programming language is flexible enough for all needs. For instance, your ideal programming language would be implemented as:
DEFU SlashDotPoster
RUMM
EXECM
This program executes in 1s (the bottleneck is the RUMM command since there's a lot to read).
The program that you show sales and marketting would be defined as:
DEFU SalesAndMarkettingPrototype
RUMM
EXECM
This program executes in 1s (the bottleneck is the DEFU command since marketting doesn't know what they want. Reading the entire contents of their minds into memory should be instantaneos since there's not a lot to read.).
The product that you actually ship would be:
DEFU WindowsUserWhoEnjoysRebootingRandomly
RUMM
EXECM
This program executes in 1s (the bottleneck is the EXECM command -- rebooting takes quite a while, especially if you have RAID and SCSI).
Say you have: ComplexNumber a, b, c, d, e, f;
. add(b)))))
Would you rather have:
((a^b+e)/c*(d+b+a+b)
Or
(a.power(b.add(e)).divby(c.multiply(d.add(b.add(a
autopr0n is like, down and stuff.
Honestly, to me it sounds like the original question was a hypothetical one. If somebody actually did have a boss that laid out the "requirements" of a project in terms of what fancy buzzword features the development environment would support, then the project is doomed to fail.
The requirements need to be in terms of: what will the user interface look like? Is it client server, standalone, what kind of network communication is required, and basically everything else involving what is this application supposed to do? If you don't know any of that, it makes no sense to even pick a language.
This is like your boss saying he wants you to construct a bridge, and you have to pick ahead of time whether your bridge is going to be a suspension bridge, cantilever bridge, truss... well it's kind of hard to make that decision if you don't know how high or long the friggin' thing has to be, what kind of load will be travelling over it, and whether you're gonna be going over water. If you pick the wrong technology for the job, your project will go way over budget and the developers will hate every minute of it.
-CausticPuppy "Of all the people I know, you're certainly one of them." -Somebody I don't know
I have used C, C++, Java, VB (pre .NET), Perl, Python, and LISP. As far as I know, you are correct in claiming that none of these languages fit all of the criteria.
Your boss seems to be very buzzword aware. Did he cite any reason for needing the various criteria? I have only found a reasonable need for multiple inheritance in a project once. And as for operator overloading, it's just sintactic sugar. It's nice, but certainly not a necesity.
As for easy to use IDEs and simple GUI design tools, C++, VB, Java, (I'm sure C# too, but I haven't used it) all have them. By simple event handling I am assuming your boss meant GUI events, which any language with a simple GUI design should have (if it doesn't, it's not a simple GUI design).
As far as abstract classes are concerned, any OO language has them, or else the language is not really OO. VB 6.0, by the way, is not really OO (VB.NET may be, I'm not sure). Function overloading (or polymorphism) is also part of any true OO language.
As for portability across platforms, your choices have been severely limited. As far as I know, the only mainstream OO language that is cross platform is Java (again, this is only as far as I know).
Garbage collection is not all it's creacked up to be. Yes it will return memory for you, but not other resources (such as closing files, sockets, etc.). Also, in Java anyway, you CAN'T force the cleaning of memory since there are no destructors, so you just have to wait for the garbage collector. The lack of destructors also makes the cleaning up of resources more difficult.
I would recommend gaining as much insite into what problem the project will be solving. Once you know this you can weigh the value of each of the criteria, and choose the best language for the project accordingly.
Hope this helps in some way. Good luck.
Sig free since 2/6/2002
Smalltalk has all of the features your looking for, unfortunately, it's an interpreted language without much support for integration with modern technologies (i.e. cgi, sql, etc).
Is this application going to be a gui only application or will there be some large domain object model (client or server side) driving the application ?
From my experience with large scale OO systems the complexity of the domain model and its interaction with the gui views (e.g. corba/messaging/relational mapping etc etc) becomes the most complex part of a large dynamic system, to the point where the gui becomes irrelevant.
If this is the case I would also concider whether the choosen language is going to sit nicely with the persistance layer you choose, and also another point overlooked; what constructs will the language provide for implementing your object model (for example I prefer the template based C++ collection classes to the everything inherits from Object hetrogenous (read cast!) way that java handles collections). To often I have seen that the bulk of the complexity in the implementation model come about because the language, libraries and persistancy layer do not allow an easy mapping from the conceptial model. Not what you want when you are modelling a complex domain!
Just my 2C
--
Nic
Suppose we have to develop an OLTP. What happens when number of tables becomes several hundreds? How to maintain forms designed two years ago? What happens when the logic fails to behave in the expected way because of being overy complicated? No language will help you when it comes to dealing with the good old enthropy. Now forget OLTP.
The problem is that as soon as development begins, the idea of what needs to be developed is being gradually replaced by how the things are being done. The declarative meaning gets lost for the sake of imperative implementation. It is quite uncommon that the rules of how to get "imperative" from "declarative" are not being lost.
My personal opinion: never try manually coding the entire system. Use automation where possible.
My personal belief is that Objective Caml is one of the best tools to make generators of all sorts. It is not that it has any unusual features. It is very simple, has very little caveats of any sorts, and powerful enough. As soon as you fix typing errors, you risk getting the right code (assuming your mind is clear enough).
People always think about AI when they think of Lisp, but don't forget that some everyday applications are written in Lisp, such as Yahoo! Store.
The antidote for misuse of freedom of speech is more freedom of speech.
-- Molly Ivins
The question is so vague, it could only lead to the flame wars. Seems that ~581 people fell for it so far. You bait us telling us you have a stupid boss that wants you to find or create the perfect language.
...
The "brilliant" slashdot community spends the rest of the time flaming the daylights out of each other. Java is the best, no C#, no C++, no Perl,
Nice fake hotmail account too. Why don't they just ask us the question what features do you think make up the perfect language. Even posting this is a waste of time!
Although I am a ruby fan I have to point out that ruby doesn't have multiple inheritence per se. This is because Ruby, like small talk, is a true object oriented language. Since everything is an object, inluding classes, multiple inheritence doesn't make sense. You do however have modules which can be used similarly to multiple inheritence but u have to seperate instance and class methods into sepereate modules. I do beleive however that most problem solvable by multiple inheritence have better solutions without them. Just my opinion.
how about some more page widening. people seem to like thay a lot.
Features don't make a language power; programmer creativity and insight make a language powerful.
And to that end, the only thing truly required from the language is execution speed.
javac is written in java. IBMs "jikes" is a java compiler in C, which is why it is so much faster.
Yes, I think so.
Always the way... It's important to realise that this is a quality-of-implementation issue, though, not an inherent limitation. In a better quality implementation, you might find that the combination of +s was actually better than strcats, because a well-written template to do multiple concatenations could get away with a single memory allocation for the result, instead of the 4 required by strcat here.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
Forgive the comments of a lowly CS graduate student but I've been working as a developer for 4 years now so here goes:
The reason that there is not a language that supports all these requirements is that the desired attributes work against each other. An intuitive and easy to use IDE can restrict your programming to predetermined paths and may result in bulky non-elegant solutions. This works against the desired OO requirements - multiple inheritance, abstract classes etc. A simplified GUI design will likely result in Screens and Reports that are boring and don't meet the customers desires. I've also seen this result in very busy screens presenting too much informaton and choices to the user. Portable means you give up (or it becomes very hard to use) all those capabilities the customer may be expecting ("I really do want the report in EXCEL!" - means you may have to license EXCEL on the server, learn how the API works, and write special business objects, plus know what version the client expects...). Operator and to some extent function overloading works against good structure and may make the code not maintainable.
We use JAVA with SilverStream for our IDE and Middleware. It does both Forms and Pages. We use ORACLE for the database. Initially we thought SilverStream would save us development time but we found we had to build the database directly using SQL PLUS because of syncronization of the code database with the data database schema didn't always work. However it works perfectly with Sybase. We had to write alot of code behind each event because the simple actions were just that, too simple. We had to write report generating modules because the Dynamically generated HTML pages didn't satisfy our customers. This caused us to compromise on the cross platform requirement. They insisted on WORD compatable formats (RTF) or non-mutable (I know its not a word) PDF formats. We have just now found a spell checker to integrate into our apps. However go ahead and check out SilverStream. Despite its draw backs I believe it is the best cross platform development environment. By the way I don't have any stock or interest in SilverStream other than that of a developer. Anybody else think JAVA with SilverStream might meet the Boss's requirements? Anybody have experience with other IDEs (WebSphere etc.)?
Supra et Ultra
Dylan does all that. And you can add multimethods (much more useful than many of the things you mention) and solid functional programming.
There is an excellent windows IDE (www.functionalobjects.com) and an open-source compiler that spits out C (www.gwydiondylan.org) for unix-like OSes.
But the arguments above that you don't want to use an obscure language are correct -- unless you're developing a game. Then you can use any obscure technology you like, because you just do the thing and ship it, and do a few updates, then in six months everyone has forgotten it. Look at how many games are written in UnrealScript. Dylan would be great for that.
I wouldn't call Ruby Python's successor. There are lots of features part of Python which have no counterpart in Ruby.
These languages believe " The programmer knows best", for example, neither of them prevents 'free floating ' functions, so the programmer does not need to pack all his code into classes, in C++ garbage collection is not mandatory but it can be simulated, so C++ can squeeze most of the performance of the hardware ( needed in, say, realtime systems). I don't really believe that one programming paradigm is best. There is no such thing as OOP is good and everything is bad, or that functional programming will solve all the world problems.Each of these technologies has its position in the world. I think these languages are mature ,real world languages, considering the fact that C++ is based on C, Delphi is based on Pascal, and Ruby was inspired by perl.
Eiffel fufills all the requested features except for function overloading. This is considered a feature. According to the FAQ, the reason for this is that it improve's the compiler's ability to catch type errors.
I've never used it, but I saw Bertrand Meyer give a demonstration of the IDE recently and it looked pretty slick. An interesting feature included the ability to generate code from all diagrams produced with their tool, and vice versa.
The tools provide alot of cute little niceties, but some programmers may not like it's "enforced" way of doing things.
Well, there is no operator overloading, or mult inheritance. But, it has a powerful exception system, and cross platform support on some vendors.
.NET enabled.
VisualWorks was one of the best, for a long time, bit identical on many platforms, platform neutral UI system, that could be made to look/behave as the host ui by selecting one menu option...
Too bad visualworks is pretty dead now. Buuut.
There is a new Smalltalk imp, www.smallscript.org, which does add Mult Inheritance, and other features to Smalltalk. It's also
The base system is free, but they sell other add-ons too. The guy who wrote SmallScript is a old QKS smalltalk hacker and guru. Smart guy, and his system shows it.
Also, Smalltalk has one of the BEST builtin IDEs ever.
Daniel
I've used Ada95. It's got some really good stuff in it. Advanced OOP, error handling, easy to use, efficient. It's even easy to do operator overloading in it too. I know this is all easy to do because I learned it all in a first year intro to programming using it.
-- [insert sig here]
Sure, it's only a Windows/Linux solution but what do you think about Delphi/Kylix?
Read Larry's Apocalypses -- 1, 2, 3 and 4 -- to see what I mean.
~shiny
WILL HACK FOR $$$
I am building a house and would like to hire a contractor to do most of the work for me (my asm skills are fading). I interview 3 different contractors and ask each of them each "what tools do you use to build houses?" You see before hand I made a list of tools that a good contractor would use and checked them off as they told me.
Contractor A uses all the tools on my list except a nail-gun, says he perfer the feel of an old fashion hammer and claims hammering gives him time to think about his next task.
Contractor B uses all the tools on my list except uses a radial arm saw instead of a circular table saw (says a good friend lost a thumb with a table saw and will never use them).
Contractor C uses everything on my list except for some stange reason he drive Ford instead of a Chevy.
So which contractor should I use?
You !
;-)
You can do anything in mostly all existing programming language.
The only limit is you or your madness
The two things it doesn't have that you "think" you want are multiple inheritance and operator overloading.
:) Operator overloading is, in my experience, a real nightmare. To be clear: it offers you nothing functionally. It's a purely cosmetic feature. People often like to write a String or Matrix class with a + operator. Well, I take only minor umbrage with Java's special + operator functionality for strings - it hides the underlying work too well (one simple character = potentially a lot of VM activity) - but I can live with it. Otherwise almost every case where an operator could be used is in some way or another ambiguous. This is the equivalent of picking a one-letter function name, with the added bonuses of syntactic complexity and obfuscation with existing arithmetic and logical metaphors.
:)
Multiple Inheritance: People claim that this isn't a good feature, but I disagree. I've run into times writing Java code where MI just obviously would be the right thing to do. However, A) these cases are rare, and B) there's always a workaround which is almost as good as the MI solution. In trade, not having MI has the added bonus of making your code simpler to understand, but most importantly, preventing people who think they know what they're doing (but don't) from using MI to make a complete mess of your model.
Operator overloading: I left the best for last.
I've seen and suffered through abuses of operator overloading often enough to become convinced that it's important not to have it, so that less-than-gifted programmers will never be tempted to use it.
So I say again, unless you're doing anything inordinately complex with audio or video, use Java. Or use a worse tool, and suffer like everyone else does.
We're on the road to Tycho.
1) reference counting cannot handle circular references. Of course, C++ programmers hardly ever want to create anything able to handle such abstraction.
2) you have ignored any time performance. Reference counting adds overhead even if you never accumulate a significant amount of garbage.
Let ADA Do it! Use ADA! Speed of C or C++, objects, exceptions, reliability, US DOD certification!
No mixed mode operations. Explicit conversions. GUI binding libs. Multiple platforms support ADA!
Free & Commercial compilers. Multithreading built right in!
Damn! This sucks that there are so many comments already, this probably won't be read. Anyways.
;-) By the way, Delphi's interfaces were modeled after MS COM, and as a result COM programming is a HELL of a lot easier in Delphi than in Visual C++, including MS's stupid ATL crap.
I am sadened by the fact that nobody cares about Delphi, and that the only comments that mention Delphi aren't moderated up. I have used many languages (and I was impressed to see that this person mentioned looking at Eiffel, a nice language).
First off I have to say this, even at the risk of being flamed and called a troll. Either the geek culture is just ignorant, scared, or both. Stop feeling so insecure to the point where you have to use a difficult language to boost your ego. What I mean is try using a language that actually makes your life easier. I am so annoyed by these people who suggest C++. I have many years exprerience in C++ and let me tell you that it is not exactly your best friend on large projects, especially with coworkers who do not know the pitfalls of C++ programming.
Also, all you people suggesting ruby, or other new and/or obscure scripting languages, please give me a break. I like cool languages like Lisp and Snobol as much as the next, but I must admit to the reality that no real business and business project is going to go with these languages as the main development tool. There are some business that use Lisp and Smalltalk, which is cool. However, the reality is that the dominant language is C++, Java, VB, and maybe even C#. Stop suggesting languages that no clueless boss is ever going to approve of (cluesless bosses only know to use C++/Java, the buzzword language).
Now on to Delphi. Delphi is what you are looking for. First off, your requirements list is too unrealistic. You are going to to have to make some trade offs.
Delphi doesn't have operator overloading. Guess what? That is not critical. What's the difference between a + b and a.Add(b)? None.
Delphi doesn't do multiple inheritence. Guess what? If you are a good enough OO designer, you won't need it. Delphi supports single inheritence, multiple interface implementation style, just like Java and Smalltalk. So don't give that shit that multiple inheritence is needed, it is not.
Here is a quick OO design tip. I have noticed that C++ programmers like the multiple inheritence because they can have a class inherit from one class to gain capability, and then have it inherite from another class to establish communication (usually through an abstract interface). THIS IS A MISTAKE!! Golden rule of thumb, favor aggregation over inheritence. I am not going to exlpain myself on this (it would make this post too long). Take it from me, I have seen this in real projects, don't use inheritence to establish communication between objects. Use inherietence to vary state/behavior of a particular entity. Net result, designs such as these do not require multiple inheritence and are far more flexible and reusable.
Delphi is natively compiled, not like that p-code shit VB does. Delphi is made by Borland, which employs some of the brightest compiler designers around. Delphi is far more efficient than C++.
I have used C++ most of my career and I am still learning Delphi. I was skeptical of Delphi at first. But I gave it a try and did performance tests. For example, Delphi's for loops kick the shit out of C++ for loops. Another examle, Delphi's TList kicks the shit out of the STL vector and list containers. Don't be so ignorant, give it a try. I DARE YOU ALL YOU TROLL GEEK C++ PROGRAMMERS WHO FIND IT EASIER TO SAY DELPHI SUCKS RATHER THAN TRY IT!!
As for GUI, no contest! No contest!. You know easy VB is with GUI development, Delphi is even better (with more components by default than VB). People have mentioned Qt. I like Qt. It is orders of magnitude better than MFC (which is the WORST LIBRARY IN THE WORLD!!). But Delhpi's VCL is better than Qt.
Delphi does not have garbage collection. That is ok, its interfaces are automatically reference counted
I thought that Delphi would not be portable, but it turns out that Borland implemented something to simulate a lot of the Windows stuff under Kylix. As a result, porting should not be hard. I will not say that porting is a snap. I would be lying. However, porting should not be that bad, but YMMV.
End result, I used to love C++. But after using many other languages I started to despise C++. Delphi was the language that made me loathe C++. I do respect Troll Tech for making an excellent product. Qt is very impressive, but MS's MFC library is the cold reality that C++ is very deadly in the wrong hands. Visual C++ with MFC has to have caused more project slippage/failure than any other language in the history of programming (well, that is my opinion). I dare anyone to check out Borland's case studies of Delphi. Check out Deja news list of compilers, where the programmers got to vote. Delphi, despite probably the least used langugae, was voted number 1, followed by Borland's C++ Bulder. Visuall C++ and VB were at the bottom of the list with negative comments too!
i think an object oriented pascal ide for qt may be a good idea, as it would be cross platform, and pretty much fit everything. i know delphi/kylix sor of does this for their gui toolkit, but something that didnt run in wine would be good, especially if it used qt.
I'm afraid that I have to agree with the rest of the posters who feel the question the Anonymous Coward asked is stupid.
In that situation the poster should obviously just use the programming language he is most familliar with. Learning a new language is always going to take longer than expected. This is going to delay the project and put it over budget.
Of course, if the poster was familliar with a programming language he would know how to deal with the pros and cons of the language and so he wouldn't even have to ask the stupid question.
On the other hand, the question that Cliff posed about what makes a powerful programming language is an interesting one. Perhaps he could ask it again without the Anonymous Coward.
"favorite language"? That's a terrible reason to choose what language to program in. If Prolog is the best suited for this particular application, then by all means use it. Even if there is only one employee that know it. If it is actually best suited for this problem, then the other employees should LEARN it.
The problem is that most developers don't have a good enough grasp of programming languages in general to make a decision about what language to use. They have only been trained in one or two languages, so that is all they use.
If you only have a hammer in your toolbox, that's what you'll use no matter what problem you have.
Would most definately have to be Brainf*ck. I really think it fits the bill for what you are looking for. It has great OO support, and is extremely easy to learn. The code you will create with it is tight and fast, and the possibilities are endless with what you can do with it.
.NET with the upcoming * operator in version 6. Check it out, you wont be sorry.
Take for example the following chunk of bf code:
>+++++++++[<++++++++>-]<.>++++++[&l t;+++++>-]<-.+++++++..++
+.
>>+++++++[<++++++>-]+.>++++++++++.
That code is a complete program, and will actually print out..."Hello, World!" can you believe it? In only 4 lines? Surely you jest? I can honestly tell you the answer is no, and dont call me Shirly. There are even rumors of bf supporting
(B) + (D) + (B) + (D) = (K) + (&)
I personally prefer C++ - it allows you to embed assembly when you want speed, do procedural and/or object-oriented programming, and, through the miracle of templates, allows you to achieve generic/template based programming solutions as well. Check out Alexandrescu's book on Modern C++ programming. Some of that code is pure poetry.
If ever there was a more portable, swiss-army-knife language, I haven't seen it.
Frameworks abound for it, you can do it with any of a number of methods, from vi to nice polished IDEs.
--- Jump!! Fire!! Bullet time!! - Lego version of the Matrix
Let's suppose you want to run a C or C++ module in Java. You can write modules in C or C++ and have Python or Perl use those modules; that's relatively easy, thanks to SWIG. In the case of Java, you have to deal with Java Native Interface (JNI), which is basically like writing extensions to the JVM. Running Java within C or C++ code isn't as bad, but it's still tricky compared to running Perl or Python within C or C++. I would recommend studying JNI further before pursuing this path. It's doable, but it's not pretty.
Frankly, I would say that the intrepid programmer is better off writing his or her GUI in Python-Qt, wxPython, or Python-Glade, than messing with Java. My experience is that development time is faster with Python than with Java; and for GUIs, the code is actually much faster and less bloated.
Finding God in a Dog
TWW
"Encyclopedia" is to "Wikipedia" what "Library" is to "Some people at a bus stop"
I work with Delphi on a daily basis. Delphi supports (fully) all of the following:
LOAD "SIG",8,1
LOADING...
READY.
RUN
What differentiates them is not "power" but rather convenience.
Delphi. It does everything and can be used by (clever) monkeys. It's main disadvantage is a lack of third-party support.
You were eaten by a grue.
I use logo for ALL my programming needs. I think its what win98 was written in too. Can get much more powerfull then this.
"Stuff... In my home!? NEVER!" - Zim on Invader Zim
"I want the toilet seat!" - Little Dog on Two Stupid Dogs
Smalltalk is a GUI/IDE/Runtime development all rolled into one. It's so object-oriented even the number '1' is an object! It compiles on the fly and runs in a fully cross-platform virtual machine that's been ported to almost every known architecture. Check out the Squeak implementation of Smalltalk, and see if that doesn't make you beg for a good ol' functional language like C.
Looking for a computer support specialist for your small business? Check out
I am a Lisp developer, and I'm proud to point out that Common Lisp does these tricks, specifically my favourite implementation - Allegro Common Lisp employs all of these features and more.
Please take a look at information available on www.franz.com , and email with any questions you might have.
Oh, and by the way - here are some success stories from a variety of people who have used AllegroCL for their projects (NASA, Microsoft, Square USA, etc.)
The true alternative is multiple-precision integers, transparently equivalent to small integers. Such as in Lisp. Lisp integers are limited only by available memory.
Of course, C programmers are used to a world where "+" means addition modulo some arbitrary power of 2. The 2038 bug isn't a bug after all---it's just where time starts to repeat, right?
page widening is gone, thank god.
you crapflooders need to think about some other thing now... but I think it wont be long until they found their way around the filters. They always do.
"Contrary to popular belief, UNIX is user friendly. It just happens to be selective on who it makes friendship with"
...about how dumbass those requirements are. (This should be about comment #750 or so saying that...)
Performance, suitability to task, and - perhaps most importantly available libraries - are about a million times more important than multiple inheritance or overloading.
The problem is they don't play well together. I want a tool that uses the information already present in my programs to take out the tedious and error-prone stuff. Why do I have to tell my computer how to map my objects to tables? Why do I have to write so much support code to use CORBA? Why do I have to worry about include paths and library linkage and jar files? Why do I embed javascript in HTML, which is in turn embedded in a string in a script file?
What makes a powerful programming language? Programmers do! The author of Turbo Pascal and later C#, wrote Turbo Pascal in assembly language. Crazy, but he made it a powerful programming language.
Our company uses Visual Basic and Visual C++. Both powerful languages, in the right hands. Define your requirements, and then find a language that suits that. Don't define the language before the requirements. That's ridiculous. If a language meets your needs, and the ramp-up time for learning it is low, then it's a good language for the purpose.
As for cross-platform, there are a number of languages that are cross-platform. Python appears to meet your needs, but I haven't used it so I can't say. Personally, I don't care for it, but if that were a requirement, I might go that way.
C++ is pretty good if you don't target it for a single environment. There are multi-platform frameworks, if you want to go that way. If you're going with command-line related stuff, then C++ is pretty platform independent, if you write it properly.
You were talking about ISO standards.
Karma whorin' since 1999
intuitive and easy to use IDE
There are several IDEs for Python, the one I typically use the most is BlackAdder. This has a Qt form designer in it for GUI applications. There are some quirks, but it shows a lot of promise.
simplified GUI design and event handling
For Windows development I typically use Qt, I haven't had any problems with it yet; besides the poor documentation. Unless you know C/C++ to read that documentation.
You can access Swing from Python, or use Jython which has the same basic syntax but allows you to access anything in Java. This way once your developers know the language they can either write native code or write Java based applications.
advanced error handling
Can you define "advanced"...seriously. I've never seen an error I couldn't catch although I don't always try.
advanced object oriented design including multiple inheritance
Python has this.
abstract classes
Python doesn't have abstract classes, at least not that I have ever (heard of||needed||read), rather it uses Mixins and polymorphism.
garbage collection
Yep, we have that too...
full support for operator and function overloading
portable (at compile-time) across various platforms
I believe the Python interpreter will compile on just about anything with a C compiler. If you want to "compile" your Python code into a standalone program then you can use Gordon McMillian's excellent Installer program. It works on Windows and Linux.
Really, if your criteria truly represent what your boss wants, then Python is the solution. It is perfect. See all the details on why Python is right for you at http://www.awaretek.com/plf.html and also there is an online program there to help you choose a programming langauge based upon your own criteria, whatever they are. it woudl be interesting for you to put in your criteria and see how the various languages on your list score.
Just in case you are doing scientific apps:
I find that my fully vectorized code runs at about 1/2 C speed with Numeric Python. Marginally vector code at 1/4 to 1/10 the speed of C. Thats great for prototyping since you can make a quick change and see the result pretty quickly. Check out my web site for examples.
C++ forever! Just use some GC (Garbage Collection) library.
Why? Come to EFnet #C++ and we'll chat.
-Jey Kottalam
I applied poor moderation, and this is the only way to undo them
If there was a new language I would like it to be like LabVIEW. LabVIEW is a good language because it uses icons and is graphical. The programmer works faster because people can comprehend pictures faster than writing.
I think it meets your criteria?
I don't know of a language that uses all of the above but if you want all of them, why don't you write your own.
./ which language is better for the job when you are given too huge of a requirement and a language that does not exists.
It would be much easier than asking
I think your boss want you to write one, not find one.
Forget the hype. What is your project oriented to?
* Assembly: Hardware programming. Embedded devices and stuff.
* C: OS level programming. *Eficient* GUI apps and OS drivers.
* C++: Big OS level app and *big* apps: Word, Excel, and alikes
* Java: Network and server programming. Web apps and distribuited systems.
* Perl: Text procesing apps. System reports and stuff.
* C#: Java clone ( no WORA )
- just my 2 cents.
Java in Java == JVM in Java
javac is no big deal, because it just parses and generates bytecode.
Why do all industrial developpers stick with low-level languages like C and C++ (yes, a language where the programmer has to take care of memory management is a low-level language), or only use aberrations like Java (who got this freaking idea of using bytecode for real programs) ? These languages are among the heaviest and most bug-friendly ones.
My utopic advice to industrial developpers would be to use high-level reliable and humanly maintainable languages. I am especially talking about strongly-typed functional languages. These are actually the ones that take advantage if the strongest theoretical foundations, which provides them with a thourough understanding. For one thing, strong typing is an impressive way of getting rid of implementation bugs. And most importantly: pure functional languages make proofs of validity humanly affordable. Talking about object programming, several FP languages provide OO features in a really powerful way. The one language I am currently a huge fan of is Haskell. I actually made some middle-sized stuff myself with it, and I was impressed how fast I got clean and elegant results.
A frequent criticism towards these "academic" languages is the fact that they lack common libraries and that their standards are evolving. I think that if industrials dared to use such languages for real applications, this problmes would quickly disappear thanks to the work of a handful of pioneers, leaving a beautiful world of elegant and efficient languages to future generations.
Well, stop me now, I'm dreaming...
I'm not sure where you can get a GC library, but they are out there and undoubtedly someone else has mentioned one or two of these.
As many others have said, Java, VB.Net etc. fall short. No operator overloading, templates, MI.
C++ and good libraries are your best bet.
No, Thursday's out. How about never - is never good for you?
And a good sign of it being an emotional topic is that almost all of the posts are below my viewing threshold. Far more than normal.
Here's my take: I used to be one of the biggest Java advocates around. (In fact, I was one of the winner's of Sun's Java Cup programming contest.) I fought off learning Perl for years, but today, my language of preference is now Perl. Here's why:
- Portability - Where Sun brags about "write one, run everywhere", Perl actually delivers. Java's available on a few platforms (and even fewer, supported by Sun). But Perl has *much* wider availability. As one example of many, FreeBSD didn't have a reliable, supported Java implementation until very recently (if even now), whereas Perl has been there for ages. And somewhat disturbing is that the most reliable Java implmentation is on Sparc Solaris. Even I386 Solaris has serious issues. I guess making sure you fix problems on your own platform is a natural tendency, but it does go against the reliable portability that Java promised. (As compared to MS's anti-competitive behaviour, this is small stuff, but an issue nonetheless.)
- Reliability - I've had JVM's cransh on me, run out of memory inappropriately, and have other ugly problems. I haven't seen this with perl, yet. I've looked to IBM, Sun, Symantec, TowerJ, and others, for a solid, fast JVM, and they all seem to have fatal weaknesses.
- Consistency - I've found far greater consistentcy in the behaviour, performance, and reliability of Perl across platforms, than Java. I've seen Java seriously choke under pressure, and run out of memory. It might be fine for lightweight, run-once applications. But for heavy-duty stuff, it's repeatedly disappointed me.
- String Manipulation - In the majority of applications I've come across, *especially* web application, most of the work you end up doing is string parsing and manipulation. Perl's regular expression functions far outshine Java in this aspect. A one liner replaces a fifty-liner. Yes, the person maintaining the code has to know Perl regular expressions inside out, but I don't have a problem with that requirement.
- API's - CPAN seems to have far more exhaustive support for standard API's, well in advance of Sun's. They are usually more fragmented initially, and I would prefer the centralized approach of Sun, if it could just keep up. But it can't (or at least doesn't).
- Open Source - While Sun talks a lot about being open source advocates, Java's source is far more restrictive and harder to get or legally use, than Perl's. (Although I am against the non-commercial restriction of GPL. Hmmm, Perl is GPL, isn't it? Have to check that, as I'm not 100% sure, but it's a good guess.)
- GUI - AWT was efficient, but hard to use. Swing is very cool looking, with great features, but *slow*. Perl/TK is fast, efficient, portable, easy to use. It's by far my preferred rapid GUI environment. (A bit of foreshadowing perhaps: On my winning JavaOne entry, I used PackerLayout [I think], which was a port of the Tk layout mechanism to Java. Okay, okay, packer actually originated with Tk, not Perl, but since Perl/Tk is more or less the defacto Perl GUI, it's not complete out of context
:-)
- Multithreading - This is actually one point where Java shines over Perl. Perl has no standard multithreading, which truly, truly, sucks.
- Elegance - This is another area where Perl fails, but another area where it doesn't matter
:-) Perl is ugly, Java is elegant and beautiful to look at. But I can do more with perl, more quickly. And super-efficient hashes as a core part of the langauge allow passing arguments as key-value types, as is encouraged in their object programming model. This, I find more elegant. So at the surface, Java is prettier. But one layer down, where it really counts, Pelr is more elegant.
So in short, I've "been there, done that" with Java. Perl is liberating me from a lot of the problems I had with Java.(And on a rather irrelevant, but rather appropriate bit of symbolism: I happened to be wearing a JavaOne Long Sleeved T-Shirt tonight as I wrote this. The wrists were a bit tight, shrunk from washing, I guess, so I tugged on them to loosen them a bit. The whole sleeve ripped. Kind of symbolizes my experiences with java. Shoddy merchandise, all around
-me
Love many, trust a few, do harm to none.
True, Ruby doesn't have multiple inheritance. But as you point out using Ruby's mixin feature (allows you to mix a module into a class thereby adding a module's behavior to a class) can often be used in place of MI.
Using MI tends to get messy anyway, especially when you end up with some kind of diamond inheritance tree. I personally tend to avoid MI even in languages that allow me to do it. I have to say that I much prefer Ruby's approach of using Mixins.
hey nigger, fuck you.
my name is Arabic and means "great". Obviously,
a tiny white trash like you, doesn't know what it
means to be great.
fuck you, and your law abiding mama.
betch.
...if it had a laser beam attached to it's forehead.
One word LISP
Avaible on all most any platform and if there is a feature you miss, create it much faster than having to create it in a other language. Also check out CLOS and other dialects and add ons.
Ref:
check out http://www.lisp.org
- Proud to be a Coward
I'd rather have:
(/ (+ (exp a b) e) (* c (+ d (+ b (+ a b)))))
:)
Got friends?
You forgot to mention what your application space is. No one tool fits all yada yada yads.
But... I've used alot of languages from Assembly, Cobol (eek), C, C++ (Visual Studio, C++ Builder, and editor/omake style).
And the one that gives the most raw power and expressiveness is Forth. You essentially write a hand tailored application level language in Forth.
What Makes a Powerful Programming Language?
Come to think of it, I can recall a recent conference of well known language developers where they asked the same question. As a matter of fact, thier conference could have been called, "What makes a powerful language?"
Unlike the "What's the best language?", this question has the potential for a lot of interesting answers and opinions. It allows people to think creatively to solve problems with the status-quo in the language world.
These question also goes beyond, "What's the best language?", because it challenges a people to solve the problems with our existing languages rather than defend the stupid quirks and idiosyncratic features of an existing language.
Personally, I think there is a lot of room for improvement for existing languages and development environments.
One feature I think lacks in many good languages is the Interpreter feature. It bugs me all to hell that C++ and Java don't come standard with an Interpreter. Why can't I have strong typing and a dynamic typing together?
I'd love to have the option to choose whether I'm going to use determanistic finalization or garbage collection. What about support for units of measurements?
var x = 6 feet / 3 seconds
print x; '2 feet/second
There are so many ways one could improve languages. I think asking Slashdot is just one way we can tap into the resources of many brains to find some good ideas.
"Communism is like having one [local] phone company " - Lenny Bruce
Available from:
3 20 7/1/
http://borland.com
Review:
http://www.linuxplanet.com/linuxplanet/reviews/
Community/Resources:
http://www.delphizine.com/
10 Reasons to use Delph/Kylix:
1) Both Delphi and Kylix have a similar IDE and is IMHO very nicely designed. Also it inherits the concetually intuitive concept of control 'properties' and form painting of VB.
2) The compiler is blisteringly fast.
3) Programs written in Delphi will generally compile under Kylix and vice-vera
4) Unlike VB, Object Pascal encourages Good Practice (TM). Is properly object oriented. Provides 'properties' (implicit get/set methods -- the lack of these is one of the major faults with C++ IMHO) and (at least a few years ago) you get a full language specification with the product.
5) Kylix is free (as in beer) for the creation of GPL apps.
6) Kylix uses the Qt widget set (oooh pretty)
7) Events directly mapped to method calls
8) Doesn't have garbage collection per se but then not many languages do. Again IMHO garbage collectors generally provide solutions which work OK for most cases but will never compare with properly coded programs.
9) Borland have a long history of quality development products.
10) A comprehensive OO class library comes as standard.
Rich
www.python.org -- the price is nice too.
"On the Internet, nobody knows you're a dog!" - a dog
Sorry, you are incorrect. VB.Net and C# are finished products.
They are good products.
Neither support multiple inheritance though, so they're out. (VB.Net doesn't support operator overloading either)
Dr. Peter Venkman
Too many language "features" leads to problems. How well do the features interact (are they orthogonal to each other)? How many people understand how to use them all?
:)
Modern research on language design focuses on finding the simplest, most elegant combination of features that allows you to express the concepts you want to, in a safe a way as possible.
If you add in lots of random features things become far too complicated to manage.
Keep it simple (and elegant)...
What about Templates, does anyone use them in the real world outside of the STL? I think that is a very strong feature for being able to quickly code complex things up and are easier to mantain.
mnewberg.com
what is the best religion?
Dear Slashdot,
My boss gave me the assignment to find the best religion. Some requirements that he gave me are:
<UL>
<LI>Should keep one from everlasting suffering and torment in next life
<LI>Should help one eventually pass to nirvana-like existence, eternal increase and well-being, perhaps even an all-powerful/omniscient state
<LI> Should help one to acheive balance, peace of mind, and a strong feeling of being alive within this imperfect world
<LI> Should enable the occasional performance of miracles when called for
<LI> Should improve behavior of followers (make them charitable and courteous but zealous in good causes), and help them improve the world
<LI> Should have limited numbers of flawed adherents
<LI> Should have a consitent theology that makes total sense to rational minds and mystics alike, yet is accesable to the common man
<LI> Should provide insurance against armageddon-like scenarios
<LI> Should have a finite (yea, even small) set of clear, detailed, and consistent directions for acheiving all positive results (Goedel's theorem notwithstanding). Not to mention avoiding bad results.
<LI> Should be in line with the will of the universe's most powerful entity.
</UL>
I've looked at Christianity (Catholic, Eastern Orthodox, Melkite, Coptic, Protestants of several stripes), Islam, Buddhism, Hindu-ish faiths, and primitive animism, Kibology, Shirley Maclain, Scientology, Wiccan groups, secular humanism, and both U.S. political parties, but they all seem to be missing something. Can you point me in the right direction?
Libertarianism is rich wolves and poor sheep playing gambler's ruin for dinner.
Eiffel has all of those, and is being integrated into .NET (soon, around May)
Analytic & algebraic topology of locally Euclidean meterization of infinitely differentiable Riemmanian manifold
Luckily the boss said only the IDE had to be easy to use ;) Don't forget O'Caml. While the learning curve can be steep for those never introduced to functional languages, the garbage collection, object-oriented/functional+imperative style mix, near-C (when natively compiled, portable bytecode by default) speed, type inference (almost never state the type of a variable again), and bindings to both Tk and GTK make for an impressive beast! And it's free (not much of a surprise these days, but still can't be ignored :) While there's a small lack of documentation, the mailing lists (two: a new one started in the past week caters specially to beginners) can fill any gap in your knowledge.
--
I romp with joy in the bookish dark
-Michael
-Michael
Yet Java has been written in Java. The standard Java compiler is written in Java. And IBM has a JVM and JIT written in Java. It is used for testing out new concepts in JVM/JIT design.
Ruby.
(its a language)
heh.
Polymath! Has anyone read the Gateway novels by Frederick Pohl? The Hero's love interest is a programmer who uses a language called Polymath. You program it by having a conversation with a 3D holographic persona generated by the computer. In Gateway, she talked to a re-creation of Einstein to do the job. No THAT is an interface!
The only real way to do it is HTML. You have all the brains in the back end and a nice GUI web page on the front end that works in any browser. If you have some advanced GUI options use an ActiveX control and or Java embedded in the web page.
I would prefer to use Visual C++ and tell my boss it isn't going to work on a mac or unix. (but I don't really have any bosses to worry about). Visual C++ kicks ass over all the rest of the programming languages. Garbage collection is only needed if you are a buggy or unexperienced programmer. But if you program in Visual C++ you are only going to release it for Win32. Porting to a Mac or Unix is a nightmare and entails starting another 2 projects nearly from scratch.
Here are a couple more things that should be considered.
1. Maintainability - How easy is this project going to be to maintain. The language you choose will affect that.
2. What's the learning curve for the language? C++ fits most of your list but the learning curve can be steep. Do you want to take nine months of doing nothing but learn a complex framework?
The race isn't always to the swift... but that's the way to bet!
I like the long names. You can always use a decent development environment (eclipse, emacs, jEdit, ANYTHING basically) that provides code completion. The long names are there to make it easier to understand what a particular function does if you're not familiar with it. If you feel that having your functions and variables named Xx1 and Xy2 is a good thing, that's a problem.
Overcaffeinated. Angry geeks.
What software requirements are driving the need for multiple inheritence and operator overloading. I think a good designer would be able to work around multiple inheritence. I personally would consider operator overloading as syntactic sugar that can be lived without. BTW, someone else mentioned python. I thinks it worth a look also, but I would start in the Java or C++ camps first. (I'm a bit biased toward Java since I'm using it now and FWIW I'm certified).
Eric A. Stephens ericastephens@mycingular.com
As long as we're off-topic...isn't it "gets my goad?"
Zen christianity
"what is the best color?"
Red
Any more questions? It's your $100 a hour.
Borland always has had the best IDE (in my opinion).
Definately take a look and weigh against criteria... I think you'll find it scores high-marks for all of your requirements.
I'm mentioning squeak because I don't see it in the list yet, not because I think it's the panacea you're looking for. But it's pleasant, smalltalk-ish, and (tautology alert) its adherents like it.
Libertarianism is rich wolves and poor sheep playing gambler's ruin for dinner.
The two most hyped programming languages ever are Microsoft's "Visual Basic" and Sun Microsystem's "Java". Though some might argue and claim that C++ is the most hyped programming language. Anyone want to start a discussion on "The Most Hyped PLs"?
There is the notion of the right tool for the right job and, as you can tell from these threads, everyone seems to have a different idea about what the right tool is. I don't quite understand why your boss feels like you need to find this one super-language. Most development projects these days span multiple platforms and software domains, from desktop to server to web. Different languages offer different strengths in different areas. Different programmers have different skill levels in different languages, and different preferences in development environments. What is the percentage in attempting to enforce such a heterogenous environment? Wouldn't you be better off to find a compatible suite of tools based upon the platform and the problem? Couldn't you better capitalize on the strengths of your development team by choosing appropriate languages and tools for each application layer? One size doesn't fit all, otherwise we'd all be programming in Java.
Ok guys, I need help finding a car for a biz project that my company is working on. My boss says that the car must have the following features: side panel wood trim, a hatch back, 60-inch wheels, a blue stick shift, firestone tires, a fiberglass bumber, and oh yeah, to be hip with the latest trends, it has to be a SUV. I am just having so much trouble finding a car that has all of these features.
- Uses Object Pascal language; no bugs due to bad type matching; less chance of memory leaks; no undecypherable source code (because Pascal won't let you do "clever" tricks that in reality only obfuscate the source).
- The GUI interface is a pleasure to use, with it's automatic source-code completion features which lets you pick and choose amongst the valid, legal field/methods/properties names.
- The event handling is simple enough: you just plug an event handler into a table of possible events for every given component, and the code is called automagically when shit happens; no more parsing at the message stream.
- Object Pascal's OOP has everything to offer to advanced OOP jocks. And the source code stays readable, too.
- Garbage collection is no pain with Object Pascal; properly coded destructors is the name of the game here.
- You will never overload enough Object Pascal functions... Full overloading is wholly supported.
- Compiles on both your neighboorhood friendly Win32 or Linux platform.
'Nuff said. Don't listen to the C/C++ dopes, they're just toying around with a sophisticated front-panel toggle-switch array...No c++ compiler can optimize the temporaries out.
"Can", as in "is able to", or "can", as in is allowed to? C++ has the "as if" rule, which allows compilers to implement the code however it chooses, as long as the code yields the same results. In this case, for example, it might be possible for a compiler to see the allocations are of specific size and only used temporarily, and allocate room on the stack.
I certainly don't promise any C++ compiler does this, however.
Ooh, a sarcasm detector. Oh, that's a real useful invention.
The real question is does the language fit the application. There are many reasons to choose one langague over another but those listed wouldn't be on my top 100. Easy to use IDE is brand spedific not inherient to the language. Simplified GUI design is generally a vendor implementation issue as well but the languaue may have better multi-platform suport than another. Multiple inherience is applicable in some applications but not that often, operator overloading is a nice buzzword, but not gnerally usefull. The rest is more buzzwords than anything else. The poster doesn't mention what sort of product it is so any advice listed would only be general purpose at best and probably not address this appplications special needs. There are no perfect solutions, at least not in any world that I'm familiar with ;-). So you generally have to settle on the language/solution with the fewest drawbacks.
.... . You are either stuck with being lame on all platforms or have builds targeted at each different platform.
It seems to me the the best language has much more to do with maturity, ability to get programmers with experience in language X, number of palforms supported (with weighting to platforms most commonly expected to be used). Next on the list would be quickest development time, debugging suport (if you happen to be a programmer than occationaly makes mistakes). Other things to consider would be support libraries, that may have a large portion of your project alraedy solved. The whole "write once, run anywhere" really turns out to be "write once, debug everywhere" and never beleive that what is right for one platformn is going to work best on all platforms, windows != linux != MacOS !=
The list used seems to show that the poster's boss doesn't really understand program management, so the best suggestion I could make is clean up your resume and use moster.com.
I guess that is why you will always be a programmer and never a software engineer. Maybe you should go and get some typing classes?
powerful programmers.
four-oh-four
Why not ask for a telephatic user interface and the ability to cure cancer?
1) circular references aren't terribly common to begin with and can be avoided.
2) this is true, but I assume that if one requires GC than there will be a significant amount of garbage. It's simply, relatively painless, and is used quite frequently in C++. Therefore, for a production environment, using reference counting may not be as efficent, but it is more likely to be effective as it is maintainable.
Unless there is a readily available GC for C++ that works really well and is Free as in speech and beer? If there is, then use it, but I don't know of one.
int func(int a);
func((b += 3, b));
It is the building and the cement that matters more than the brick for good design.
I think OTcl and TclCL does everything on that list, at least to some extent. I'm mostly dealing with the OTcl part here.
While I agree with many of the points made by other people about how the language isn't as important the problem, it's quite possible that the boss knows that if a language can be found to do all that, it will make the implementation a lot easier. Either that or he/she's got pointy-hair genes.
Anyway, down the list:
IDE - wish + text editor, e.g. emacs. This isn't your "traditional" IDE, but it does pretty much everything an IDE needs to. Easy to debug because you're in an interactive shell which does everything right in front of you. Easy to write files and then execute/debug them immediately. But no point-and-click creation of code.
GUI Design - wish. Type it, see it immediately. Decent layout management.
Event Handling - Tcl/Tk event handling. Pretty basic. You can simply "bind" events to functions.
Advanced Error Handling - this is your job, but the feature is there. e.g. catch.
Advanced Object Oriented Design, Multiple Inheritance, Abstract Classes - oTcl gives this to you on a Tcl level. Abstract classes aren't specifically provided, but you could enforce "abstract" classes via the constructor/init code.
Garbage Collection - There's no automatic garbage collection, but it does reference counting.
Overloading - yep.
Cross-platform - Tcl/Tk runs just about everywhere.
I've just recently finished researching the available CL implementations, and their relative merits and for my needs Franz Inc's) Allegro CL product was most appropriate, but there are other offerings from Xanalys and the opensource CLISP and CMU-CL to consider as well.
Please do post what your eventual decision is, it'd be useful for some of us to understand your decision making factors.
Take a look at ADA, I'm pretty sure it fills all those requirements.
Ash nazg durbatuluk, ash nazg gimbatul, ash nazg thraktuluk agh burzum-ishi krimpatul.
Now, links such as this can be constructed.
Truly a day to celebrate.
- A.P.
"Remember when the U.S. had a drug problem, and then we declared a War On Drugs, and now you can't buy drugs anymore?"
No laundry list of programming language features will prevent bad code. A good design which leverages the strengths of your language of choice is a much better bet. I always evaluate what my application will be and where it will run before I pick a programming language. The decision should be based on the merits of the language for your application rather than just the merits of one language versus another. There is no language with all the virtues you are seeking because every language is formulated using tradoffs and are tailored to the preferences of the designer. Garbage collection typically slows things down and sometimes contributes to bloat. Operator overloading and C++ style multiple inheritance often result in confusing code. Features which involve overloading are often syntactic sugar. Use features as far as they are useful. Language features should not be used to impress your friends. ;)
The real question is how useful a language would be in solving your particular problem. Is C++ sytle multiple inheritnce going to let you implement your solution faster? Will your users notice the performance hit caused by the garbage collection features in Java or Lisp?
Personally I prefer C++ for performance intensive applications. Java is really a step forward in terms of clean language design. Proper use of java can result in a more reliable, albiet marginally slower, application. These and other languages all have their place.
I think prior suggestions to combine languages are very valid. Many languages will integrate with others that will front a C or C++ interface. Choosing one language for the UI then another for solving the actual problem can be quite effective and seamless to the user. I've solved a lot of problems by selecting a client-server interface between the logic and user interface.
I hope this doesn't confuse more than it helps.
Hi, I'm Bernard Shiffman. You probably already have my resume. I recently designed a Dialog with Yes and No options and can therefore be considered an expert in all programming languages. Please contace me or my legal team and I'll be happy to bring my intellect to bear on your problem.
Your wish list isn't even warm. You will have to settle for a subset. The last real attempt at a virtual machine was P-Code, and where many P machines were available, the system never caught on. The problem was speed. Microsoft's .net and Java make some attempt at cross platform operability, but there are restrictions and a huge performance degradation.
For any major application, even compilers like C++ will require custome libraries that are not available on all target platforms.
The only Computer Language that I know of which has true cross platform support is ADA. ADA is one of the most powerful programming languages available but try finding a programer the likes to program in ADA. Just the mention of ADA makes my stomach turn.
Sorry, you are not going to find what you are looking for.
TOM
Designing a language from the ground up is a fool's errand, but assuming I'm that kind of fool, I'd categorize the above features as follows:
Features to include at all cost:
- abstract classes
- well-designed error handling
- garbage collection
- portable semantics
Features that are nice, especially if you don't have to implement them yourself:Features that are annoying and should be avoided if possible:
Features to avoid at all cost:
This is a red herring. One uses reference counting when shared ownership makes sense. Mutual ownership is at odds with "shared ownership".
2) you have ignored any time performance. Reference counting adds overhead even if you never accumulate a significant amount of garbage.
The overhead is very small unless you use copy-on-write, or the objects are very small. You only pay during construction, destruction, and assignment. And even then, the cost is substantially less than that of a deep copy.
For very small objects, there are other memory management strategies that are more suitable than reference counting. These can also be implemented in C++.
Why object oriented? OO is only one attempted solution to the larger problem of making programming easier on the programmer. It does this by trying to compartmentalize functionality and seperate implementation from usage. To see how OO has eschewed its own features just look at how delegation is favored over inheritance. This is a functional way of programming.
Functional language actually provide even cleaner semantics of encapsulation by first-class method passing; compare the interface semantics of this versus encapsulation and notice how simplier the documentation is. Even OO style is better done in a functional way than objects: calling a function to return a lexically scoped function that can then be passed around does far more to promote security and encapsulation than any OO language could hope to do (look at the ugly attempt of C++ to provide member function pointers). Even the arguably most OO language, smalltalk, does what it needs to do in a very functional way.
Besides functional there is the APL, now J and K, way of doing things. Array languages have shown for years that the most effecient way of operating on data is to slice the data column-wise as opposed to across object: doing an operations on the all first fields of your objects as opposed to doing an all operations on your first object. This even hides the amount of data from you. Perl is just now seeing this with hyper operators.
Instead of desiring OO, peple should look to see what the desired outcome is, then think rationally instead of going with the buzz-word compliant non-technical people.
Have you checked out Python www.Python.org If that does not work for you then try Perl www.perl.org Python is easier to learn but can be taken to extreme depth. Perl is alot harder to learn right off the bat when compared with python. Both work with multi archs and platforms and would seem to have the characterists you are looking for. Check them out. Cheers, Nate Nesler
intuitive and easy to use IDE
Overrated. It must be because I'm getting along pretty well with vi.
simplified GUI design and event handling
This is a tough one. The GUI frameworks are unconditionally complicated. Use what you're team is most familar with.
advanced error handling
errno? Just kidding. But real exception handling is pretty expensive. Those are really your only options besides maybe something like this.
advanced object oriented design including multiple inheritance, abstract classes, and garbage collection
This is kinda funny because multiple inheritance a feature that is only justified in a very small number of cases (I believe it should be avoided alltogther) and is a really good way to get into trouble lick-ity-split, abstact classes is mearly a convention and really doesn't buy you anything in terms of functionality and garbage collection makes languages far too forgiving to the idiot using crappy data structures and algorithms.
full support for operator and function overloading
Well, you just want everything and the kitchen sink don't you? They did that already, it's that morass of a language called C++. Do the next guy a favor and pick features that suit the needs of the application rather than features you think will make it easier for you or the result will be indecipherable.
and portable (at compile-time) across various platforms
Why? Is this really that great? The XOpen and ANSI standards are designed to reduce system dependancies to the point where this shouldn't be an that much of an issue. Even if you're not using C/C++ the language binding likely is. In either case, as long as you consider the scope of those specifications your code should be portable without too much effort. Of course if you cheat and call those Win32 API functions it wouldn't matter what language you're using.
Sounds like you're trolling for some super Java/C++ language. It will probably never happen and rightly so because it would undoubtedly result in unrecognisable code that's dog slow.
I'm willing to bet your application could be written very well with plain ANSI C a few additional libraries and some C++ for the GUI.
wherin I'll specify the language to get it done in!
The spec's are useless. What is the project? Database Application? Try SQL....Have to modify the bank's software...COBOL...Must integrate with M$Office...VB/VC++ may be your best bet. Lotus Notes App....LotusScript...
You said portable, so why were you considering anything from Microsoft? VB/C# currently only run on Windows. VC++ is C++ until you start using COM/MFC, which kills the portability.
The question was like saying "I want to work with wood...what tool should I use?" Figure out the project ("Drive in a Screw") and the answer will become obvious("Hatchet")
-- There are 10 kinds of people in the world, those who understand binary and those who don't.
But reference counting often is. For example, the g++ implementation does use reference counting, so the example offered should perform as well as +=
Materials engineers call the equivalent thing in their field 'unobtainium,' I believe.
I think ada95 fits allmost all (except multiple inheritance).
Aside from that, sounds like java to me, and the IDE of choice would probably be the IBM Visual Age thingy.
Ya ya performance..... so.. the newer buisness desktops are at a minimum Celeron 900's. Add to that the IBM JRE and....
When someone yells "Stop" or goes limp, or taps out, the fight is over.
OO is only one attempted solution to the larger problem of making programming easier on the programmer.
No. You're thinking of MSVC++ and drag and drop programming. OO is about modeling and it can be very effective.
It does this by trying to compartmentalize functionality and seperate implementation from usage.
This is the stuff trolls are made of Jayson. OO does not "compartmentalize" and it is not about contract programming. You have a very superficial understanding of OO principles.
Each instance of an object in a program is a model. You think about what it is conceptually that you are modeling and derive classes for those concepts. In practice these objects usually have hierarchial and recursive relationships. For example a stock is a security but a security is not a stock because it could be a fund. Or a WWW document has elements and frames where frames may be sub documents. These relationships are found everywhere and can be modeled most effectively using OO priciples. That's not to say you should use OO for everything (e.g. you wouldn't want to represent each character in a document using a separate object). Indeed I don't beleive 9 out of 10 developers using an OO language are actually writing OO code. It's modular at best. To use it effectively is non-trivial.
To see how OO has eschewed its own features just look at how delegation is favored over inheritance. This is a functional way of programming.
Like I was saying above, the results of OO are most effective when used strategically. The highest level superstructure benifits greatly from an OO organization. But using OO to a fine degree is not necesarily good.
Much of Lisp lives on in Java (and its clone, C#). Sure, Java syntax can be a bit pedestrian at times, but look a bit deeper.
...the people who will be developing the software ie. the dev team?
Surely they will prefer to do things in a language they prefer rather than do what the boss says.
They might even say they want to do some parts of the project in one language and some parts in another.
I've found that when one language doesn't fit the bill alone, that more than one creatively hooked together can do better. I don't know the specs of your project, but perl/python/tcl-c/c++ hooks together well, and besides, partitioning sections of the project into languages can help the codebase organization later on as well. The biggest issue would be getting an IDE to do all of this, but the portability is there and any IDE for which plugins could be written (Kdevelop or MSVC or anything else really), could be made to support multilanguage development.
Something else to look into is the Qt library for C++. It is a portable library that gives you more than GUI, but does include a RAD tool. It is portable across Mac/Win/Linux and is free on Linux. It gives you lots of basic stuff like Data Structures, as well as sockets, files and other OS abstractions all the way up to portable threads support. It is incredibly clean and the event handling architecture is one of the best I've run across. Development time is also fairly quick. My experiences with it are good, but that's just a thought. Possibly Qt with some runtime scripting in Python or Scheme (Scheme is for when you really want to make the other developers feel inadequate). That would definitely be my choice for a large project were I starting one.
Good Luck,
Brian
Consistency?!
Okay, perl-the-runtime may do well for consistancy, usually. Perl-the-language is not consistant at all -- not between versions, not between syntactical constructs, not anywhere. There are so many places in the documentation where words like "except", "excluding", "but" and company are required that it's practically impossible to remember all the little nuances of its syntax at a glance. And I had all sorts of code break between perl 5.005 and 5.6. Having a language that tries to read the developer's mind for the sake of TIMTOWTDI may sound like a good idea, but it leads to all sorts of problems (just like laws that place penalties based not on people's actions but what goes on in their heads). You can have TIMTOWTDI or you can have an internally consistant language -- not both. I pick consistancy -- TIMTOWTDI may be damn nice when it works, but it's a royal pain when it doesn't. I haven't had to read a language reference in Python since 2.0 came out (with a few new minor language features), whereas as a Perl coder I hit the language ref docs every day.
Python's PyGTK beats Perl/TK into the ground on both speed and ease of use. Build a really big grid of pushbuttons and labels and such in tk, and do it again in gtk. Then tell me tk's fast. (Never mind the usability differences between them -- unless you want to, in which it's another huge win for gtk). As for ease of use, I have one word: libglade.
Python's runtime environment is not only extremely reliable, but it's also readable, so mere mortals (who know C) can debug or otherwise toy with it. Try doing that with perl! (Further, Python can cross-compile, whereas cross-compiling perl is an evil, evil task -- I know, since I had to make it happen for my job). And writing bindings between C and Python (in either direction) is far, far easier than using Perl's XS interface.
Did I mention that Python uses PCREs? Yup, you get all your perl regular expression goodness, but with code that's actually maintainable. WooHOO!
As for the "elegance" argument... well, I don't even really have to argue it, do I?
Don't i see a question like this about once a month on slashdot? Hey guys im in charge of choosing a language to use at work, what should i use c++, java or c#? I dont know because they all have sometihng that the other doesn't, and I need every feature in the whole world to do what i need to do. If it is really that hard then flip on it. I dont read slashdot to hear that someone is having a hard time deciding on a language and so wants to spark the same old war, I read slashdot to hear about remotly controled monkey brains and stuff like that.
Looks like he read the latest development management magazine and picked out the buzzphrases with a 'Good' connotation attached.
There are other posts that have excellent suggestions, so I wont rehash 'em here. I just couldn't resist as I'm particularly pissed at managers with no technical background in software that think they have a clue how to design software or write code much less lay down criteria for language selection. Oh, Please! Deliver me from stoopit people.
Bah
Check out Ruby, I'm no exert but I'm sure that it fills all your needs,
Well, since I'm partial to C++ myself (and not too informed), my ideal language will seem a lot like C++. It has to, of course, be portable. With all the diverse processors out there, your market will be very constrained if you just make it Intel compatible. Or even in OS's...But, that would just be making another compiler... It also has to be Object Oriented. It provides for smaller compiled programs and for more readable and more organized source. I'm very much a programmer but, not very smart (just do it on my free time). There are so many other things that I can't cover. But, that's a jumping-off point.
Are you telling me that you don't see the connection between government and laughing at people? - Interviewer
It has ALL of those features, but it is just interpreted instead of compiled.
used search to look if anyone would mention delphi..
amazing how few people know the power of delphi..
it's a waste
C++ Builder seems to me to meet all of the criteria.
Well, you could adapt a GUI IDE to Qt libs and have a lot of what you are looking for there, but, if you want just about everything in that list, go checkout a copy of Delphi 5 or 6, I am honestly not sure about operator overloading, however, everything else is there, and has been for years, along with being extremely easy to use, a monkey could code a database app in 5 minutes with Delphi.
....has to be NULL!
Pick Perl and then use whatever language you like.
Different languages have different strengths, and with no idea of even what industry you work in it is not easy to tell whether you are building real-time physical process management, security tools, or what. So right off the bat, I have to say you are going at this ass-backwards.
That said, Perl has all of the above functionality, and is the highest level language which does so. That means you can abstract as far away from the nitty gritty as you like, or you can hit the metal. It also is a superset of the languages you mentioned, so if you want you can program in Java, C, C++, or many other languages and insert that source code right into your Perl programs, Inline (not using XS). GUI through Tk, Qt, or other packages are possible. It is probably best for you, unless you already have a great Java team, or you are writing a video game or have a lot of flashy graphics. I was going to say, or if you want to sell your product as shrinkwrapped software, but that isn't true anymore with ActiveState's DevKit.
Python might be good, though it seems Perl is still going to have more support for different platforms and general ways to save yourself from trouble. I have to say I have way more experience with Perl than Python myself, though mainly this is because it wasn't mature enough when I was seriously considering a switch, and now because I have no need to change and the future for Perl looks very bright. I get more return on my effort with Perl, it's that simple. You could also use C/C++ with one of the popular cross-platform GUI toolkits, but the more flash the less portable in general.
Another person recommended English, another good choice. The closest language computers understand these days though is Perl, and the language itself is easily to extend. Maybe the best thing to do is figure out what you are building first, then pick the right language. Perl doesn't solve every possible problem, it just seems more likely to be all-powerful than anything else out there, that's why it is the glue of the Internet.
Use COBOL. Highest powered language you can get. It's like running 5 crays at the same time its so powerful
The most insightful thing I ever grasped was that programming transends the languge with which its written. Unfortunatly we mere mortals have not devised an all encompasing language with which we can describe any system so we're left with C++, lisp, scheme etc...
I think the coolest programming languages support continuations so my vote would be lisp.
higher order functions and closures
word
Your signatures belong to me.
I've long wanted a "x wrap z body y" construct, which is execute x y z. A variant has an errorframe built into it so that z is executed even if y throws an error. For example
saved = context;
wrap {
context = saved;
} body {
context = 0;
foo(context);
}
bar(context);
Yeah, that damn strcat... It's just such a mess! Good thing you overloaded that + for me!
-Tom
I haven't explored Python personally myself, but at last a couple of strong tecchie's that I know and respect, are big Python fans, which means a lot to me.
:-)
:-), running on the open source Risc hardware, yadda, yadda, yadda. I think we'll get there eventually, but we've got a few hurdles to clear before we get there. A fun time to be alive. :-)
I don't doubt that Python is more elegant and consistent than Perl. (It wouldn't be hard
But the *huge* libraries of supported API's on CPAN, and the fact that the differences between versions is *well* documented (with source available, even), and the fact that the source can easily detect what version it is running under, and make appropriate adjustments, makes it still preferrable to me. Predictability and API support can outweigh Elegance, in my book.
Yes, in theory, and in my heart, the more elegant solution is the best. (At heart, I prefer AWK to Perl. But in practice, I can't do as much with it, as easily.) So, in practice, I will still choose what lets me accomplish the goal, which today, is still Perl. I'll check out Python, but without the same CPAN support, I doubt I'll switch today, or any time soon.
I'd love to come back in two years with a future slashdot post, where I talk about how Perl came to let me down, and I've now moved on to the far superior, far more elegant, far more support, Xyzzz language. Let's hope. Maybe it'll run on the newly open sourced QNX
It's only going to get better folks, as long as we keep the monopolies (okay, monopoly) from completely eliminating our choices of platforms and OS's.
-me
Love many, trust a few, do harm to none.
I wish I was paid to ask questions on Slashdot. I wouldn't even have to finish my CS degree!
I sig for world peace
What? When did Microsoft stop shipping MBasic?
Never mind, CBASIC is better anyway -- it's semi-compiled and has BCD math. Cool!
What will they think of next -- something more powerful than my 8080-based CP/M machine. Nah, it'll never happen!
Though it might seem strange to specify language requirements for a project, it makes some sense. Having worked on a project before, it's certainly possible that a list of language features becomes necessary in order to implement any design you can conceive. Language choice can be very limiting. The feature you didn't mention was genericity (generic programming), which both C++ and Eiffel support (though C++ does it through a less-than-optimal template system, whereas generice classes follow all the same inheritance rules and requirements as non-generic classes in Eiffel).
Does Eiffel really not satisfy these requirements because it doesn't have function overloading, when it satisfies all the other requirements so well?
"intuitive and easy to use IDE": As of Eiffel 5.0, the IDE has syntax highlighting, full debugging integration and the best class and feature browsing I've seen.
"simplified GUI design and event handling": The Vision 2 library is both cross-platform and well-abstracted. The use of Eiffel agents makes event handling extremely decoupled and simple. The IDE is written in it, I believe.
"advanced error handling": Eiffel 'rescue...retry' handles exceptions and is simple and easy to use. Full support for design-by-contract with preconditions, postconditions and class invariantas would also fall here, I suppose.
"advanced object oriented design including multiple inheritance, abstract classes, and garbage collection": Check, check, and check. Eiffel's support of multiple inheritance is actually complete and an unintrusive as possible, while still allowing the full power of multiple inheritance. Abstract classes are, of course, available. Garbage collection has always been in the language.
"full support for operator and function overloading": infix and postfix operators are the same as other routines. Function overloading is not supported, but for very good reasons.
"portable (at compile-time) across various platforms": Eiffel compiles (cross-platform) to Linux and Windows, as far as I know.
Second, I am not one one of the "objects as real-world entities" people. I believe strongly that to effectively partition work -- to make programming more tractable -- many times you will create work partitions and create objects that have no correlation to the real-world. A contrived example would be a deck of cards. Imagine that you make each card an object, then you have a deck object, and a dealer object. In the real-world the dealer would shuffle a deck, but in our code this responsibility would fall on the deck, but the dealing mechanics would probably rest with the dealer.
I am the kind of programmer that believes in active objects. I am the kind of person that makes everything an object. I make all my constants objects (for type checking and I cannot stand it when people use integers for this) and slowly through most development I have done, these once data-only objects gain methods and no longer become just place-holding constants.
I think that to effectively use the OO paradigm, you need to really abuse it. I use dynamic dispatch for almost all my flow control; try finding even an 'if' statement in my code. I even have the_empty_tree_node objects that don't do anything except return so my tree recursions don't need a base case. This abuse is non-trivial; you are correct. I have spent alot of time abusing C++ and Java for it to come more naturally to me.
However, I don't think it will ever come as naturally to me as functional programming. I am not saying that I do not use OO techniques in my functional code. You can see a sort of dynamic dispatch mimicked by function passing and you can see pseudo-object in functions that return different functions, each operating on the same lexically captured bindings. I am just saying that OO is over-hyped and I feel that the functional paradigm effectively captures OO benefits.
APL's style of data oriented processing has also shown to be much faster and require far less code. Why develop a library when it only takes a single line implement the functionality? Also when you language supports dynamically evaluating a string code reuse in terms of modifying a string then evaluating is phenominal (plus the on-the-fly compiler gets to optimize the hell out of it).
Shouldn't the 'boss' character either be giving less detailed requirements, or just choose the language him/herself? My gut instinct is that if someone has such a strong idea of what is required, and has such detailed specifics, that that person is just a few tiny steps away from the final decision anyways. Either that, or the PHB just put every single programming buzzword into the requirements document to sound 'cool'.
....but not necessarily others' heads.
I have been in many "My Language Is Better Than Yours" debates. It all comes down to Mental Ergonomics: the ideal choice personally fits the way you think and work.
BTW, I documented some of my choices and justification at:
http://geocities.com/tablizer/langopts.htm
Note that error-handling is a messy and tuff philosophical issue. I tend to vote for KISS on that one. Some try to use them for glorified IF statements and get carried away.
Good luck
Table-ized A.I.
The user. All the rest is syntactic sugar.
I would personally go with Delphi to meet the needs of any application, because it is so versatile. However, if you still really like multiple inheritance then you can go with borland c++ builder, which is basically delphi in c++, rather then pascal.
http://www.vanillaafro.com - take me seriously and I will shoot you
Take a look at ESR's "The Art Of Unix Programming", which can be found at http://www.tuxedo.org/~esr/writings/taoup/.
He advocates a mixed language approach that is "knowledge intensive" rather than "coding intensive", using each language for what they do best. I think this approach makes alot of sense.
It seems to me that, by specifying language features, your boss has violated a major tenet of OO design.
The power of Object Oriented design comes from the fact that you do not need to know how things are implemented in order to hook them together into a more complicated system. What good does it do for your boss to specify particular OO language features if this first step in the development process goes against basic OO principles?
When things other than strings and vectors are used, the standard C++ operators are just not enough. For example, we can have > for streams just because we have such built-in (and entirely irrelevent) operators *by sheer luck*. This is ugly. Things are even worse for mathematical stuff. There are much more math ops than C++ ops.
That's where extensible syntax like the ability of defining new operators are needed. Then overloading will no longer be a half-formed feature.
Don't have time to reply. But based on what he is asking, I can tell that he is clueless.
Good luck!
If you have as definite and clear requirements
of the rest of the project as you have for the
tools you must use, then you should be good to
go.
-fb Everything not expressly forbidden is now mandatory.
Sorry, Slashdot post length won't allow it. Your post doesn't demonstrate anything.
Arguing about vi versus Emacs is like arguing whether it's better to make fire by rubbing sticks or banging rocks.
I believe all of this is true for Python, except of course that the CPAN-ish collection is smaller. It's a newer language with (at the moment) fewer users, so that's not surprising.
I believe every Perl programmer owes it to themselves to at least try it out.
Mike
"Not an actor, but he plays one on TV."
Try OpenROAD from CA
Write it in machine language. If you can't write machine code, you're only a poser, not a programmer. Rule of thumb - The higher the level of a programming language used, the lower the level of programmer ability present. Assembly is for wusses, C is for clueless lusers, anything else is for total dorks who don't know that there's really ones and zeroes running around inside that do all the work.
You're not going to find a single language that's got all those features. I won't bother questioning *why* it's so important that you find a langauge that does, but you might consider leveraging technologies such as COM or .NET to create a solution that combines components written in several different languages.
For example, VB and C++ can make a very powerful combo. VB excels at rapid GUI development, and C++ is great for writing multithreaded code and using a wide range of APIs. Your VB and C++ code can work together through a set of COM interfaces. Of course, you might decide that this particular language combo doesn't meet your needs, but this is just an example. (C++ doesn't have automatic garbage collection, for instance, but VB accomplishes something similar to it through its automatic use of AddRef and Release on COM interfaces behind the scenes.)
Hope this helps!
D
Why not try Borland Delphi? It meets all your requirements except Multiple Inheritance (can be emulated) and real platform portability (but so does C# and VB.Net). Atleast now you can develop Windows/Linux solutions using Delphi/Kylix. When it comes to good IDE's and easy GUI development Delphi is right on, you'll never look back. Tom.
Fortran is the way of the future!
Evolution of Language Through The Ages: 6000 BC : ungh, grrf, booga 2000 AD : grep, awk, sed
The rest of the issues you mention, however, appear to be more in Python's favor than Perl's.
Python whoops perl in terms of predictability. No, really. The language spec is simple enough that it only very rarely needs changes that affect backwards compatability (or changes at all; a great many things that are language features in Perl are library features in Python). When these *do* take place, there's right now a multi-step process that takes place over several releases, the upshot of which is that code breakage from release to release without warning Just Doesn't Happen. Contrast this to perl, where code just breaks when Larry sez so (no, I haven't forgiven him for 5.6). Having sudden breakage be documented makes it no less painful when you need to get the damn product out and suddenly it needs major fixes to cope with a new language release. (When I call such changes rare in Python, btw, I mean it -- there's only one I'm aware of that broke any amount of code whatsoever, and it was not a change in the spec but the removal of an undocumented "feature" from the interpreter). As for predictability in terms of whether a piece of code does what it appears to do, that's another area where perl falls short -- see my objections to TMTOWTDI.
"[A]ppropriate adjustments" based on runtime version generally Just Aren't Needed on python, simple as that; that you make such a deal over being able to detect the runtime version on perl implies that the language is so unstable you need to know such things. (Yes, you *can* pull the language version on Python... but I've never seen anywhere where it had to be done).
Interestingly enough, btw, the undocumented "feature" removed that broke a fair bit of Python code moving off of 1.5.2 was just the sort of thing Perl would put in there intentionally. It was something akin to a built-in list modification function (don't remember which one... append?) that took any extra arguments to be elements of a list rather than insisting per the language spec that they be made explicitly a list by putting parens around it. What this comes down to is that folks were writing what they meant rather than what was consistant and Right according to spec, and the interpreter (formerly) accepted it. That misfeature was removed because with Python, consistancy and readability are higher priorities than terseness (though that too is given high standing). If you've ever worked on maintaining Other People's Code, you'll realize that that's The Way It Should Be.
Btw, another interesting thing -- Python has at least three separate interpreters (written and maintained by different folks) following its language spec (cpython, jython, and stackless), and a 3rd-party compiler which converts Python to C. That they all maintain language compatibility with each other (jython's access to the Java standard library and the weird and wonderful flow control constructs of stackless are available strictly through library calls) is perhaps quite telling with regard to the simplicity and stability of the language itself.
Here are a few design points, just to get started:
It would allow me to write code the way I want to think about it, rather than forcing me to follow clumsy idioms. This means it must be a very high level language allowing for many diverse kinds of abstractions. Life it too short to program in assembler or C or even C++.
It would allow me to say as much or as little as I like about the interfaces between the parts of the program (at the level of procedures and modules), and would check to make sure I'm using the interfaces according to my declarations if I've given them, or at least consistently if I haven't. Type checking is sometimes not enough, and sometimes too much!
It would not force me to pay attention to details I am not interested in, but would allow me to look at the details when I want to. Why do we tend to assume that the programmer has to type in everything that someone looking at the program wants to read? 30 years ago assemblers produced listings showing the source code with extra information (like assigned addresses and cross reference listings). Why can't compilers now produce listings with inferred types and other useful dataflow annotations?
Most importantly, the language would be designed to make it easy to reason about what the program is doing, easy to automatically analyze the program's behaviour (important for the preceding points), and easy to manipulate the program (eg, taking a chunk of code, replacing it with a reference to a new procedure, and generating a definition for the new procedure using the removed code; try doing that in C++).
Why? I guess because these are features whose absence from existing langauges I find most frustrating, and I think would do the most good for program reliability and programmer productivity.
>I have already looked at C++, Java, C++,
>C#, Eiffel, and even VB.net;
So you looked at C++ twice. Reminds me of that scene in Blazing Saddles where one of the outlaws says he's good at "Robbery, rape, murder, assault and rape". The other guy says "You said rape twice", and he replies "I like rape".
RMN
~~~
It just isn't worth it in the long run to go with a minority language, even if it has features that are elegant. Yes this is dismal, but at some point the market for programming languages was going to become a two horse race. C'est la vie.
Ruby simply didn't offer enough of a reason to switch off of Perl, Java or Python. Its elegant but not groundbreaking, and frankly the market for programming languages is already overpopulated.
Its okay, I have a little extra karma. Even though a troll tends to not provide any reasoning behind it.
Congrats! You are now a purveyor and advocate of a minority language. Take a seat beside the COBOL programmers trying to eek a retirement out of the last contract they can land.
Its amusing to note how not one person on this article makes any mention of economic factors. Sure, go ahead, use ML. See you in two years.
It generates binaries for Windows, Mac (9&X) Linux, Solaris and bunch of other Unixes.
It has graphcial GUI design tools
It is programmable in a object-oriented language that reads like English.
You can extend it in C if you want.
It has a good free trial offer.
http://runrev.com
I built the Pocket GoogleWhacker in it for 4 platforms in under an hour.
How about Ada? I don't know about its event handling or IDE's, but from experience, I know it has good garbage collection, is portable, reliable and has nice error/exception handling. Here's a couple of links (from google) on the other issues:
9 5. htm
Operator Overloading:
www-inf.enst.fr/~domdl/Ada/lovelace/s16sf.htm
Multiple inheritance:
www.comp.glam.ac.uk/pages/staff/bfjones/oot/ada
Snarkiness is inversely proportional to wisdom because it emphasizes feeling right rather than being right.
Programming languages are only good if the syntax they use is one to one with how you dream up your algorithms and data structures. If you EVER find yourself wondering "I've been trying to get this basic function to work FOREVER, and I can't figure out WHY IT WON'T WORK!" or "This is SO much more of a hassle than it ever needs to be!" or even "Why can't I do something that seems so simple, and seems so in-line with all the rest of the code this language uses, but flat-out doesn't work?"; then what YOU have, my friend, is a syntax problem.
.NET concept of separating the programming language features from the syntax of the code is an excellent goal. Everyone should be able to work in a language they understand as intimately as their own thought, without having to worry about the next person not understanding what they've done. Programmer Unique Languages have to be one-to-one with each other in terms of feature set, so this idea will only work if there is a common underlying base to support all this uniqueness. Get to work on it gang; I'm tired of putting up with inferior syntax. I want my dreams to fly directly onto the screen, not be filtered through some half-assed implementation of a powerful feature set.
It's all well and good to say that this language supports this feature, and so on and so forth. But the first roadblock between the programmer and the completed software is the syntax itself. I have yet to meet a programming language that I don't hate outright because a few simple, basic features that seem in-line with everything else that is standard about the language cannot be done because the syntax cannot support it. One of the things I have always wanted to do is to declare a byte, and then treat that byte like an array of 8 booleans by the same array syntax used everywhere. Fundamentally, that's all a byte is, an array of 8 bits. Should work, isn't that hard, but no language can do it from scratch, and you can't add that functionality by creating some assembley language to support it, because 1, that's not cross platform, and 2, there's no way to bind it to the syntax without creating parser scripts, and that only works for your code.
While Microsoft will inevitably screw it up with it's proprietary greed and fundamentally screwed up nature, this whole C# and
I'd suggest Java, with AspectJ rolled in.
Java by itself is an OOP that doesn't suck as much as it could (it's better than Satan^H^H^H^H^HC++, and is palatable to managers in the same way Smalltalk isn't).
Add AspectJ, and you're really cooking! What do you get? Custom profiling and tracing/logging support. Method dispatch re-writing (yes I know this is the cure, not the disease, which is policy or contract enforcement), mixins, inheritence hierarchy re-writing...
Of course, you could look at Erlang instead. It's a neat functional language that solves multi-threading, communication, event handling, and other issues that you long for when switching from an imperative language. I'm still trying to make this one fly with my bosses...
Putting the sig back into +1, Insightful since 1995!
URLs To backup my bald assertions below. Browse the sites and you'll see studies and numbers. Facts not Religious opinion. Adapower is a good start. Or the Ada Information Clearinghouse
IDE - there's a variety of freeware ones.
Simplified GUI - there's a variety of bindings to various APIs, from X-windows to SWING to W32. Plus many other simplified freeware ones, some thin, some thick. Pick which one is most appropriate. Ada (the language) doesn't have anything more advanced than stdio - but then again, neither does Java, it relies on the awt and swing libraries *shrug*
Advanced Error Handling - Java's exceptions contain more info than Ada's. Ada ones are more simple, easy to use, but I think Java's are better in most ways. They should be - both C++ and Java copied their exception handling from Ada's 1983 incarnation. OTOH most of the time all Java programmers (like me) do is make an exception without using any of the internal data, so YMMV.
Advanced OOD including multiple inheritance and abstract classes - As regards OOD. Ada's the most flexible of the lot. You can do strict OO, but don't have to. Methods are properties of Classes(actually packages) rather than objects, so you can say Wooden.paint(a_wooden_door) or Door.paint(a_wooden_door) rather than a_wooden_door.paint(). So you get all the advantages of multiple inheritance, without the horrendous penalties (which method are you inheriting, the paint for wooden things or the paint for doors?). Abstract classes are used all the time.
Garbage Collection - Ada doesn't produce garbage in general. You can do most things using statically allocated memory, or dynamic allocation within a statically-defined garbage-collected area. When you want dynamic allocation, you can choose to rely on the compiler's garbage collection, if it exists, but you're also given tools for explicit disposal of garbage. Note that Java has true garbage collection, but even Sun says that you can't rely on it, you should use explicit disposal. This is true not just for Java, but in general.
Operator/Function Overloading Ada has had this since 1983. Often copied, never bettered
Portable Stories abound of million- and 100,000-line Ada programs that require a dozen lines changed to make em work on different systems. My own personal war story is of a 20,000 liner developed on a 386 on an Irvine compiler, ported with 3 lines changed to a MicroVax using a DEC compiler, thence to a Vax using another DEC compiler, then to an embedded system using a DDC-I compiler. Was an AI to do anti-missile defence, people's lives depended on it. It's been in service since 1995. Cost less to make than the 7,000 lines of C in its test bed too. I've just help finish a 20,000 line piece of spaceflight avionics that makes not one Operating System call, even though it has 60+ simultaneous threads of execution. Oh yes, there's a shareware (or GNU licence? I forget) Ada compiler that produces Java bytecode, so will run on any Sun JVM.
So why isn't Ada-95 used by anyone? Because everyone knows it's too big (nearly as many keywords as C++,), needs a huge machine to run (bigger than a 286 running at 4 MHz - which was big in 1983 when Ada-83 was invented), it's designed by a committee (like Linux - one really good designer Jean Ichbiah, then peer review), and it's a product of the US Military (like Unix, and the Web - designed for not by). Oh yes, and expensive (GNAT is open source...) and uses a lot of risky concepts ( to wit, Operator Overloading, Object Oriented Design, Exceptions, all risky and untried in 1983 ). It's also obsolete, (the Ada-95 version being a little younger than C++). And it is used, for Avionics of all modern airliners ( Illyushin, Boeing, Lockheed, Airbus) and many satellites, railway- and air- traffic control systems, where quality is vital. It's not used much elsewhere, as there's a vested interest for software developers and programmers to keep software buggy (so they have job security) and quick to market (it takes a long time to develop reliable software).
So Ada's perfect, right? Wrong. It's just better than most general-purpose languages for many purposes. BUT It's not language of the month ( C# this month? ) so getting Ada programmers is very difficult. Though it's easy to learn, based like the similar Eiffel, Delphi, Object Pascal and Modula-2/3 on Pascal. If you've programmed hardware design in VDML, or used Oracle's access language, you've used Ada without knowing it.
Zoe Brain - Rocket Scientist
Intercal
"that's not encryption - it's a new perl script that I'm working on..." - from some Matrix parody
All you need is pointer access.
Java: Not powerful
C#: Powerful
C: Powerful
Perl: Piece of shit
Fuck you, you know I'm right. Multiple inheritance, OOP, bite my ass.
Borland has something that should be an exciting alternative. It is portable, meaning that if you buy both Borland Delphi and Borland Kylix, you can compile the same code for both Windows and Linux platforms.
I can't say for sure that it supports all the features that was mentioned, (since I haven't had the need to use all those features,) but I've seen a lot of them in use. As far as design is concerned, Delphi rocks. You can check out Borland Delphi here, and Borland Kylix here. Personal editions are available for free.
I've been maintaining a small perl laboratory application for about 1.5 years now... The story is simple. I got it up and running... FAST. It performs excellent. I used perl/Tk, which was joyously easily to learn...
Since it was written there have been a couple of weird bugs that were a bitch to track down, and involved a fistfull of punctuation to fix them, but that was surely worth the high speed of development and excellent string handling and interface with OS. Some of my heavy duty processing was written in 'C'... like maybe 300 lines in 'C' and like 3000 lines of perl.....
I guess the moral of the story is that mixing languages is excellent!
:-)
Correct, as long as you are not in a multi-threaded environment. If you are, then there will be synchronization overhead for all individual string operations, as even const methods can modify the reference count.
--Jeff
ipv6 is my vpn
one word.. Hypercard ;)
It sounds to me like your boss looked over the strengths of Java, C++, and Visual Basic and strung them together. My advice would be to look at the applications that you want to develop and the environment or the apps that you will be writing with this language and derive the requirements from that. While your boss is perusing through language evaluations you may want him to check out LISP, PERL, and perhaps a basic book or two on computer science machines and languages(these will probably be the most helpful, because they will tell you why languages have or don't have these features, and the underlying principles). You will need the books on Machines and Grammars, because you will probably want to correctly and completely define your language. And I would also suggest looking into a book on modern compiler design because you might even want to have a compiler for it someday ;-)
Probability provides a way of summarizing the uncertainty that comes from our laziness and ignorance (Russell & Nor
Why is it anyone asks for a language choice, the first thing that seems to come out of anyone's mouth is "Ooh, I know, Java Java Java!" Obviously none of these people have worked on a large (i.e. > 100 kloc) project in Java. The Java build system is abominable and dealing with build failures is nothing but a pain.
My company made the unfortunate mistake of trying to make a large project in Java, and have since learned from our mistakes. Our initial reason for using Java was that together through TSP Java could save us a considerable amount of developer time. We ended up going over 6 months past the deadline and a great deal overbudget because we switched the entire project over to C++ halfway through, after having developed some 750 klocs in Java. Why? Because the project, even being run through HotSpot, was so abominably slow it was unusable. It alone was consuming 700MB of RAM. A representative of our client during early alpha testing called it "Completely unacceptable." All of these problems necessitated the switch to C++.
The result of the conversion from Java to C++ is rather nasty, but it works. (The entire codebase was essentially rewritten, however solutions developed during the Java implementation could be used, although the programmers had to manually translate) Memory consumption is down to approximately 70MB and execution performance had increased at least an order of magnitude.
I suggest any of you who are working for a software development firm read Brooks "The Mythical Man-Month" and specifically "No Silver Bullet" in which he once again addresses the issue that there is no single means of reducing development time. Java certainly is not the answer everyone has been looking for. Above all else, Java does not scale to large projects. That's not to say that C++ does, or that C++ is a better language than Java. The problem is that Java isn't a language, Java is a language, a run-time system, and a security model, and the furthermore the Java language is inseperable from the other components.
The bottom line: Java is just not a good choice.
Two words:
Turtle graphics.
TO SQUARE REPEAT 4 FD 50 RT 90 END
Forget operator overloading -- Logo has built-in commands to _draw pictures on the screen_! Who could ask for anything more?
Support, Availability and Librariers
In reality these features are far more important than the language features, it' syntax, the look&feel, etc.
All successfull languages have these, a strong community thats behind the language (support), at least one free as in beer compiler, and dozends of libraries written by the community backing. These things is what one should consider more important than the ohhhs and ahhhs the language itself offers.
Look there are at least a dozend "experimental" languages that are really superior to the list you give, but the compiler might not be yet that mature, only the standard library exists, etc.
C is inferior, C++ is even more. But why do people use it? Because it's always first on the availability list for new techs, libraries, targets etc.
--
Karma 50, and all I got was this lousy T-Shirt.
My experience as long time professional developer:
For small to medium sized projects use Visual Basic, PHP, Python or Perl.
For medium projects consider Delphi, Python, Java, C#. But know that Java and C# are slow compared to native machine code.
For large projects consider C++ and Ada95. Both compile to native machine code. Use C++ because of the many tools available for it. Use Ada95 because it was designed to write reliable long-time used software in large projects. Ada95 can be compiled to Java Bytecode, too (with JGNAT).
Note: An IT professor told me that there is no 100% error free C++ compiler in the world! AFAIK only for Ada 95 exist valided error free compilers. There exist very good development tools both for C++ and Ada 95.
http://www.gnat.com
http://www.adapower.com
There is a programming language called "Self" which is even better than either Smalltalk or Java. And since a few month, there is a Linux port of it. Check it out at: http://www.cichon.com/self/
take a look at visualworks smalltalk and pythonworks.
I don't know anything about Eiffel and C# but here's what I can tell about the others :
intuitive and easy to use IDE :
yes : C++, Java, VB.net, PYTHON
simplified GUI design and event handling :
hard to answer this one.
advanced error handling :
all, including PYTHON
advanced object oriented design including multiple inheritance :
no : Java
yes : C++, PYTHON
abstract classes :
yes : all including PYTHON
garbage collection :
yes and not efficient : Java
yes and efficient : PYTHON
no : C++
full support for operator and function overloading :
no : Java
yes : C++, PYTHON
portable (at compile-time) across various platforms :
yes : Java, C++, PYTHON
no : VB.net
As you can see, PYTHON is THE language you need. For GUI programming, you can choose between :
wxPython, Tk, anyGUI
Hi
The list you mention above. Try to compare that with Smalltalk, and I think that you have a match. Last time I checked it fulfilled all the criteria. Plus you have the added benefit that this language have been around a whole lot of years, in fact it is older than C++.
Regards
Can you state (actually write down) your reasons for all these "needed" concepts?
If not, you might want to look at Teaching programming as an engeneering discipline for a a well-done introduction into programming concepts and when to choose which, and why normally the least complex feature that does the job is the best one, and why this is as true for programming languages / concepts as for the rest of the world.
Hopefully you can choose wisely after that.
Cheers, Mathias
He didn't say choose a random language then work arround it so that it solves your problem. He's approach is correct. Maybe what you meant was: add to the prgram goals to be easily maintained (language supported in the future).
unfinished: (adj.)
A powerful Swahili.
The most important feature being the type system. A strong type system really helps the developpers (despite what students are thinking). And with type inference, you don't even have to bother giving writing the types...
I think that OCaml a language made at the INRIA is one of the easier language to use. It's functional, with higher-order functions, strongly typed (with polymorphism), and have a good system of modules.
It's a language of the ML family (like SML), that's available for nearly all platforms of development. It can compile to byte-code or native code, and behaves well in programming contests and benchmarks !!!
The code is efficient, and easy to write. That's definitely a good choice. On the drawbacks side, I must admit that there are not much library and API written for the language (comparing to perl)...
Reference linking does.
Native complex number, vector and matrix support would be even better for a couple a reasons:
No need to create/support/messing up your own math libs.
All mathematical code would be compatible.
Native types are faster than overloaded self defined types.
No contest. Common Lisp is simply the most powerful general-purpose language there is. Procedural? Check. OO? Check - probably the best OO system on the planet, too. Functional? Check. Bizarre Lispy stuff? Check. Best IDE On Earth? (XEmacs) Check.
"Overrated" is one of the mods that can't be metamoderated, IIRC, so should be used with care and responsibility.
Perl actually has everything you need - except for GUI things, but you can use some toolkit to build GUI e.g. something like glade-perl but more portable solutions.
Smalltalk Squeak offers the ability for rapid prototyping and it is quite fast (more than java in my own opinon).
A commercial solution is Visual Works or Dolphin.
Try Squeak
-- Giovanni Daitan Giorgi http://gioorgi.com http://www.siforge.org
> Reliability - I've had JVM's cransh on me, run out of memory
:-)
> inappropriately, and have other ugly problems.
Many companies runs important web applications on Java platforms. I
think you can rely on the latest JVM's.
> Consistency - I've found far greater consistentcy in the behaviour,
> performance, and reliability of Perl across platforms, than Java.
Perl has consistently worse performance than Java for typical OO
applications.
> String Manipulation - In the majority of applications I've come
> across, *especially* web application, most of the work you end up
> doing is string parsing and manipulation.
Ok, if you do very much string processing this might be a valid
point. But this dont apply to most applications. Typically the Java
regexp packages which is part of JDK 1.4 is enough. If 0.01% of your
application is string processing it's not justified to have special
language constructs for it.
> Open Source - While Sun talks a lot about being open source advocates,
> Java's source is far more restrictive and harder to get or legally
> use, than Perl's.
Good point. Java should really become open source.
> GUI - AWT was efficient, but hard to use. Swing is very cool looking,
> with great features, but *slow*. Perl/TK is fast, efficient, portable,
> easy to use. It's by far my preferred rapid GUI environment.
But does it have the power of Swing? And Swing is really fast running
under JDK 1.4 on my Win2k computer.
> Multithreading - This is actually one point where Java shines over
> Perl. Perl has no standard multithreading, which truly, truly, sucks.
Agreed, multithreading is a vital part of any modern application.
> Elegance - This is another area where Perl fails, but another area
> where it doesn't matter
I dont agree. Simplicity is very important for code maintability. Java
code is very easy to read for a person that hasn't written it.
It is absolutelly useless, and dangerous too, to choose a development platform before addressing the nature of the problem. There is no language and development platform suitable for every class of problem, no matter what MS, Sun etc. are saying. Another issue you should address your development process, and how the various development platforms suit in the process.
That said, I suggest you may investigate also SmallTalk. Once you get the hang on the language, you'll find it has one of the most productive IDEs ever created.
You asked what is difference between a + b and a.Add(b).
;)
This is counterattack. What is difference between
a + b
and
move.l a, D0
add.l b,D0
; result in D0
I think it's around none, but still all don't program in assembler. I mean, every programming
language is kind of like syntactic sugar for
Turing machine, but still I feel better sticking
to something like C.
My C++ compiler uses that rule. When I try to compile code at 2am, the compiler will often be like, "yeah, right, as if".
"Well, put a stake in my heart and drag me into sunlight."
... does your boss have pointy hair ? Obviously your project will benefit from being 100% buzzword compatible. How many projects are you planning to use this language for ? Typically there's one major project, so fit the IDE/language to the problem at hand. I would suggest Java then C++ in that order. Oh, and make sure you drop an email to Scott Adams...
Never, ever lose a file again. Ever.
Delphi is worth more than a look.
I'm totally fluent in C, C++ and Delphi, but where I have the choice I always reach for delphi by preference. It can do 99% of everything you can do in C++, the 1% it can't generally being obscure stuff that you don't need in most projects - and I find code development far faster, main because delphi tends to stop you writing errors in the first place. You milage may vary of course but I'd estimate for me it takes about 20-30% less time to debug a delphi project than C++.
The second killer feature of delphi for me is also the availability of many thousand of additional components for every conceivable function in freeware to fully commercial versions. Most also come with full source code - not Open Source, but pretty damm close.
Finally if you really need C++ code for anything then C++ Builder compiles to the same intermediate code as Delphi and from V4 onwards it's been reasonably easy to combine the two - either directly linking an object file or by the more traditional dll route. Both C++Builder and Delphi can happily debug inside a dll running from a project created in the opposite language.
Here is a paper that describes a Java Virtual Machine written in Java.
Implementing a Java Virtual Machine in the Java Programming Language
boost has a list of how close each compiler gets to supporting C++ properly.
http://www.boost.org/status/compiler_status.html
EXP takes only one argument, and + takes as many as you want. So the expression should be written:
(/ (+ expt a b) e) (* c (+ d b a b)))
The perfect programming language IMHO would be a mix of Java, Ruby and
... } creates a closure object, type of parameter p is infered by compiler
Smalltalk. It would have the following features:
- Static, strict typing but with dynamically checked casting. This
would make the compiler detect many common programming errors.
- Single inheritance and interfaces.
- Generic types. Very useful for collections etc.
- Smalltalk blocks (also called closures). These would passed as
normal objects to functions. Allows you to write very short, readable
and powerful programs.
- Common language constructs like for, while, foreach. Closures can't
replace these in a good way.
- Types of local variables should be automatically infered when
possible.
- Syntax would be a mix of Ruby and Lisp. Clean and easy to read.
- Strip away all unneeded features.
An example:
# Generic type
class Vector
# Fields are private unless otherwise stated
fields
items T[] = T[].new 200
size int
end
def add (item T)
items[size] = item
size++
end
# Type (T) means a closure which takes a parameter of type T and returns nothing
def each (fn (T))
# Type of item is infered by compiler
foreach item items
fn item
end
end
end
class MyClass
def do
# Type of v is infered by compiler
var v = Vector.new
v.add (Point.new 10 20)
v.add (Point.new 20 30)
# {
v.each {p: p.setX (p.getX + 10)}
end
end
Good developers automatically do their own memory management. It also depends on whether you can control the garbage collection - I have no problem with automatically removing allocations when a specific object is destroyed, but do not like systems that try to figure out if you still need something; it's too easy to end up with thrashing.
Multiple inheritance is seldom required, but of course you want it when you need it.
Operator overloading too, but more importantly it gives you sensible operators instead of having to make up function names. I see no reason for this to be removed from a language, it should be there if you want to use it.
If you're looking for the best development environment then you'll probably want Visual Studio either using C# or C++.
What is up with this 'Swing is slow' crap? I know Swing is _slower_ than native widgets and even AWT, but it's not *slow*. After the initial JVM load time, I always had more than acceptable performance on my PPro200/64MB, even when using complex Swing-based GUIs, and I highly doubt that any business undertaking a supposedly massive new project is going to be sitting around on anything that gutless.
my sig's at the bottom of the page.
All serious next-gen GUI platforms are Unicode now. If you're not using C++ for other reasons, don't pick a language that isn't fundamentally Unicode-based if your goal is GUI apps.
Ruby is like Perl. It's for parsing and filtering byte streams, and like Perl it's great for that sort of app.
Such languages are not ideal for interactive GUI apps that are all about visual display and interaction. Go for Java or C# or VB.Net or C++/KDE and forget the MI or overloading nonsense. That's not how you pick a language.
"Those who have never entered upon scientific pursuits know not a tithe of the poetry by which they are surrounded."
I am a cross platform developer. There are different tools for different jobs.
Example: Would you use C++ to handle web forms? Would you use Perl to build a GUI for a Database front end on Windows?
The buzz words are that, buzz words. When deciding on a devlopment enviroment the 3 most important things are:
1) Platform and Portability.
2) Time of Development.
3) Scaling and performance.
The request you are talking about sounds like a bullshit buearacratic crappy request from bored management.
Run away, Run away!
...for a number between 3 and 10 that's divisible by 3 and prime.
Show your boss a list, with what they do and don't offer. But you're not going to get all those things in a language that is widely-used.
By the way, I happen to like the way Java and C# do things with no multiple inheritance. Instead, you use interfaces, and you end up avoiding a lot of potential headaches. GC handles memory for you, etc, you have a modern, rich library of tools included, etc.
Donate background CPU time to fight cancer.
I'm not a very brilliant coder, but i have played with Microsoft VB, MSVC++, Borland Delhpi, Borland C++ Builder, and at last on linux, using GCC, Glade and Anjuta. Conclusion: Microsoft Tools are shit worth. They arent easy to use. In a early beginning they may be, but when the code starts growing, it gets very hard to maintain it. The best experience, regarding productivity ,i got with Borland C++ Builder. Delphi is quiet good too.
Personally i feel more confortable with the latter (GCC + Anjuta + Glade), but that wouldnt be and option for Windows (l)users.
bye.
I haven't seen any Swing apps that I would consider "peppy" by any means, even on reasonably fast hardware. LimeWire, for example, is what I would consider one of the premiere deployments of a Swing-based application. It looks great, works well. But when you click on a tab or something, you have to expect a noticable delay before the screen updates.
Usable? Yes, most of the time. Fast, no...
-me
Love many, trust a few, do harm to none.
"Oppression and harassment is a small price to pay to live in the land of the free." -- Montgomery Burns.
Still people around? There is probably more ObjC programmers in the world today than ever before, MacOSX is based on ObjC, a lot of old mac programmers are currently learning to use ObjC.
But at least C programmers are going to get to 2038 this century. If you start arbitrarily replacing nice, high-speed integer types with "multiple-precision" integers, the performance hit you're going to take is going to be huge. The vast majority of the time, overflow is not an issue in C or C++, and the nature of their integer types is advantageous. If overflow is an issue, you're probably already using a dedicated maths library that takes care of these issues anyway.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
Who said the compiler/runtime environment has to be completly stupid? It can use basic integers as long as there is no overflow and revert to arbitrary integers, compile separatly those cases, or just in time. It's not like we are absolutly forced to use 70s compiling technology, we can use more clever technology these days.
The vast majority of the time, overflow is not an issue in C or C++, and the nature of their integer types is advantageous.
Overflow is always an issue when you do maintenance, some day in some case. Just let the functions/data structures byt used by someone else in some other context or with different input (as they usually will, one day), and just wait for the catastrophy.
Actually, Ada fit the bill, except for multiple heritance. Although that could be emulated through generics and Ada's package feature.
I know, people start throwing things at you when you mention Ada. But how many of those people have actually used Ada95 and not the old obsolete standard...
Also compilers for Ada aren't that expensive nowadays, they even come for free (speech). Soon a part of the gcc 3.0 branch (keep up the good work GNAT!).
Au revoir
If you use strcat with any data that originates from the outside world, you are asking for a buffer overflow and your program to be compromised. See all current C programs for examples :-)
C-Hash fail on the cross platform (unless the M$ shills in the audience can point me to the respective Mac || *NIX compilers for them AND assoc. libraries) Keep a close eye on the Mono project will be shaping up to be a nice cross-compiler for C-Hash (it can already compile itself). http://www.go-mono.com/ -- Andy Jeffries Linux/PHP Programmer
-- Andy Jeffries Scramdisk for Linux (Change the orgy to org to reply)
intuitive and easy to use IDE;
emacs + perldb; cvs co, cvs commit
simplified GUI design and event handling;
use CGI; while() { s/INPUT NAME="(\w+)"/INPUT NAME="$1" VALUE="$$1"/gi; print; }
advanced error handling;
eval { fail; }; die "failed: $@" if $@;
advanced object oriented design
package Object; use Tie::Hash; my @ISA=qw(Tie::Hash); 1;
including multiple inheritance,
@ISA = qw(Tie::Hash IO::File);
abstract classes,
use Tie::Hash;
and garbage collection;
{ my $x; }
full support for operator and function overloading;
@ISA = qw(Tie::Hash);
sub STORE { warn "Here!\n"; shift()->SUPER::STORE(@_); }
and portable across various platforms.
unix, Win32.
I think, therefore thoughts exist. Ego is just an impression.
I quite agree with the PFM comment way back there...
All of these "requirements" look interesting. I'm just curious where they came from.
Apart from the GUI design and functional requirements, a user couldn't know or care whether it was written in Java, C++ or carved into a piece of wood. Not user requirements, then I'm guessing.
Why do you need operator over-loading and multiple inheritance? Java can simulate multiple inheritance with interfaces so it's looking like the most logical choice.
These kind of "requirements" are either from :
A) Buzz-word drunk PHB who doesn't really have a clue, in which case use Java (or actually what ever you want) and s/he won't be the wiser
or
B) Some first-year or high school lame-o CS essay project question, in which case, stop trying to get us all to do your homework for you.
As a developer and a manager, I can't see how all (parts maybe, but not all) of that could come from your "boss" or any requirements docs I know of....
I have to ask, What about the target platform? I guess I think this way b/c I'm an embedded developer (C & asm), but IMO, part of your decision should be based on the constraints imposed by the hardware on which the software will be running. As previously mentioned, your boss likely already knows what he wants to hear based on the laundry list of confining requirements. It's odd to hear, "I want to the solution to my problem to look like this" rather than, "Find the best possible solution to this problem using the resources you have available"
------
http://www.geocities.com/fbiwood
Only if it knows at compile-time whether or not the numbers might overflow. Otherwise, one way or another, you're going to have a big run-time hit.
No, it's not. My little for(int i = 0; i < 10; ++i) isn't going to break any time in the future due to overflow. A count of entries in a database might, but you shouldn't normally be using raw types for specialised values anyway. Your reuse argument is fallacious simply because reuse itself is largely a fallacy outside of library code, and library code should be designed with robustness in mind anyway.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
Here is some more info on Delphi.
;-)
.NET. In these cases I know Java is much better at server side internet development, its Servlet technology and wealth of APIs kick ass. I am guessing that .NET will be very good. Guess what? .NET, and C#, was co-designed and implemented by Anders Heiljsberg, who is the father of Delphi (and was hired away by MS in the 90's to work in R&D, Borland sued MS over this). Did anyone read the C# specs? People call it Java, but do you really wanna know where the idea of properties came from? ;-)
Compilation times. Delphi has everyone beat. Delphi, according to Borland themselves, compiles 4 million lines of code per minute!!!! But don't take my word for it, try it your self. I have seen a half-a-million LOC project compile, on a GHz Pentium, in about 30 seconds!! C++ will never, ever, come anywhere close to that and it is all because Object Pascal syntax is relatively simple. Look at C++'s syntax and sematics. It's complexity limits how fast you can parse the code. Delphi by default doesn't show compiler statistics because for the average program you are working on as soon as you click the compile button the compilation is already done!!
Because of blazing fast compilation times one will definitly get in the spirit of using the debugger. First, you will get used to doing full recompiles once after you implement one method. Then you will get use to using breakpoints and watches to find bugs. I love using breakpoints, watches, evaluations, etc. It is the way to go. However, Visual C++ fosters bad debuging habits in the form of that stupid TRACE macro, or the Win32 API call OutputDebugString. It is like using printf to figure out the state of your program to try to figure out the bug.
I apologize for mentioning Visual C++ so much. I would love to use GNU C but professionaly speaking the only jobs I work on insist on using Visual C++, a brand name standard. Besides, most of the Linux people I knew prefered vi or emacs, hardly an IDE to the likes of Visual Studio and Delphi. Yeah, I know there is KDevelop and such others, but they are not as nice (and I was nausiated by the fact that KDevelop is literally a Visual Studio clone right down to also providing a Doc/View architecture, which is a bad architecture). On a side note though, I did try the Vi OLE control for Visual Studio because I do love vi alot
There is no Debug mode vs. Release mode in Delphi. Not that it was a bad idea but MS dropped the ball on it and Visual C++ has made Debug/Release mode style development a pain in the ass! Delphi doesn't put debug symbols inside your executable. Instead it keeps everything inside extermal files (.dcu files). When you are finished debugging you just had your executable off as is. Actually, there is a sort-of release build in the form of "turn of assertions", but this is not the same as Visual C++ release mode where the project settings are very different from Debug mode.
Last but not least, Borland is a company who, like Apple, is sticking around for quite a long time. People think they are going out of business, but they are not. So company support is there (managers like to hear that). Also, just like there is a Linux community, there is a Delphi community, full of resources, reusable code/components, and friendly developers who are willing to help you out.
On the negative side, if you are going to do some internet development then Delphi may not be for you. I have not used Midas or VisiBroker that much and I do not know how they truly fare against Java and
Nicholas
Is there a language available that has all of these features?
.NET framework (based around XML) supports all kinda funky cross-platform technologies such as SOAP and UDDI.
:)
Yes. Isn't that what VS.NET is supposed to do? I mean, you can use other languages Class files in C#, ASPx etc. And the
But would anyone ever admit that it was this
"Never let the truth get in the way of a good story..."
1) having to distinguish between different kinds of ownership means you have to restrict your design to fit the memory management model. This is progress? In Lisp, it is relatively common, for instance, to create circular lists to represent arbitrarily-long periodic sequences. With reference counting, your "list" abstraction either isn't abstract enough to handle this, or this usage has to be forbidden or made a special case.
2) overhead at assignment: this is exactly my point. The reason you go to GC is that assignment is common enough that you can't explicitly keep track of ownership without making a mistake or going crazy. In reference counting, you spend time incrementing and decrementing counters even if the thing never becomes garbage. An object only becomes garbage once (ignoring certain finalization or "weak pointer" issues), but you pay many times.
It basically boils down to this: GC was basically invented by and most researched by the Lisp community. Not a single Lisp implementation I know of uses reference counting because its run-time performance is dominated by true GC.
It's truly amazing to see the turnaround. The beef against Lisp used to be "perhaps powerful, but too bloated and slow." Now, 20 years later, Lisp has gained (in relative terms) in speed by aggressively pursuing compiler and GC technology, and has (in absolute terms) stayed about the same in memory consumption as RAM prices have plummeted. Now we find out it is all right to give up speed and memory consumption as long as you support ugly notation that has to use every punctuation character in *at least* one way.
1> intuitive and easy to use IDE;
Not a language feature. Yes, some very nice IDEs are available to support various languages - but this would be like using your word processor to generate documents in English, Spanish, or German...
2> simplified GUI design and event handling;
Not solely a language feature. Most modern languages do not (as a rule) incorporate GUI code into the language base. Many do provide very good libraries to support these features - some libraries available for various languages are better than others. Additionally, a lot of modern GUI design is handled by the IDE - so if you're looking for a WYSIWYG forms designer, that's a whole 'nother ball game.
3> advanced error handling;
Hey, wow a language feature. I assume you are looking for decent support of "throw -> catch" with possibly a "finally" clause in there. A lot of languages support this.
4> advanced object oriented design including multiple inheritance, abstract classes, and garbage collection;
Hmm - this really bundles a lot of things together. Any chance of getting these _prioritized_? Python or Ruby might be a good choice if these are equally important goals. Java doesn't much care for multiple inheritance - it can sort of fake it thru good design though. C++ has got multiple inheritance down pat, but that whole garbage collection thing throws it off.
5> full support for operator and function overloading;
Why? What does your boss know about the problem that you will be solving that will require this feature? I have used it on occassion myself - but largely I've found it to be a more confusing addition to a language, unless it supports it fairly ubiquitously (see Python or Ruby for ubiquity). In C++, overloading is just stupid - as you'll really want to explain what adding two new types together should do and make it perfectly clear to anyone else using that type.
6> and portable (at compile-time) across various platforms.
Compiler issue, not language issue. The question is whether a compiler exists for the language in question for your target platform. Sort of comes around to the IDE goals at the beginning.
This is a nice laundry list - but depending on the real problem at hand, you may only really need a few of these features. I'm guessing your boss would really like to have a "one language shop" that can solve a whole lot of different problems. An admirable goal - but not entirely realistic. Better IDE support is usually available for languages with good commercial support - C++, Java. However, both of these skimp somewhat on some of the actual language features your boss professes to be interested in. Python and Ruby both have all the language features you're looking for - but generally lag (comparatively) in the IDE department. Eiffel is neat - but again you loose out on multiple inheritance, and most Eiffel implementations are geared toward producing C/C++ code for compilation.
"Unless you have pretty strong performance requirements?"
Unless you have any performance requirements, more like.
Take a look at Jade. It was designed and built by Aoraki Corporation, whose previous succes was Link(?). This includes an integrated object orientated, transaction based, distributed computing alternative. Just Another Development Environment.
Is this thing ganna be run on *nix or winblows, I think that also needs to be taken into condiration.
Was it [list].append(x,y) or socket.connect(x,y), by chance?
[1](if (iscool '(L I S P)) (print "Kick Arse"))
Kick Arse
[2]
"The best laid plans of mice and men gang oft agley..." - ROBERT BURNS
if you need the long names to remember what you're doing, you're not a programmer, you're a monkey with a keyboard.
Yeah, languages like scheme/lisp let you do just about anything you can imagine. Because of their simplicity and completeness you can pretty much support any type of object oriented or other programming paradigm you want. This guy's boss seems like a typical nincompoop boss. He gives the guy a laundry list of buzzwords that he probably doesn't know the meaning of as criteria of a programming language to use for a (undescribed ) project. Bosses love buzzwords that they can impress their bosses with. This guy's boss ought to shut up, sit back, and let the people who know what they are doing make te decisions about language criteria.
Eat at Joe's.
Well if i look at his CV I think we will end up with C++. Not to mention he names it twice in the languas he looked at.
Next question:
what runtime libraries? What IDE?
Interesting, but it simply confirms my point (have you read that paper?); these people are VERY experienced Java developers, and they ended up with a product that runs THREE orders of magnitude slower than a normal JVM, and constantly had to apologize for shortcomings in the Java language. So, yes, it isn't impossible, but it can't be done quickly and well.
:)
I'm just sorry that they never had to build a native function implementation; from the paper, it sounds like they used the standard one, or made a broken look-up table of some sort. C has function pointers, of course, but what you really want is a jumptable of some sort.
pb Reply or e-mail; don't vaguely moderate.
"Better" doesn't matter. In how many markets for any type of product does "best" win????
Lisp is dead, even if its better. Learning it now is a waste of time.
If shared ownership is not a good model (which it is not with any node based data structure), then don't use it. For a linked list, the obvious ownership strategy is for the list to own the nodes.
In reference counting, you spend time incrementing and decrementing counters even if the thing never becomes garbage. An object only becomes garbage once (ignoring certain finalization or "weak pointer" issues), but you pay many times.
Incrementing and decrementing counters is a very fast operation. It's only a performance issue if your object can be copied very quickly. The main overhead issues in reference counting are memory overhead (for very small objects), and multi-thread overhead.
It's truly amazing to see the turnaround. The beef against Lisp used to be "perhaps powerful, but too bloated and slow."
There's nothing wrong with LISP, but it's kind of silly to compare it with C++. The design goals, and hence the benefits are not even moderately similar.
Our web surfing, buzz word concious director threw that hot potato at us once... What a moron. Silly us for even fielding the question... Now, if you'll pardon me, I'm off to Sears to find a tool that will replace all the others in my shop. I will be the envy of my neighbors...
therefore, you should adopt a problem-solving oriented, buzzword-free approach
What sort of features? How about macros (we're talking R5RS here)? Macros allow you to define new language syntax. For example, if macros were available in C (no, #define doesn't even come close), you could use it to add new language features. Like say, a new type of switch statement that didn't require you to end each case with break.
But what about all the nice features you might find in more conventional languages? You want a nice IDE you say? A GUI toolkit? Objects? You want DrScheme. It offers everything more mainstream languages might offer and more.
Okay, Scheme and it's other Lispy friends might not be the right choice for you, but they're definately worth looking at.
As for the monkey with a keyboard thing... mmhhh... could you define what a real programmer is to you first please?
Overcaffeinated. Angry geeks.
My language is bigger than your language.
Please, do we need such a post? I am surprised nobody posted that assembly would be a good choice; your limitations will be minimized.
Slashdot readers as a whole write in just about any language out there, and everybody has a reason their favorite is the best.
As many have pointed out, without a problem spec, the choice has little to go on. In general, pick a language that either has a base of programmers who are familiar with it, or that is easy to learn. That way, you can find employees. Judging from the fact that your boss's requirements are not satisfied entirely by any language, you should hope his requirements for employees are not so.
Programmer Requirements:
Doesn't write bugs
Doesn't complain about vague specs
Is vigilant about maintaining perfect documentation
Doesn't blame hardware
Shows up on time at 7:00am
Displays elegant mastery of multiple-inheritence, however is incapable of preventing leaks without the help of a garbage collector.
Doesn't waste company time reading SlashDot
Best of luck to you.
Although I am against the non-commercial restriction of GPL. Hmmm, Perl is GPL, isn't it?
Perl has the Artistic license which essentially says you can choose whether you perl modules / perlX patches are GPL'd or BSD-like (don't remember the details of the more free-varient).
So GPL advocates can promote their anti-pay mentality, and businesses can still make money.
-Michael
-Michael
I was under the impression that Jikes is faster because it's iterative. (Well, it's probably a bit faster anyways.) It's not entirely compatible with javac though, eg you can't switch/case on bytes in Jikes but you can in Javac. I don't think you're supposed to do it however.
Perl 5 will not handle most of these requirements. It will handle about a third of the requirements. Simplified GUI design? Perl doesn't even have a concept of a GUI built into the language, nor an event model. Advanced object-oriented design, my ass. Perl's OO lacks basic data hiding features (public / private / friend / package / protected type modifiers on data members and methods) on purpose, because Larry Wall doesn't think encapsulation is a good idea (it restricts what a developer can do). Operator overloading, AFAIK you can't do that in Perl at all.
Perl is very portable, has garbage collection, supports inline documentation with man-page and HTML doc generation, is astonishingly fast at text processing even with enormous files, and is great for system-level scripting.
It has exceptions, and is sorta-kinda OO (I consider encapsulation a must-have for any OO language), but the problem is, nobody uses either of these. Go look on CPAN, and decide for yourself whether that code is as object-oriented as the classes that come with Java, Python, C#/.NET, etc. When you use the Foo::Whatever module, the typical approach is to have it import a bunch of functions into your namespace that you can then use on a standalone basis. Classes should model real entities in the problem domain, but that's not how people use Perl classes... they use them as function libraries that have a bit of control over namespace importing. And of course nobody uses exceptions in Perl, falling back on C-style nested IFs from hell, or just not testing for errors at all.
Don't get me wrong; you *can* make objects in Perl (if you don't care about encapsulation), and you *can* use exceptions. It's just that nobody does, so any code you reuse will have a totally different design style that looks more like a monter shell script or C program than a robust, maintainable, well-factored OO application.
It's all about the money. I.T. is economical.
nothing else pays as well for so little input. I hate the work, I hate the business, I hate the people in the business. Nobody likes their job, so why should I bother with one that pays less if I have the skills to make more?
A real programmer, to me, is someone who thinks about what they code and who sometimes has to write a better way. MOST Java programmers just regurgitate library calls. That's not programming, to me. Guys who do lower-level stuff are programmers.
"software engineer", linguistically speaking, is analogous to "sanitation engineer". the terms have the equivalent weight. They were invented by people in those fields to make themselves sound more important. Don't bother arguing.
If shared ownership is not a good model (which it is not with any node based data structure), then don't use it. For a linked list, the obvious ownership strategy is for the list to own the nodes.
And if an object is in more than one list? It has to be copied anew? What if it doesn't make sense to copy/clone it? Clue: there is no single definition to "copy" which makes sense for all applications. The notion of "copy" has to do with the notion of "identity" which is not a fixed concept. Again, you are forced to fit your abstraction to the need to track ownership.
I'm interested in your comment that Lisp and C++ have different design goals. Common Lisp is designed to provide the programmer with a flexible, robust, object-oriented environment, suitable for large programming tasks. How does that differ from C++'s stated goals?
1) you are exaggerating the "big run-time hit." Testing for overflow in addition of fixed-size integers is going to be easily pipelined. Sure, when you actually overflow, you will have to branch and transform your representation, but the alternative was to get the wrong answer?
2) Your for loop example is exactly the kind of case that a compiler will optimize to be kept in fixed size registers.
As usual, we see the "New Jersey" design technique. Better to be "fast" and sometimes wrong than always right.
I find it interesting that counting the number of entries in a database is somehow a "specialized" operation. So anytime I want to count anything that there might be "a lot" of, I have to use some non-built-in multiple precision arithmetic package---who knows how well it was optimized, or whether it's buggy---instead of a vendor-provided, standard-mandated ability of the language?
It's the one that allows you to be more productive.
It's the one that has lots of code base for you to rip.
It's PHP.
With PHP-GTK you can create GUI apps. There's also a SDL port for you to do graphic things with PHP. Imagine wining that demo-competition with a scripted demo.
http://www.php.net http://gtk.php.net
Even Microsoft put a team of coders working on PHP for Windows. They even managed to create a couple of security probs there
I still think that java is too new to use for generic enterprise operations. I've worked with Java+MsSQL-server, Java+Oracle, Java+ANY GUI, and I've regularly found production flaws that we've had to work around. I'm sure newer versions of java fix many of the older problems, but the API dramaticaly changes so often that you're CONSTANTLY on the bleeding edge. Since they haven't given enough time for a given API to settle down across multiple platforms (e.g. open-sourced initiatives can't keep up), I doubt that Java will ever achieve robustness. To further the point, a new version of JDBC just came out with boat-loads of new untested features.
Java CAN work, if you pick a robust platform, a robust version and well-aged API components. But it's very tempting to use the latest / greatest, because functionally it solves your problem more efficiently, and thus you're prone to bizzar production-time errors (as I've encountered).
In comparison, the basis of the perl language only changes in the major version levels. And we've been at perl5 for a Very long time. Most of the change is in the CPAN modules, which given enough proving-time probagate down to the standard distribution. The changes to the core are rare (only in perl5.005 did threading / agumented reg-ex's really hit and thus cause some stability issues). Thankfully many of the features were off by default, and some (raw threading) have since been revoked. It's a VERY different mentality, than MS / Sun, who seem to want to sell themselves via feature-bloatware.
I would be very interested in seeing your benchmarking results demonstrating this. Part of the problem is that you're comparing apples to oranges.. You don't solve problems the same way in Perl that you do in Java.. Java is a forced solution (e.g. OO with method-based operations). Perl uses a combination of simple function calls, HEAVY use of low-level C-based functions, and a sprinkling of OO here and there - just to pretty up the API. Granted, OO on Perl 5 can be horrendously slow (especially if you have the inheretence-tree of java; given the linked-list lookup style method dispatching). But Perl's garbage collector alone puts Java to shame. My Apache apps with mod_perl never exceed 30Meg each (with large amounts of large-temporaries), while most of my apps never reach a meg in size. My Java-apps HAVE to start at a God awful size and are both CPU and memory hogs (non ref-counted GCing is horrid for page and cache thrashing). Yes there are memory leaks in ref-counting, but it's well known and designed for in perl5 APIs (or you spank the module writer). The only potential pausing that ref-counting does in perl5 is deallocation of massively nested structures. But then again, perl5 is more determinisitic than java (at least until perl6, but I won't get into that). We're not even going to get into the *cough* jit-startup time.
Again, apples to oranges. Perl5 uses strings as a fundamental data-type. Integers, floating point, exceptions, error-messages, parameters. Just about everything (short of tcl) is at one point potentially a string. While I don't know how intentional this is, this fact allows a dramatic efficiency when making string-manipulation the number-one priority for the language. While in Java you could apply a sequence of catch (ObjType1) catch (ObjType2), etc, which essentially becomes a switch statement, in perl you are relegated to if ( $@ =~
Thus, the power of the string can in no way be cast aside (simply because c, c++, java finds 5-10% use for it).
YES!!! There is more to Perl than Tk. There is Gnome, Qt, MFC.. The only thing I'm not aware of is Swing proper, but who cares, it's not a great design and buggy as hell!! (Maybe as of 1.4 the 1.2 features work properly, but not across all platforms).
Gnome even has a perl generator within Glade.. I find glade MUCH nicer than forte' (at least the version I last looked at).
I disagree. Multi-threading is inherently non portable. Personally I believe MT allows for bad design. The programmer gets lazy and just relegates tasks to other threads (ignoring the scalability and communication overhead). While certain classes of operations are more efficiently handled in MT (especially on MP systems), the majority of algorithms can have the highest in performance with single-threading. MT is great for response time, and it does have a certain elegance, but don't talk to me about elegance when debugging MT code.
That said, there is, of course, primative MT support in perl5, and perl6 will support it natively (though I believe (and desparately hope) that MT won't be required, nor activated by default). I say primitive, not because they're limited in functionality, but instead in efficiency (global locks, etc). I BELIEVE the stability is sound, but the CPAN library support is non-existant (just try and compile an Oracle DBD with use5005threads enabled).
Lastly, I'd like to point out that my disagreement is with the phrase "modern application". A modern _language_ should most certainly provide robust thread-like facilities(even if it's just virtual threading), but most certainly threading does not apply to MANY real-world applications. Take web-services for example. There is a big push for MT web servers.. Apache 2.0 is a good example (of course IIS has always had it). While MT allows rapid concurrent static content retreival, it has several costs with respect to dynamic content. First, it is less stable; one thread might corrupt co-existing app's memory-spaces. Secondly, designs that require MT are not easily segmentable. Apache 1.3 makes little difference whether the dynamic-app is on the same machine or on independent machines. IIS-modeled ASP servers are not directly translatable to multi-machined applications (without significant clustering support). Similarly Java servlets does not [natively] provide for much inter-process communication, except when mapping sessions to workers.
The point here is that even with MT, multi-processing solutions are still sometimes necessary (e.g. using serialized access to a common database is necessary for basic communications, thereby avoiding many of the advantages of MT). To further the point, Apache 2.0 prefers a mixed-mode, where there are several independent processes which can optionally run n-threads each. This gives you the best of both worlds; services that can take advantage of threading (like static paging) can, while the benifits of the age-old IPC-based single-threading persist. This also allows legacy apps like mod_perl to work (in ST mode).
A basic turing machine is simple. Care to say any kind words about it? e.g. there's more to the equation when deciding who's "best" for a task.
I agree with you, but with reservation; you can write bad code in any language. But more relevantly, you _can_ choose a coding style which is readible in perl assuming that the reader actually KNOWS perl.. This is the biggest falicy about perl. Most people that berate it don't even know regular expressions (or sh / awk). Once you know them, you understand WHY the syntax is the way it is, and understand its benifits. After using it long enough, most of it is intuitive. I regularly read through CPAN code and always understand everything EXCEPT the algorithms. (which are sometimes obtusely done). I have the exact same problems with Java, though often it's more difficult unless you have the java-doc window open with valid documentation. Inlined hash-based parameters blow the doors off positional parameters in terms of readibility. Sadly, Java provides no such capability; applying hashes actually draws out the code such that it's even more difficult to understand.
Similarly Java is so verbose, that the syntax often gets in the way of understanding. Part of TMTOWTDI is that you write the code in terms of significance:
die "something went wrong" if complex-bad-condition;
Is more intuitive than:
if (complex-condition) throw bizzar-sounding-exception;
While at the same time the Java-style syntax is still an option.
Further, whenever I've had to write parsers, the intent of the VERY LONG code is anything but obviously; to say nothing of the debugging.. A simple regular expression (which is only recently standardized in java.. And oh, by the way, they used perl5.004's syntax) takes less than a line and is completely intuitive once you trace it out. The point is not to bash Java, but to praise the foresight of perl, awk, etc. for their designing languages that very nicely solve problems. Java started with your basic premise (the elegance and predictability of lisp / minimalized base operations), but found that this was not useful in the real world. They had to incrementally evolve, to find their real equilibrium (demonstrating that they missed their initial target). Now they're at v2.0 and have several "bolt-ons" which limit the elegance.. C# basically looked at Java and said, ok, we'll do java freshly (avoiding compatibility issues). Perl is a frankenstein of a language, but not because it missed it's initial mark, but because the world evolved (from c-based procedural, to OO. From quick-and-dirty RAD to quick-and-efficient web-apps. From no-holds-bar speedy core to user-extensible cores). That perl has lasted this long brings to mind the x86 processor (which even today has no death in sight). perl6 is going to be a complete rewrite, and it'll be sad to see the last vestigates of that genome dissapear.
In short, Perl gives you the ability to write "understandbile" code, and peer-pressure / corporate mandate should be enough to enforce this. The only thing left is the enlightenment of the developers. Let the best tool win the contract for my job.
-Michael
-Michael
I program my toaster in PHP, it owns your base. All you other punk ass languages are faking the funk. You better bow down suckas. *Zip* BOOOM!
Not at all. More "You can build something safe on top of something fast, but you cannot build something fast on top of something safe." We're only talking about the foundations here; you can build what you like on top of them (if they're sufficiently flexible).
Again, not at all. However, it is prudent to wrap any non-trivial type in at least a typedef (in C/C++ terms), for maintainability's sake. Using int or double everywhere is like writing code full of magic numbers.
There is nothing to say that you must use a custom type for these, rather than just an alias to a built-in one. However, the indirection provided by the alias typically costs one line of code, and in return increases readability and makes you future-proof. If your database code is written in terms of index values rather than ints, then if overflow is a danger, you can always turn index into a big number class transparently, or into an optimised class that uses int wherever possible but checks for overflow and switches if necessary, or whatever else you want to do.
This approach is far more flexible than forcing anti-overflow logic onto me whether I want it or not. I know better than the programming language what my requirements are and what kind of data I'm going to be processing; I don't want to be second-guessed, thank you.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
It won't be long before hardware is 100x faster than it is now. Speed will no longer be a topic of discussion for any language.
Neil
http://www.hpl.hp.com/personal/Hans_Boehm/gc/
rant
Take a look at the Flyweight pattern in Design Patterns book. Yep, a model of a word processor where every single character is represented by a very light-weight reusable object. Interesting stuff, though I can't say it convinced me completely.
list.append, indeed. (the socket.connect one slipped me -- good thing I used that qualifier!)
>Democrats were/are proponents of our failing >educational system in this country. Are they the >ones to blame becasue a perticular school in >Alabama sucks?
Being the proponents of a system is different than being a proponent of how that particular system is run. Democrats are not 'for Education' per se or even for the educational system as is. Are they partly to blame for the current condition of the educational system? Sure. ( Incidentally, so is Texas's publishing policy which uses standardization of texts statewide to influence the books published and sold in the rest of the nation, but that's another story. U.S. Textbooks have gotten absolutly horrible ratings from those assigned to do so)
Blame alone dosen't really suggest a course of action until it's focused on a particular policy.
It makes sense to blame people only if they're consistent advocates of a particular, harmful policy, and then argue for the reversal of that policy.
In this case, energy deregulation and lack of government oversight were the policies which I take issue with.
>2. Who was in a position to know Enron's actual >financial condition?
>Lots of people. So what???
So they should be subpoenaed at the least. And what's all this crap I'm still hearing about the lincoln bedroom?
Republicans have consistently let campaign donors write actual legislation and choose cabinet members. Virtually all of Bush's foriegn diplomats were either donors or friends as opposed to Clinton who chose mostly professional diplomats trained to do their jobs (less than 1/3 donors or friends).
Just another case of the pot calling the kettle black.
"You can build..."
So you are talking about roll your own. It is NOT EASY to write a high-performance multi-precision integer solution in C that smoothly integrates with fixed-precision integers and which you can use with the ease of a typedef. It needs to be built in the language from the start, not bolted on afterwards.
If you want true high-performance switching of integer sizes, you need to have the *machine code* tuned for the processor to make the common case fast, and the uncommon case still reasonably fast. You really can't do that in standard C, much less by including the overhead of C++ classes in a roll-your-own implementation. Much better if the person who wrote the compiler wrote it to emit the best code for these cases, then to have to persuade the compiler to change your C into the same code.
And in the case where you want to optimize away the overflow checks, the compiler is a lot more careful in the constraint analysis, and can check *every possibility* *every time*, not just when your gut tells you you should.
If you want to spend your hours acting like a Common Lisp compiler to get robust overflow protection, feel free. But in the 21st century, I'd rather a compiler do the work than have to do it myself.
Secondly, Perl OO is conforming with Perl's TIMTOWTDI (There Is More Than One Way To Do It) design goal. While native Perl OO is pretty casual in its encapsulation, if you want Bondage-And-Discipline OO, you can use one of Damian's Class::Classes, with Contract programming or Data hiding enforcement or ... there are at least 6 choices. At least one should have multiple inheritance grafted on, although I can't recommend actually using multiple inheritance of implementation (except maybe in CLOS); multiple inheritance of interface (like in Java or COM) seems safe enough.
Likewise, anything else Perl is missing can be added via other modules -- many of which probably already exist, but can be custom crafted on demand. This includes Operator Overloading, which can be added, for whatever cases are required, using Inline::Filter -- using the full power of Perl as a macro-language for Perl, to enhance the syntax as desired. Not for the faint of heart, but a good Perl consultant can whip it up for you.
GUI's -- Yes, it is true development of GUI's isn't built into Perl, unless you count the TCL modules as "built in". Ability to do GUIs does seem to run counter to portability (at compile time, whenever that is); this requirement may force your choice on Java. Perl has Gnome, TK/GTK, and Curses interfaces already. See CPAN
Thirdly, Perl6 will likely be mostly functional before .NET this summer, and _will_ be all things to all people, thanks to the modular bolt-on accessories. (Operator overloading will apparently be a part of the PARROT runtime for Perl 6, as well as in Perl6.)
Fourthly, Reality Context: Did The Boss specify that you had to be able to hire programmers in this language? Cheap or expensive? With lots of experience or not? Here or offshore? Eiffel's a great language, if you don't mind all your staff speaking French.
Regarding the evils of Lisp ... see the story of Yahoo!Stores Paul Graham: Beating the Averages or /. #1539239
for a real world $ucce$$ story with Lisp and why; amusingly, he turned up just last week /. #1917202.
-- Bill
Actually, Java supports multiple inheritance through the use of inner classes.
No. It's just a condition test which, when there is no overflow, gives no data dependancy, and is on a "non-predicted" branch. Probably half of the time this cost you 0 cycle (done in parallel on unused CPU units), and maybe one or 2 cycles overwise. It's a minor hit, unless you are doing intensive calculations, so intense that you must do loop unrolling, and should consider SSE and assembly. Overflow checking should definitly have been provided at least as an option in C and its absence is a major design blunder.
No, it's not. My little for(int i = 0; i
Yes it will. Your little loop should be written "for(int i = 0; i Your reuse argument is fallacious simply because reuse itself is largely a fallacy outside of library code,
You don't reuse code, fine, but it doesn't change the fact that maintenance argument is definitly right. In fact the example you gave with a loop is a perfect illustration, since I met exactly this problem: the loop was done with "unsigned char" index, I changed in the "config.h", one of constant (maximum number of some entries), and this resulted in a computer hang (since it was in a device driver). Diagnostic after much time wasted: infinite loop, with exactly your little loop (loop index was 1 byte, boundary was 'int' 4 bytes and >= 1000).
That's a good point, but I did not want to elaborate on the issue that far. I just wanted to keep to the stereotypical best uses for particular languages to make my point.
Your other comment "at least on current archs" is interesting. I have spent time day-dreaming about a system where Lisp is the "native" language. An architecture where recursion is somehow done naturally and, of course, as are lists. Though, I am not exactly sure how'd it be done or what advantages would exist...
Why bother.
You can store reference counted objects in lists just fine. Or you can store non-reference counted objects. Or you can store garbage collected objects. Or you can store pointers. In fact, you can store just about anything besides objects with destructive copy semantics. All I'm saying is that the node structure of the list shouldn't be reference counted.
I'm interested in your comment that Lisp and C++ have different design goals. Common Lisp is designed to provide the programmer with a flexible, robust, object-oriented environment, suitable for large programming tasks. How does that differ from C++'s stated goals?
First, as stated, the goal is very general. It's all well to aim to provide the best of everything, but what design choices and trade-offs are involved ? Basically, the "goal" you've stated doesn't mean very much by itself.
Moreover, I don't believe that you're correct. Lisp AFAIK started out as a functional programming language, and Common Lisp added objects much later.
As for the design goals of C++, one of the major goals is compatibility with C. This was considered important for the language to be easily and widely adopted. A closely related goal is performance. Performance takes precedence over purity. Another goal is flexibility -- it is a multi-paradigm programming language, and has been from day one. This is in stark contrast with languages that claim to be pure object oriented.
Take a look at the Flyweight pattern in Design Patterns [amazon.com] book. Yep, a model of a word processor where every single character is represented by a very light-weight reusable object.
True, although that example uses the same object instances over and over. You ultimately only have 100 or so object types to represent different characters. I suppose that's what a Flyweight is (donno, have the book, never quite committed it to memory). Actually, the more I think about it, the more I think the approach is flawed. It might work for a small character set but what if you're using UCS codes like UTF-8? The only reason you would want to have an object to represent a character and not just use an integer would be if you wanted to actually control the rendering of glyphs as subviews of views. Even then it's probably not a good idea. Those examples are just examples.
What, did you learn programming from the back of a matchbook or something? Grow up and read a book or ten on real software engineering. It's headstrong turds like you that give us crashy suckware like Mozilla and anything from redmond.
The most powerful language is the one that can interface easily to another language, allowing you to "change horses midstream" if the first language doesn't do it all for you.
Put another way, the set of most powerful languages are those that can be used together. Anything with a binding for CORBA, COM, .NET CLR or anything similar will do the job.
sub f{($f)=@_;print"$f(q{$f});";}f(q{sub f{($f)=@_;print"$f(q{$f});";}f});
ADA is the best language there is. I regularly use JAVA and C++ and i know ADA beats the competition my miles.
Every new feature that you see in the modern languages today was in ADA years ago.
* better concurreny (protected types)
* better realtime systems( tasks)
* better exception handling(fail-safe systems)
* is a strongly typed language.
* better interrupt handling
* very early on introduced the philosophy of reusable code.
* had intefaces when java was still in its infancy
.....
and is used in: financial services, avionics, aeronautics, air traffic control, telecommunications, medical devices, power plants, railroads, astrophysics, satellites, and defense, to name a few.
If you are going to develop a realtime system forget about everything else... use ADA.
my two cents
Voltaire: God is dead.
God: Voltaire is dead!
I can't understand parts of your post because it obviously isn't formatted properly. However...
Not at all. C is a low-level language, and forcing the use of such high-level logic would be inappropriate there. On many systems, your arguments about performance are way off-base, and you would cripple it if you imposed such a requirement. You personally may write mainstream applications for Wintel or whatever, but many who program in C don't, and your reasoning does not hold for those people.
C++ is a higher level language than C, but your argument is still broken, since it would violate the "zero overhead principle". If you think having an overflow-checked integer type in the C++ standard library would be useful (and you make a reasonable case for it in this thread) then you can suggest it to the standards committee as a possible inclusion in the next version of C++. They know the library is currently missing several key features that weren't ready in time for the first C++ standard (regular expressions, UI, proper file system support, fixed-point arithmetic, etc) and they're open to suggestions for enhancements in the next version.
So let me get this straight. You used unsigned char as a loop counter, and now you're annoyed that it's messed up? Sorry, I have no sympathy. char types are not suitable loop counters. You should be using int or some custom type, unless you have a very good reason for doing otherwise (which you clearly didn't).
If you started forcing char types to do automatic overflow checking, you'd break text handling (particularly strings), which is what they're actually for. Don't blame the language for your own inappropriate use of its features (and ignoring the warning that would have been generated by every single C or C++ compiler I know when you made this error).
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
...until you wrote:
That statement is so completely off-base that I'm afraid you don't really know what you're talking about. You can use C++ templates to write type-safe containers and algorithms, but they're also useful for many other idioms (traits, metaprogramming...). Java interfaces aren't even close to providing equivalent functionality.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
jaoswald understands. :-)
In a GC system, the concept of ownership (from a memory releasing perspective) doesn't exist; everything is effectively owned by the GC. Most of what's being said here then immediately becomes a non-argument.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
I'm not talking about C, I'm talking about C++. And in C++, it's pretty straightforward to do what you describe. And it shouldn't be built-in to the language, because it doesn't need to be. Providing the optional facility via the standard library is a much better option for several reasons (notably ease of implementation, forward- and backward-compatibility and keeping to the zero overhead principle).
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
Every hammer and every nail are made up of atoms. So why not just put the atoms in place a more delicate way. I suppose we'd need colliders to break iron atoms off existing nails (one at a time of course). Maybe we could get the guys over at IBM to let us use their scanning-tunneling electron microscope so we can see exactly where we're placing the atoms. I suppose that after about 5 years of work, we could not only drive a whole nail, but also have it bonded quite nicely to the materials being assembled.
Pfft. No. The hammer is an abstraction of the solution. The nail is the abstraction of the problem. We create these abstractions because it's easier to work with larger elements than all the atoms in a system. We *could* code everything in assembly, but why would we do that? We could NOT code everything in Pure Lisp, for example. That's a programming language. Can is solve every problem? Absolutely not. Maybe with some hacking...
What it comes down to, using the wrong tool for the wrong job may still result in a solution. BUT, it will almost always take longer. If I want to add two numbers, I should probably not think about multiplying the two and then dividing by another number such that it produces the result of the addition.
Why bother.
He claimed that Common Lisp specifically (and not Lisp in general) was to provide an OO environment. From the history in the Hyperspec, object-oriented ideas in general were find their way into the Lisp world by the late 70s. While (as far as I can tell; I wasn't really old enough to be around the community at the time) the 1984 definition of Common Lisp didn't include CLOS, clearly people were thinking about it and the problems that had to be solved in getting an object system that would be as compatible as possible with the variety of object systems that had cropped up. (A little more information about this period can be found in Keene's book on CLOS, or in AMOP.) CLOS was officially adopted into Common Lisp in 1988 and appears in the second edition of Steele. It has always been part of the ANSI standard. Since the latter is what people mean when they casually say "Common Lisp" nowadays, I think it's fair to say that having OO facilities was a part of the goal of Common Lisp.
Also, in the history from the Hyperspec we find the following:
So at very least we have to conclude that by 1986 that this was one of the design goals of Common Lisp
The overhead of C++ is still going to be substantial.
Hint: how do you plan on detecting overflow on integer operations? Most processors have flags that you can branch on, but C and C++ don't offer language-level access to that functionality. The results of integer overflow are purposely left *undefined.* As in, no standard way to detect it. Every C implementation I've seen defines it as "silently truncate result and continue," with no way to detect it in the language.
Either you have to include assembly code in your C implementation (there goes portability), or you have to put a lot of tests in your common case to determine when the overflow is going to happen. That's a lot less efficient.
That's why this stuff belongs in the base language--they can do the processor dependent stuff right the first time.
I said "C" several times in the parent post where I meant "C and/or C++"; from my perspective, they are equally broken in this area.
Others are perhaps more qualified to comment on the history, but they've probably moved onto more productive threads ;-)
Part of the purpose of Common Lisp was to define a *common* standard for Lisp programmers. The language had branched into a lot of different dialects, each with their own quirks. Some of this was just random evolution, some of it was alternative ideas being explored.
My understanding is that OO was one of the areas where alternative ideas were being explored. There were a large number of OO extensions to Lisp that had been developed (e.g. Flavors) by various groups, and there had to be a reasonably large amount of discussion to determine which approaches were really valuable enough to standardize. CLOS was determined to be powerful enough to accomodate any important feature of the other approaches, so it could be standardized on without crippling some set of programmers.
This is very different than the C++ standardization approach, where, as far as I can tell, only a few people work on new ideas, and test them out in whatever way they feel is appropriate, then it gets thrown to a committee. Common Lisp depended on there being *existing*, *widely used* implementations that behaved in the standard way, so that the quality of the solution was already widely acknowledged.
That means that there is a lot more to many Lisp implementations than the standard discusses (e.g. GUI, network, database support, etc.). The standardization process did *not* include GUI features, for instance, because there is far too much variability between platforms, and because no one model is clearly successful enough to be forced on everyone. However, almost all Common Lisp implementations include GUI support.
What part of "at least as an option" don't you understand ? This is the usual way (other languages have usually the reverse option "remove overflow checking, usually providing only a few percentage performance improvement). Debugging symbols, profiling, boundary pointer checking are provided by gcc as an option, there is no reason why "overflow checking" can't be offered.
So let me get this straight. You used unsigned char as a loop counter, and now you're annoyed that it's messed up? Sorry, I have no sympathy. char types are not suitable loop counters. You should be using int or some custom type, unless you have a very good reason for doing otherwise (which you clearly didn't.
No, you didn't get this straight. I *didn't* use "unsigned char" as a loop counter, it is some other programmer, who saw that with his config.h was enough, the same way that "640 KB was enough for everyone" for Bill Gates, and the same way "int" should be enough for everyone according to you. I *changed* the program, but of course not his loop, because it was hidden somewhere. I just gave you an excellent example that actually happened to me *why* even your simple loop can overflow, and this can happen no matter what size of loop indexes your are taking, when code gets changed (you can get >= 4 GB files, and even 64 bits CPU cycle counter overflows after some time). And by very far, loops aren't the most likely part of the program to overflow, and it was an *example*. Just wait for your program to be modified in 15 years.
If you started forcing char types to do automatic overflow checking,
I'm not arguing for "char" overflow checking, I'm arguing for "int" overflow checking. This was an precise example of how things can go bad without.
So what are you proposing? Do you want to mandate that every C compiler provide this option as standard, including those for embedded processors with 8K RAM, where it's just never going to be used? That's absurd. As you point out yourself, there is nothing to stop vendors of C or C++ compilers providing such extensions on their own systems, and several do.
And you didn't notice or ignored a warning to that effect, and you got what you deserved for doing so. You should have fixed the loop counter at that point; the compiler told you that you had a problem. Either that or you're using the only C compiler on the planet that doesn't warn on such a blatantly dangerous coding practice.
int overflow testing wouldn't have helped here.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
I'm not going to say it's perfect, but it's far and away the best language I've used (in 27 years). I've been associated with several C++ projects that were total disasters. Wheras, several programs I have written in Eiffel have worked correctly the first time (no debugging required). And I've found that with the pre and post conditions, class invariants, etc. *MOST* of the time they are easier to debug. It is really a very simple language to learn ("Object Oriented Software Construction" is the best book I have ever read on OO software). It has garbage collection and multiple inheritence. I use the SmallEiffel http://smalleiffel.loria.fr (the GNU Eiffel Compiler) and it works on almost any platform with a C compiler (it converts Eiffel to C).
Yes. If it costs you too much, you don't use the option, that's as simple. It can be used in debugging anyway, it's not like you need 10 MB of RAM to do a single trivial overflow test. I want it as an mandary (for compilers) option (for users) at least in C++.
And you didn't notice or ignored a warning to that effect, and you got what you deserved for doing so. You should have fixed the loop counter at that point; the compiler told you that you had a problem.
Pure bullshit. gcc -Wall gives 0 warning, none, nada, zilch ; nor does VC++. And, again, that was only an *example* of how overflow commonly happen when another person maintains the code. But of course you cut the point of my post, and bitched wrongly about some unrelated detail.
int overflow testing wouldn't have helped here
Well you're right, I would actually want char overflow checking ; what I don't want is arbitrary precision chars. What actually happened is that the programmer defined types "uint8", "uint16", "uint32". This sorry mess only exists because of an "typedef unsigned char uint8", which was only possible because "unsigned char" is an arithmetic type (hint: incremeting characters is forbidden in most other computer languages). So, yes, I want overflow checking of all arithmetic types. I don't understand your initial statement why this breaks text handling.
The problem on minority platforms isn't in the cost to the developer, it's in the effort required to stick such code in a C compiler, when it's never going to be used.
As noted previously, this would be a reasonable candidate for an addition to the next standard C++ library, which would indeed make it an always-available option for programmers. Perhaps you could hope over to comp.std.c++ and suggest it?
My apologies; it's actually Lint that's objecting in my VC++ setup, not the compiler itself. It's a bit sad that two of the most popular compilers around don't object to this, though; it's an obvious and easily tested-for problem, and many other compilers do pick it up.
It's switching to arbitrary position if you detect an overflow that breaks the text handling (noting that C strings are just char arrays, and all elements in an array must have the same size). I agree you could have just the overflow test without breaking this, but then you have to work out what you do if it goes wrong.
And yes, char is broken in C and C++ for historical reasons; so is the handling of boolean values and tests. The sad thing is that newer languages in the family often haven't learned from such mistakes...
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
You're totally ignoring the points that I've made, and arguing with the points that you think I should have made. Yes, both parties took money from Enron. Enron gave money to hundreds of individuals. That, in itself, is not a crime (though I wouldn't mind seeing campaign donations get a lot more regulation).
What should be a crime is removing federal oversight so that a company can get away with fraud. You've consistently failed to address this point. Likewise, knowing Enron's financial status and continuing to help them should be a crime. It remains to be seen whether Bush will be implicated here. Enron helped determine the actual people in Bush's cabinet, re: the link I posted earlier. They didn't have that kind of influence with Clinton. If they managed to get someone into Clinton's cabinet and I'm missing somthing, post the link and let me know.
The information regarding Bush and Clinton's diplomats was from NPR. I don't have time to post a bunch of links here regarding how lobbying info consistently winds up in Republican sponsored bills, since I'm at work. If you're interested in the facts, you're probably smart enough to research it yourself. If you're only interested in asserting that 'your side is right', nothing I say here will matter much anyway.
___
It's the end of my comment as I know it and I feel fine.
Some of your "requirements" aren't language requirements, or even IDE environments.
Some of them are OS requirements, and others could be ORB requirements.
So you've got bigger fish to fry.
--Blair
"Big, boss-sized lunkers from the look of 'em."
Bullshit. Python has lots of IDE: idle, VisualPython, etc.
Your list of requirements describe Borland Delphi. Microsoft will never port to any other platform other than their own! The only item on the list that Delphi falls short on is garbage collection, but thats just sloppy programming. Borlands IDEs are very easy to use, visual development is a snap, and the inheritence is truly OOP. VB.NET still is not true OOP. Multiple inheritence can be accomplished with a COM interface. Delphi has been our language of choice for over 7 years.
While you really have to fit your problem, your environment, and your programmers, you might consider the language Dylan. See
comp.lang.dylan in the newsgroups,
Functional Objects for a commercial version (http://www.functionalobjects.com/) , or
the open source "Gwydion Dylan" at http://www.gwydiondylan.org/
The F-O "about Dylan" area is full of information, enough for you to see it satisfies all of your criteria.
Jalapeno (http://www.research.ibm.com/jalapeno/) is fast and almost entirely Java (1kloc oc c to bootstrap the VM).
10?"Frrpp!!":GOTO10
I looked at the list of requirements and you need to ask why the items are there. If the mission statement is flawed you will have problems. I haven't heard of this approach for many years, this was the way it used to be done, a bit more cerebral, I think. But why do you think you need overloading. I assume you want to maiantain the code for some time. Visual PL/I from IBM is probably what you want, you don't want to train future maintainers about your overloaded class libraries
a better language would be great for programming one that is straight forward and has the abilities to do all that today's modern languages can do. but this type of lanaguage would have to be easy to learn and not like java c++ and the other that take years to master why not a language that is english based and does what you type and not use special code names and settings to run
but that is what i think a new language should be like
Look for these features:
:
Exception Handling.
Error Handling.
Debuging Features.
Garbage collection.
Multiple Inheritance.
Operator Overloading.
Execution time performance.
Platform Independence.
Interfacing to hardware.
Support for GUIs.
OOPs Design.
Pointers, References.
Object Slicing.
Compiler/Interpreter Driven.
Dynamic memory.
If I were to design a programming language from ground up I would look for something with these features
1 . A true OO based language like Java with a true OO hierarchy.
2 . Support for GUI like VB.
3 . Efficiency of C.
4 . Programmer flexiblity like C++.
5 . Platform independence of Java.
6 . Data types can be primitive as well as
Classes, providing more support for
programmers like Java.
7 . Automagic Garbage collection of Java.
Use of Multiple inheritance(MI):
If we think about it, how many cases and what practical situations would you use MI.I also think it is not a very good OOPs design, if
you have to come up for MI unless it cant be avoided.C++ does handle it very well by providing Virtual Base Classes but if you look at java, most of the time you can still incorporate MI in
java using Interfaces.
Operator Overloading:
I dont know why, but never in my life did Ihad to write a program where I used operator overloading, so clearly this cannot be a
criteria to decide is a language is good or not.
For all you geeks if I offened any of you about your favorite programming language please excuse me, but I love all languages.