Slashdot Mirror

Yes; I bought a C compiler there - Watcom's (now free), after I read it was used to create Doom and I wanted to learn more about C. This was in the late 1990s, and I think I paid ~ $100. This was back when you could buy the Netscape web browser in a box off the shelf at Best Buy for $40ish!

Speaking of ye olde compilers, OpenWatcom seems to have ground to a halt in 2010. Can't tell if I think that's a shame, or if its time has come, or both.

From the Open Watcom wiki, "An Open Source license from Sybase allows free commercial and non-commercial use of Open Watcom." How much more free do you want it?

If you want a sense of history, compile it on OS/2. ;-)

I thought that was something people used back when MS-DOS was a popular OS was not even aware the product still existed.

I am talking about Watcom C++ of course.

It was open sourced some time ago. Now it supports Linux (to some extent) and some other CPU architectures. It can still make DOS/4GW exes, though. Ahh, nostalgia.

As someone that has maintained Watcom C/C++ code, the Watcom and OpenWatcom are slightly different and code needs porting from Watcom to OpenWatcom. How much I don't know...I just know that our code needed quite a bit of work to do that. Would have been nice if we did...but no one wanted to.

I thought that was something people used back when MS-DOS was a popular OS was not even aware the product still existed.

I am talking about Watcom C++ of course.

It was open sourced some time ago. Now it supports Linux (to some extent) and some other CPU architectures.
It can still make DOS/4GW exes, though. Ahh, nostalgia.

OpenWatcom has OS/2 16/32-bit targets: http://www.openwatcom.org/index.php/Detailed_Contents#A_Wide_Range_of_Host_and_Target_Platforms

Libraries and tools are probably a bit thin on the ground.

They are still around: OpenWatcom.

First of all, thank you. It's always good to hear some criticism on definite and specific issues, rather than the generic "M$ sucks".

(I am a VS developer)

