We can create C++ using Microsoft Visual C++ and Borland. May I know what is the significant differences between both and which is better to use?
Printable View
We can create C++ using Microsoft Visual C++ and Borland. May I know what is the significant differences between both and which is better to use?
They are both IDEs. However, they both provide stuff that is specific to their IDE. For example, only MVC++ offers you MFC (which isn't that great in my opinion) and Borland offers you some other ugly API for GUI. I haven't tried Borland's IDE but I always had something against it because it seems to me that all of its users are addicted to that GUI API even though it's *completely* unportable (i.e. not cross-compiler). It's all about opinion though.
If you're working with standard C++ (i.e. only doing things that are portable) then the choice of IDE makes little difference. The key to getting the program working is getting the code right. The advantage an IDE offers is managing the source files.
The difference between VC++ and Borland Builder products is in how they support non-standard C++ (GUI, database interaction, etc). For "drag and drop" design of GUI (also known as RAD: Rapid Application Design) Borland products were well ahead of Microsoft from the beginning, although Microsoft products have made great strides to improve in recent years.
In fact, if you look at the history, Delphi (which was a GUI builder from Borland based on a variant of Pascal) was among the first tools that supported GUI development in this way. Visual Basic (which was the first product from Microsoft that supported "drag and drop" design of GUI) was actually produced by Microsoft in response to tools like Delphi. Both Borland and Microsoft then both bought into C++ in a big way, with [as far as users of the products are concern; the technical roadmap was a bit different for both companies] C++ Builder initially leveraging from Delphi components and VC++ leveraging from VB components. Borland did this by implementing proprietary extensions to their C++ compilers (eg properties) to support features offered by Delphi, and allow both usage and development of components in C++. Microsoft did this by a mix of proprietary compiler extensions and some technologies such as ActiveX, COM, and MFC. A similar philosophy carried across to other things, such as database access (eg Borland offers components that support OLE, and Microsoft has ActiveX components that support OLE). Both companies have released information which allows developers to produce their own components.
The end result is that development using Borland products (IDE's and libraries) tends to result in lockin to Borland products for anything that is not standard C++, while development with Microsoft products tends to result in lockin to Microsoft products. And both have camps of developers who religiously follow each one. The Borland camp (unsurprisingly) includes a fair few people who are anti-Microsoft, while the Microsoft camp (unsurprising) includes people who are only interested in development for windows operating systems and consider that following Microsoft is the best way to get access to the relevant technologies. There are also some cross-dressers (like myself) who use pick and choose between Borland and Microsoft products, as some things are more easily done with one product line, and others are more easily done with the other. For example, although development environments from both vendors can be used to do anything you wish, I find developing the basic aspects of knocking up a GUI much easier with Borland, but development and reuse of ActiveX (or COM) components is much easier with Microsoft environments.
unportable?Quote:
Originally Posted by Desolation
really?
builderx, which takes ANY borland IDE project and ports it to whichever os you are building on.
and Borland's current GUI toolkit is now based on Trolltech's QT, which is 100% portable for all operating systems.
the newest version is MS locking though, as Borland killed C++ Builder in favour of Delphi.net. C++ is available as a poorly done plugin for Delphi's .net release 2005 and newer. I know a few avid Delphi developers who won't use the newest version because Borland screwed the tools up with their adoption of .net
That is a little bit of an overstatement, Jaqui.
1) Trolltech's QT supports some common operating systems, but there are a lot it doesn't support. That is not "100% portability" unless your definition of that term is pretty narrow.
2) By basing newer versions of the VCL on QT, Borland/Inprise have achieved greater portability (as opposed to "100% portability", whatever that means) of their product beyond windows. It remains to be seen (as the alliance between Borland/Inprise and Trolltech is pretty recent) what advantages and disadvantages are involved with using those products. For example, how much lockin will there be to using those particular products?
Desolation's comments were based on earlier versions of Borland products, and those were not particularly portable.
Even Borland's newest compiler has some significant deficiencies in terms of support for the full C++ standard. Microsoft's compilers are far better at that.
Rubbish.Quote:
Originally Posted by CornedBee
Most current compilers have some significant deficiencies in terms of support of the full C++ standard. For example, there is only one compiler that supports "export".
Historically, most of Borland's compilers were well ahead of versions of Microsoft compilers of similar vintage in terms of standard compliance. If you acquire any two compilers dating from (about) 2002 or earlier, the Borland compiler was more strongly standard compliant than its Microsoft opposition.
Borland always, strategically, sought to improve the standard compliance of their compilers, and were relatively open in acknowledging known deficiencies. Microsoft's strategy was different. Up to and including VC++ version 6, Microsoft were quite notable as they aggressively, and deliberately, not supporting the C++ standard, prefering instead to support proprietary compiler extensions and proprietary libraries, although their marketing department claimed they were compliant with the C++ standard. This changed about 2002 or so. VC++ version 7 represented a change of strategic direction by Microsoft, in which they overtly sought to achieve standard compliance. At the same time, the evolution of Borland's compilers (after about version 5) slowed for various reasons, as they focused more on support of features (components, etc) than on improving the quality of the basic compilers.
The current situation is that Borland/Inprise's compilers have not improved their standard compliance much in the last few years. At the same time, standard compliance by Microsoft compilers has advanced dramatically. Given that Microsoft compilers were initially well behind those of Borland, they had some catching up to do. It is a fair call that Microsoft compilers have passed Borland compilers in the last 2-3 years, but the difference isn't as dramatic as Microsoft would claim, as they came from behind.
Both Borland and Microsoft compilers are well behind, in terms of standard compliance, some other compilers. For example, Comeau compilers have been well ahead of either Borland or Microsoft for several years --- and Comeau is fairly open in acknowledging known flaws in their products.
What does the past matter? The most current MS compiler is way more compliant than the most current Borland compiler. That's all that matters in the direct comparison.
The mantra of "keep your compiler up to date" seems superficially easy, but is not so easy in practice. It really only works with small and trivial programs. It tends to break down with moderately large projects (lets say a few million lines of code or so, although LOC is a bad measure of project size) and definitely breaks down with large projects. When build times for a complete system are measured in days or weeks, the time to install a new compiler and recompile existing source code with it, means a down time in which the development team is less productive as their ability to modify source files and test the resultant system is less. And, of course, there is a need for a significant testing regime to ensure the system works as intended with built using the new compiler.
Practically, a lot of people are tied into to an older compiler for quite some time. With moderately large projects it is often simply not cost effective to adopt every new compiler release and then do regression testing to ensure the code still works. So a deliberate decision might be made to stick with an older version of a compiler, despite known shortcomings of features or of standard compliance in an older compiler. With really large projects, the impact of changing a compiler can be huge, and it can therefore be a valid decision to only update compiler versions once every five years or so. And, for people in that boat, knowing limitations of both old and new compilers is important.
Will you stop taking your arguments out of context? The OP is obviously not maintaining an existing project, and there's absolutely no reason to start a new project on an old compiler.
Not to mention the whole argument opens a new can of worms...
This opens up a can of worms for me. Have you tried MFC and gotten deep enough into it to actually make a decision one way or the other? MFC can suck if you use it wrong, but it can save you tons of time if you use it right.Quote:
MFC (which isn't that great in my opinion)
Both MS and Borland have great compilers and I always prefer Borland's to MS. Borland's error messages are so much better and more descriptive and their debugger is as well. However MSVS 2005 is no slouch.
It depends on what you want to do. If it's OpenGL, I believe both can do this. If it's DirectX, Borland will give you some problems. If it's MFC, Borland will give you problems since they cannot directly support it or the interface MS uses to create MFC apps. But OWL is actually a fairly good GUI language and is not that much different from MFC, except that, MFC natively can support COM/ActiveX objects. I'm not sure about OWL as I haven't used it in 5 years.
grumpy, Borland is 100% portable, compared to the windows only MSVS.
but for the best portabiity, the options are gtk/gdk or wxwidgets.
both are available for more platforms than Borland's QT based VCL or MS' MFC.
and yes, the Gimp Tool Kit / Gimp Development Kit does have windows, mac, support as well as almost every unix variant.
You don't work in the real world then or, if you do, you work in an environment where you have unfettered control over what products you use. Very few professionals have such control over the projects they work on because the people who pay them do not allow such control. There are plenty of reasons why people start projects with old compilers, including;Quote:
Originally Posted by CornedBee
1) Organisational policy. If your employer mandates use of a specific compiler, you are putting your job on the line if you use a newer one. A lot of employers (particularly employers with a few thousand employees) do this, in the interests of avoiding a proliferation of different compilers or compiler versions being used in different projects. Such companies do this and do regular but infrequent updates (let's say every 1-2 years). Some very large organisations require that all products (operating systems, compilers, office suites) be tested exhaustively by their IT support offices before being installed on all company machines - because incompatibility between versions is a major issue for organisations with a few thousand employees. Going against organisational policy is a good way to lose ones job.
2) Contractual obligations. If your customer requires compatibility between products produced by different companies, they will often stipulate a specific compiler and compiler version to use in new projects. This is particularly true if you are asked to implement an extension to software that was developed by another company for your customer. It is a waste of a customers time and money to pay you to update the original software so it works with the latest version of your preferred compiler. Instead, they will often (within the contract) provide you with a license to use a compiler that they know the software will build with, and require you to develop new code that works with the old compiler. Importantly, they wil leven do this with some new projects, as one of their end goals is to be able to manage the software configuration after you deliver it, and they use an older compiler in-house .....
You may consider that my arguments are out of context. I consider they are right in context; in the real world, people often have no choice but to use an old compiler when producing a new software product.
Personally, I work in a large organisation that -- as a general rule -- has does not follow the bleeding edge of technology (hardware, compilers, etc) [there are some possible exemptions to that rule, but the arguments required to justify such an exemption require considerable documentary justification and sign-off by very senior management -- so they are rare]. And I regularly place contracts for software development on other organisations, requiring them to honour constraints I operate under.
In practice, at home (when I have complete control over what I am doing) I often use the latest compilers. That includes beta releases, so I regularly submit bug reports to compiler vendors as a result from home. I do not do that at work because it is more practical --- for both myself and my employer --- for me to use slightly older compilers.
Jacqui: the term "100% portable" means different things to different folks.
That does NOT change the fact that MS's latest compilers are quite simply BETTER! They are the better choice for programming. And this topic is about choice, not contractual slavery or corporate glaciers.
You pointed it out yourself:
If you have no choice, then the topic is moot. You use what you get, and you try to work around the deficiencies.Quote:
in the real world, people often have no choice
But if you have the choice, you will stay away from Borland if you value your sanity.