Or how about, starting in either VS2005 or 2008 (can't remember which one), I opened up a project written in VC++6 and freaked when I suddenly started seeing hundred and hundreds of warnings, telling me that functions like strncat() (strncat!) were "unsafe" and I should use something like _strnscat or something like that, which supposedly was "more" safe at the cost of being totally Microsoft-specific.

It was added in VS2005, but it's not quite MS-specific. OpenWatcom also provides it out of the box, and there's a cross-platform FOSS implementation available now.

The reason why the text says that they are unsafe is because, frankly, they are - as a result of several security studies, they account for a very significant proportion of known buffer overrun vulnerabilities. Of course, it's perfectly possible to use them in a safe way, but surprisingly many people actually do... but this take has been fairly controversial, anyway, I won't deny that.

It should also be noted that this isn't actually the default for the compiler as such - if you directly do "cl.exe foo.cpp", you won't get any warnings for strcpy. It only pops up if you raise the warning level to /W3 or higher, which is what IDE does by default for newly created C++ projects. The text of the warning also clearly states what to do to get rid of it:

warning C4996: 'strcpy': This function or variable may be unsafe. Consider using strcpy_s instead. To disable deprecation, use CRT_SECURE_NO_WARNINGS. See online help for details.

When you refer to it being per-project, do you imply that it was inconvenient to add the define to all the numerous projects you've had in the solution?

How about the auto-hide windows that seem to randomly decide to suddenly be pinned or to suddenly appear during unrelated actions?

Tool windows in VS have different and separate settings depending on which mode you're in - aside from the default one which you get on normal VS start and/or project open, debugging is a separate mode, and opening VS with a single file (aka "simple editing") is yet another. This is somewhat similar to Eclipse perspectives.

If you pinned a toolwindow in one of those modes, it will not be pinned in other modes. The idea is that you generally want different toolwindow configurations depending on activity - e.g. you might want Breakpoints window to be set to auto-hide during normal editing, but pinned in debugging. So you will, at most, need to pin the window in all modes in which you've made it visible, and most likely, you'll be dealing with just the default mode and the debugging one.

If you experience random pinning/unpinning that cannot be explained by the above, then please describe the scenario under which it happens - which toolwindow, what were you doing when it got unpinned, etc. Better yet, do it in a bug tracker.

When working with C#, the compiler and editor will give you a red squiggle under code it can't compile, but gives you know way to know where or how many places in the file they are

If you open the Error tool window (which will happen after the first build, but you can do it manually), it will list all IntelliSense errors just as if they were compiler errors, so you can see the error descriptions, and double-click to jump to location. By the way, this (as well as squiggles themselves) also works for C++ in VS2010.

If you want margin markers as in Eclipse, you can

I am not a Linux guy, but I learned vi using Watcom C/C++ under Windows. Now that that tool has gone open source, it seems there is a Linux version. Will this work?

http://openwatcom.org/

If I'm off, my apologies...

Get open watcom c++ http://www.openwatcom.org/ and start here: http://www.scene.org/dir.php

I guess it's still available, here:

http://www.openwatcom.org/index.php/Main_Page

The OpenWatcom license is OSI-approved, but I don't see why. It failed DFSG, and I asked the FSF about it and they can't make head nor tail of it either.

I love KDevelop/GCC, but it is also nice to have some options. The massive reliance on GCC is becoming tiresome, especially if it still under performs, newest Intel's and Microsoft compilers are faster and produce better code..

The good old Watcom was rock solid compiler producing one of the best binaries at the time, also comes with good debugger and even decent IDE. It is open source now, see www.openwatcom.org. It has a stellar source base and potential to spawn another cross platform compiler to compete with GCC. It would be nice if we could swap GCC for something else.. This great and promising project needs developers badly!

Do not forget, it is Watcom that compiled and gave us Duke Nukem, Doom, Termial Velocity, Frontier and all the DOS4GW titles.

Let's just say that it's easier to grade one or two pages of 80 column text than it is to click through each and every cell used in a calculation. That should rule out Excel/OpenOffice for all but trivial purposes.

Then you get to practical problems. Do you know it this guy has the latest and greatest version of Excel? Will he be able to render all of the fonts he might get? Do you really want to enable macros and take stuff from worm infested student machines?

Then there's cost. Why require your students to purchase an OS and Office when they could use GCC or Watcom and learn something useful?

goofballs are not good for the engineering or physics student.

Check out the free versions of Microsoft's development tools sometime, called Visual Studio Express editions. AFAIK, they can be used by enterprise developers for free as well, check out the license. I guess, it's because they're supposed to be "appetizers" for "the real things". But they work quite well, if you don't demand too much.

The Windows SDK is also a free download, containing the full OS documentation, build environments and samples.

IMNSHO, that's just a non-issue to claim that development for Windows would be expensive.

Besides, there are other good, free development tools for Windows, like Watcom C/C++ (which is BTW the only compiler natively supporting DOS, Win 3.1, Win32, OS/2, and NLM development, with Linux support planned LTIC).

Free IDEs for .NET development include Eclipse, and others.

Your main point is dead on, but there are a few other projects working on open-source compilers; off the top of my head I know of:

TCC, written by the guy who created QEMU
BCC, "Bruce's C Compiler", which spits out 16-bit code (for embedded machines?)
OpenWatcom C compiler which is only for OS/2, DOS and Win32, but they're porting it to *nix Real Soon Now.

There's also one I'm forgetting which has been talked about in the OpenBSD mailing list as a free alternative to GCC; but I forget the name of it.

However, because it's a university setting, I'm free to basically do what I want with it (my job is to "make it work with a modern compiler (i.e., without Watcom since they're out of business)")... so I'm porting it back to UNIX as I go! : )

Wouldn't it be better to help with the Linux and BSD ports of Watcom (now Open Watcom, http://openwatcom.org?
At least when Watcom went out of business they open sourced their code and released it. And it is still a pretty good compiler that is being brought up to todays standards.

Submitter and Editor should be ashamed. Here 'tis

And in a similar vein, see the Open Watcom project for a different set of (not GPLed, but open sourced) compilers.

There are a large number of Watcom employees still at iAnywhere. We have a low turnover rate, generally, though a large part of the compiler team eventually decamped to RIM (they have their own homegrown Java intepreter and tools) and other places after Watcom C++ was EOL'ed. Most, but not all, of the engineering work at the Waterloo site these days focuses on SQL Anywhere, the descendant of Watcom SQL. (Other iAnywhere and Sybase products are also worked on there.)

Note that Watcom C/C++ and Watcom Fortran still live on as open source projects released by the Open Watcom organization.

http://www.openwatcom.org/?

Or something else?
http://www.thefreecountry.com/compilers/cpp.shtml

These C++Builder people can easily switch to Visual C++ -- but they'll hate having to do it. There are open source compilers out there. There is no good GUI builder for windows, but perhaps a few borland fans could finance/write one. I suggest they team up with Open Watcom. You have a great compiler there with a crappy IDE. The Borland developer community could probally make a kick ass GUI builder with watcom, and help with fleshing out some of the newfangled C++ extensions yet to make its way into the C++ compiler.

As a former Watcom user (albeit one with fond memories) there's OpenWatcom too.

• Web browser - Chimera. Has an Athena-based X11 user interface, supports modern GIF images, and can retrieve data from HTTP, FTP and Gopher servers.
  
• C compiler - various exist, including the Tiny C Compiler. Other possibilities for porting include Sozobon C Compiler and Open Watcom.
  

Does anyone know if this even works with watcom c or am I going to have to pay money and get visual studio (which I can't afford) in order to use it?

Seriously. GCC allows many things that the standards forbid. And even if you are dilligent and stick to standards-only behavior you still can get code that is incorrect (by accident) but runs okay on GCC. Using a different compiler will help bring out portability bugs - indeed all bugs - in your code.

GCC and MSVC are just two. There is also Watcom C, lcc, TenDRA, and a few others.

If you want portable code, compile your code with all of them; test it with all of them. Diversity (with respect to compilers) usually only makes code better, not worse. Its like getting better coverage when testing.

How about it? Watcom seemed to be the most popular besides Turbo C in good old DOS, especially for 32bit apps. Watcom is free, see openwatcom.org

A few servers in my server room store the source code, run backups, and do nightlies. I also keep a Windows laptop with me as well. Why? Portability tests. I use OpenWatcom and Microsoft Visual C++ to make sure my code is 100% portable.

I really do prefer using the Mac for most development tasks. I do have to use the PC for running Tornado and building target images sometimes too; but I try to test the code on my PB before hand.

Having a real UNIX box on the go with the ability to run M$ Office apps along with my dev tools was worth the money that my toy cost me ten times over.

Umm, Watcom? Not only were their compilers the most popular for OS/2, they were the most popular for DOS as well. Remember, they were the ones that released DOS/4GW, which every game was built on for several years.

All I can say, is there were many problems with getting developers, but lack of a good compiler was not one of them.

Btw, watcom is now open source, as Sybase dropped it after acquiring Powersoft, which previous acquired Watcom.

Check it out

It came from commercial roots so it is likely to be a better compiler in many ways compared to g77. They are actively porting it to Linux and Watcom was always known as generating terrific code. For x86 scientific computing it may be just the thing!

to be honest, i don't understand the motivation for using vc++ in a non-professional (read: outside of work) capacity in the first place. i realize the $99-$129 "professional version" price tag that i've seen, and the even cheaper academic pricing, are not too shabby compared with "enterprise" pricing... but they're still more expensive than $0! there are more than several freely available alternative compilers for win32 machines - cygwin gcc, borland (debugger also), djgpp, open watcom, lcc, MinGW, and Digital Mars (nb: haven't examined the license in detail) to name a few. can anyone else shed some light on why a developer might prefer vc++, or under which circumstances vc++ might be considered a clear-cut better choice than one of the alternatives listed above?

So if the same open source developers work on both Watcom compilers and GNU compilers, does this mean that the best features of both will be carried back and forth (kind of unknowingly, but more out of convenience) until they start looking alike? I would assume that in the future these products may grow together, and the same destiny may apply to other open source efforts that have commonalities.

For what it's worth, the Watcom C Compiler has been open-sourced as well. Whether the license is really open source seems debatable, but at least you can get the complete sources and binaries of the compiler.

For what it's worth, the Watcom C Compiler has been open-sourced as well. Whether the license is really open source seems debatable, but at least you can get the complete sources and binaries of the compiler.

Would be nice, but not gonna happen. There is a lot of code in the BeOS codebase that Be licenced from third parties- they cannot release that code to the public.

id Software's Doom and SciTech's Watcom C++ had the same problem of proprietary code licensed from third parties, but id solved the problem by releasing a crippled version (without sound) and Sybase plans to solve it by rewriting the third-party parts before releasing the code, but that's still taking a long time.

A lot of commercial software likely is using libraries/code licensed from 3rd parties making opening up the code (or selling it) extremely unlikely.

id Software's Doom was originally opened without sound code because it had used the proprietary MIDAS library. The developers of Doom Legacy filled in the gap with the Allegro cross-platform multimedia programming library (similar to SDL).

Or they could do as sybase did when it opened Watcom C++: first open it to previous owners, with a build that requires the DLLs already included with the compiler, then after you rewrite everything you don't own, release source code to the general public so that they can bootstrap the compiler.

Or use Watcom C and get fast code and fast compiles.

2.1 You may use, reproduce, display, perform, modify and distribute Original Code, with or without Modifications, solely for Your internal research and development and/or Personal Use...

where "Personal Use" is defined as:

1.8 "Personal Use" means use of Covered Code by an individual solely for his or her personal, private and non-commercial purposes. An individual's use of Covered Code in his or her capacity as an officer, employee, member, independent contractor or agent of a corporation, business or organization (commercial or non-commercial) does not qualify as Personal Use.

This is not an Open Source license. Sybase has misunderstood the meaning of the term. Yes, the submitted this to the OSI. May the OSI swiftly reject it.

[Watcom C++ has been released as open-source software] Some while ago, in fact (August 2000), based on the final commercial version, 11.0b. Take a look at http://openwatcom.org

I did, and they still don't have a release up. It's not open source until it has been licensed to at least one third party under an open-source license.

They're being slow and careful

Some would say "too slow." At this rate, x86 will be dead and we'll all be using Hammer and Itanium processors by the time Open Watcom comes out.

The Open Watcom core team has already created a binary patch update release

Perhaps this time next year they'll release another beta of this patch, get a little more free publicity from Slashdot, and get a few more dollars in donations. How exactly does this project qualify as open source? Just because they say it is?

Don't know anything about this one.

http://www.openwatcom.org/.
--
Lord Nimon

Not that I'm biased or anything...;-)

I just read this from the info page:

"SciTech Software, a long time user of Watcom compiler products contacted Sybase about turning the compilers into an Open Source project, and hence the Open Watcom Project was born."

http://www.openwatcom.org/info.html

I was going to ask SyBase to open source their C/C++ compiler after finding out they dropped their compiler/support last year, but Thank-you SciTechSoft for getting the ball rolling !

Direct from the OpenWatcom FAQ:

Q: What compilers will I need to compile the source code?

A: Initially the Open Watcom 1.0 compiler will require an official copy of the Watcom C/C++ 11.0b compiler, with the 11.0c binary patch release applied in order to successfully compile it. This is due to the need to rely upon proprietry SDK's for platforms such as Windows, and OS/2 that cannot be distributed along with the Open Source 1.0 compiler release. It is planned to eliminate this dependency in the Open Source 2.0 release, by allowing the compiler to work with freely downloadable SDK's for the supported platforms.

So in other words, to compile the 1.0 Open-Source version, you need the commercial 11.0c version. So everyone run out and buy the 11.0c version for ~$200 so you can compile your free Open-Source version. Or you could wait god knows how long for version 2.0 to come available without the 11.0c dependency.