Slashdot Mirror

Rational Software makes a program called SoDa wich will create documentation from source into a MS Word document.

Well, as always, the text editor itself is really up to you - I use the ubiquitous emacs along with the fantastic jdee IDE that installs inside emacs for syntax highlighting, quick toolbar access to your classes, and easy creation of class from templates.

If you are serious about writing good OO componentised java though, its almost essential now to use a decent UML tool during the design stages and further like rational rose / together.

One of the nice things about together is that it works by placing javadoc comments inside your java - so your design documentation is never out of step with your source. Invaluable.

I don't work for together - but I do find their tool helps me visualise the workings of complex systems without remembering all the methods and stuff.

So if I had to put a finger on it - let developers choose their editor/IDE themselves, but get all developers to use a UML tool independant of the IDE.

Even worse, ood (object oriented design).

As proof, presume Rational uses its own OOD products to design and implement each next generation of its products. Observe poor quality and rough design. Observe obtuseness of UML itself. QED.

"At this time, Rational has not declared any plans regarding Purify, PureCoverage or Quantify support for Linux on 32-bit/64-bit Intel platforms."

(From elsewhere on the page: IA-64 Linux support is more likely?)

I don't know what a vanilla Unix Purify license goes for (my employer has a negotiated lower rate), but it's less than $10K US. It is several thousand dollars per user, floating across hosts (and maybe Unix platforms) but not floating across users; expensive.

Purify alternatives were recently discussed here.

I recently had the job of evaluating what SCM system to use for our company. We were using CVS at the time.

I believe that the complaints your bosses have about logging and concurrent editing can all be fairly easily fixed in CVS.

The major gripes we had with CVS were:
. slow (see below)
. merging between branches was miserable, because the system didn't keep track of what had already been merged
. renaming files lost all the history
. windows interface was cumbersome

We actually worked with a system layered on top of CVS that allowed us to submit batches of files at once, in a single transaction. This was the major cause of slowness, and CVS didn't really support transactions, so in some sense we were just fooling ourselves. The other major cause was doing a 'cvs update' on a large tree could be slow.

Most of the problems we had could've been fixed
if we spent the time to fix it. Some (transactions, renaming) we couldn't really fix at all. But, when I looked at everything I wanted to fix in CVS, I found that I had just described Perforce's feature set, and when I looked at how they implemented things, they did it like I would've. Plus, comparing the cost of Perforce (relatively cheap) to the time it would've taken us to implement the same features ...

So, we switched to Perforce, and I've been (more or less) happy since. The branching structure is a little weird (compared to ClearCase's, which is the most intuitive I've seen), but we're learning to live with it.

At a previous company, we used ClearCase. This was also a fine product, and it does a few things that no other product does, but it's very expensive, and a major hassle to administer.
ClearCase (at least in the mode we used) implements its own filesystem, and can provide a level of security that the others just can't. But, is this worth paying 10+ times the amount for it?

I also looked at AccuRev. This was about on a par with Perforce, and had one or two features that looked really cool. But, in the end, Perforce won mostly because we went with the product that had bigger market share and more people had used it before.

VSS wasn't an option because we're a mostly linux based shop, and because I had heard many of the complaints that others are making as well.

PVCS I think is mostly an also-ran in this day and age. I think most new source-system users use one of the other previously mentioned systems.

One new open source project (Subversion) looked promising, but it was too immature for us to use.

Bitkeeper also looked interesting, but not enough so to beat out Perforce or AccuRev.

Another thing you might want to consider is how well the SCM integrates with a change mgmt system (or bug/task database). Perforce has a simplistic change database built in, but it's good enough for what we want it to do, and it can also be used with Bugzilla and a few other systems. Of course, CVS and at least ClearCase can do these as well. I've found Bugzilla somewhat cumbersome to use on limited inspection. Other freeware systems (GNATS, for example) are very weak.

In the meantime, my company would LOVE to put some stuff together. We've already started helping a bit. rational software is putting together a van full of equipment and people to deliver. Please contact Ali Kaufman to see if you can help at all.

If you know of anyone else who can use computers or equipment in the NYC area in relation to this disaster, please tell her or me, dave, and we'll try to coordinate!! It's better than just sending a bunch a stuff and people down and saying, "TAKE IT!"

Dave

In the meantime, my company would LOVE to put some stuff together. We've already started helping a bit. rational software is putting together a van full of equipment and people to deliver. Please contact Ali Kaufman to see if you can help at all.

If you know of anyone else who can use computers or equipment in the NYC area in relation to this disaster, please tell her or me, dave, and we'll try to coordinate!! It's better than just sending a bunch a stuff and people down and saying, "TAKE IT!"

Dave

There is another class of GUI tools, however, that allow you to incorporate UML diagrams within your design and development process. I guess that the two programs that best represent this class of "modeling tools" are RationalRose and Together.

RationalRose is more popular, since it was out first, and essentially set the standard, but it supports only a one-directional process (unless that has changed recently) -- design your UML diagrams, and generate code from them (some OO people actually see this as an advantage, but that's another discussion).

Together, on the other hand, is bi-directional -- it constantly updates the UML diagrams to keep them in sync with the code you are writing. As a result it has the neat property that you can actually write your code w/o going through the UML modeling/design stage, and yet you get complete UML diagrams of the code when you are done.

Personally, I am ambivalent about the utility of RAD tools for building GUIs -- they can be great for quick prototyping, but on the other hand they tend to produce code that is not very maintainable and thus not too suitable for large commercial application (although a lot of people are so used to them, that it is hard for them to see the alternatives).

On the other hand, UML modeling tools can be tremendously useful, especially in team environments. A picture is worth a thousand words, and that is very true even in programming. Even if you do not use UML for design, Together's ability to generate diagrams representing the code is invaluable when you have to take over or maintain someone else's code. It is much easier to see how classes relate to each other at a first glance, than to try to figure that out by going through the code manually.

I guess this won't go down well, but we use Mickeysoft's SourceSafe for all our version control and I would recommend checking it out. Admittedly there's the cost factor involved in that, and the administration. However, having used CVS for a while, there are limitations in that software that were hard to work around, and administration was no breeze either. No doubt it's improved in the past two and a half years, but I can't comment.

By far the best system I've used is Clearcase, but that requires an enormous effort in administration (we had 3 full-time and 2 part-time admins on it for a project spanning multiple continents and with some 80 developers, and that was just in one of the offices - I have no idea about the others). That was back before it was sold to Rational and running on HPUX though, and I've heard terrible stories about the performance of the Windows client. Oh, and it costs an absolute bomb.

My experience has been that a 30 minute course for the non-technical will bring them sufficiently up to speed on SourceSafe. A well structured SourceSafe database and a couple of clicks can allow non-technical people access and control over their documents at a centralised network location whilst maintaining version control. Note that the structure of the folders (Projects in SS terminology) is worth investing time in figuring out because it can make a world of difference to how accessible your documents will be - and that's a large part of the problem when you're dealing with non-technical people.

This of course presumes that you want a system that handles both code and document control. There are dedicated document revision control systems out there, but I have not had experience of them. At one point we built our own simple one, but I was never fully convinced of the benefit of doing that, though it leads me to believe that good commercial products may not be as plentiful as hoped for.

For the cheapest route, CVS is probably best. There are other GUI solutions available than PCVS, though I haven't tried them out, and I don't know how well they're supported. I presume you've found this page already. A quick perusal and TortoiseCVS seems a fair approximation to what you want (I presume your users are technical enough to use Windows Explorer if they are writing Powerpoint presentations), though their website is down at the moment (perhaps that's a bad sign).

I hope that's of some use to you.

Cheers,

Nixta

CVS lacks a few features that make it really uncomfortable to work with.
-atomic checkins on multiple files: basically meaning that you can't really tell what files came in with each checkin, so backing out of a change is a chore, also it's possible to checkin
only a part of what wanted to (if the network goes down) resulting in a broken tree
-file renaming breaks file history
-no directory renaming
-no disconnected operations on the repository(e.g. checking the file history when you are on a laptop in a plane)
-branching and multiple merges back into the trunk is a little awkward
-setting up a staging area for integration of changes is similarly awkward

The alternatives:
Bitkeeper looks really nice, I've only played with it though, not used it in any serious development. It follows a model that every developer gets his own repository, and then push changes around these repositories. The license allows access to the source code, but is not quite open.

A lot of people like Perforce. I don't have much experience with it myself though.

Visual SourceSafe is slow over the network, seems to corrupt files easily, and not so friendly cross platform. It has a nice GUI, if you are into that kind of stuff. Has similar problems with CVS regarding branching and atomic transactions.

ClearCase is really expensive(in computing resources, money, and adminstration costs). On the other hand it has nice integration with rational's workflow and bug tracking products.

Right, I know this is not free/OSS but its a good product nevertheless. Has anyone tried Rational Clearcase. Its great for really large projects and comes with its own FS to preserve space (Files can be in your view but if they arent checked out they are Read-only and only in the repository).

For quite some time before that I have been writing GoingWare's Bag of Programming Tricks, a collection of articles on the business and practice of programming. Of most interest in learning how to program well would be:

• Study Fundamentals Not Tools APIs or OSes
• Properly managing memory returned by transcode() in the Xerces library (while about an obscure problem, it illustrates more general principles in a useful way)
• Secrets of the Debug Meisters: MacsBug Tips and Tricks (MacsBug is a Mac OS assembly debugger)

• Pointers, References and Values - Passing Parameters, Returning Results and Storing Member Variables, with Musings on Good C++ Style

• Bounded Pointers for GCC
• Spotlight for Mac OS PowerPC
• BoundsChecker for Windows
• Purify for Windows and Unix (but I think it doesn't support Linux)

• OptimizeIt

Mike

============

============

============

The one problem I found is that sometimes if you let MagicDraw idle for about an hour or so, the memory usage stacks up a bit. I don't know why, but probably because the program is using jvm.

============

It's called UML.

Rational Rose will do this. It is used for planning a system at the class level (and then generating the class files) or reverse-engineering existing classes into a UML diagram.


Yup, and you can have it all for the low-low price of $2394

I don't have any experience with Clearcase, but they have a free online demo, and a free demonstration cd-rom offer at http://www.rational.com/tryit/index.jsp

Unfortunately, it is completely useless now unless you're working on NT or Sun or one of the other few platforms it supports.

If you like GNU project software, there's a package called Checker which aims to do many of the things which purify does. I haven't used it much though, so I can't comment much on its usefulness.

Cryptnotic

You didn't mention a platform. I'm assuming some sort of Unix, such as Solaris or Windows.

Rational Software (I think) makes a product called Purify. If you ever work in a large shop, you'll use purify to help write your software.

Click here to go to their website

It not only catches memory leaks, but also uninitialized pointers, using uninitialized RAM, stack overflows, etc. It is, in my opinion, the best tool on the market. Yes, it does cost some $$$ (about $2500 per license). If you can't afford it for whatever reason (your a student, business doesn't have the money, etc), or you need a Linux solution (not purify - yet), you'll have to go open source. I would be thrilled if Rational released their tools on Linux, too, although I have to wonder how many Linux developers could afford to buy them (probably the reason they haven't released for Linux yet).

Does anyone know of any good Open Source UML tools?

By far the best CM system I've used is ClearCase by Rational. It's probably not cheap, but it has excellent GUI/CLI interfaces, features up the wazoo, and integrates well with their ClearDDTS defect tracking system. Well worth looking in to.

If you are a programmer, at least, look at companies that develop so-called embedded systems. The operating systems of choice in this industry are UNIX-like: WindRiver vxWorks and LynuxWorks LynxOS/BlueCat Linux. Indeed, many embedded designs are starting to utilize plain Linux.

What are embedded systems, you ask. Damn smart question - you should be proud of yourself. Fact is, probably most programmers in the world are actually developing such systems. Basically, any electronic/computing device that is not a conventional computer. For instance, gaming devices, cd-rom drives, DNA analyzers (I do that), telecommunications devices, power utility switches, routers/bridges, medical instruments, .. ..

Keywords to look for would be firmware development, embedded systems programming, real-time development.

Best part of it all is that you'll probably get to deal with some of the most interesting development environments that exist. For instance, we developed our said DNA analyzer using ObjecTime, and going forward we'll be using Rational RoseRT - tools that automatically generate C++ code based on the model that you visually draw! (You just fill in the "meat" of each function - the action that takes place in a transition, say). Logic Analyzers, emulators/simulators, virtual platforms, cross-compiler environments -- this is all the stuff that teach you everything about computers - and nice OS designs.

Now, if you were not actually asking as a programmer, but as a systems administrator or other IT drone, here is the (more limited) tip: Go for the back ends - i.e. web servers, IBM's Net.Commerce development, DNS/Firewall administration, that type of stuff. But those are not real people - the I.T. world is just to stuffed with "management types". If you still have the choice, look for software/firmware development environments - much cooler people and more casual atmosphere.

OSS doesn't have test suites available

This brings up an interesting point. Are there Open Source automated testing suites? At my company we use Rational Robot to do automated testing which makes regression tests trivial because we just run a script overnight and it tests everything. We also have manual test plans for areas that can't be tested automatically or scripts just haven't been written for.

Do Open Source projects even have test plans? From what I can tell they don't. The developers just submit their code and they post it. I'm sure they might run through some simple tests, but sometimes I doubt they even do that. They seem to be depending on peer review too much and, as you mentioned, sometimes the problems in code are more involved than just a few lines need to be changed in which case making larger changes can sometimes cause undesired effects in other areas of the product.

I do think that with a dedicated test team running something resembling test plans that the overall quality of an Open Source project will improve.

I've spent most of my career fixing somebody else's broken code.

This is not to say that my own has always been of the very highest quality, but in fact I decided early on to try to come to a fundamental understanding of what was wrong with software development, to get very good at debugging (I say that debugging is a specialty on my homepage) and to learn to write better code.

In my early years I was initially very shocked at what I'd discover in production use at companies. Over the years I just learned that that's standard practice, in commercial software, in-house software, and even in scientific software (where I have become convinced, because of my experiences with high-energy physics data analysis, that many scientific papers are published with erroneous measurements because of software bugs).

Early on I read that something like 90% of software development is spent doing maintenance programming. Some of this is doing legitimate upgrading, but a lot of it is just spent fixing bugs, and even a lot of time spent doing upgrades would be more productive if the code were of better quality.

After reading this figure and having so many experiences with software bugs, both other people's and my own, I decided very early on to get very good at debugging.

One of the first things I did was adopt the regular use of "lint" for checking my C code. I would integrate lint targets into my makefiles and after editing a source file I would type "make lint" before compiling to objects and lint would check all the files that were out of date with the object modules. Pretty quickly I got to where I could write code that was nearly always lint-clean - but the existing code I worked on would make lint scream with hundreds if not thousands of complaints, often serious things like variables being used before they are initialized.

One of the first solid clues I got about software quality came from Robert Ward's book "Debugging C" - now out of print, it predated the common use of source code debuggers and talked about how to write your own stack crawls and other tools.

Ward emphasized the use of the Scientific Method in debugging, and because I was trained in physics, this came very naturally to me; before that I'd mostly floundered and used printf a lot.

I've gotten very good at debugging and have even worked full-time as a debugger at Apple Computer where I was a "Debug Meister" and my business card gave my title as "Cybernetic Entomologist".

I can easily get highly paid consulting work doing debugging for companies desperate to ship a product (and have in the past) but I don't really like to do it for various reasons, some of the same reasons I quit my debugging job at Apple.

One is that if I only do debugging I don't have something to point to at the end of the day and say "I wrote that". I could say "that works because of me", but sadly there's usually lots of bugs left that I didn't have the time to find so I don't really feel proud of the result. The other problem is that the bugs are usually not there because of something interesting, it's not like the code is mostly good but there's some subtle flaws, rather the code is a heap of dung and I can go in with a pitchfork and do debugging wholesale until I get tired of it and the client or manager decides the rate new bugs are being found is low enough they can feel OK about shipping it.

I don't feel good about contributing to such shoddiness. If a company is not good enough to support quality in their corporate culture I don't want to come in and put on a band-aid for them. It would be an entirely different thing if a company hired me to restructure their development process so that quality was a goal that was achieved through direct application of process but gee whiz no one has ever asked me to do that for them.

I do have to say though that the best thing that ever happened to me is that I became a "technology prostitute" as the author of the original article puts it. One benefit of this is that the process is entirely of my own creation, and almost all of the work I've been given has been to write entirely new products from scratch, so I can engineer in quality from the beginning.

Here's a few recommendations I have. Get good tools. Besides a compiler, editor and debugger, you need a static code checker and you also need dynamic testers. The ones I know about are (I haven't used them all yet):

• PC-Lint static code checking for C and C++. It runs on Windows but Flexe-Lint comes as shrouded source code and is highly portable.
• Spotlight dynamic tester for Mac PowerPC - I use this every day and recommend it highly
• BoundsChecker dynamic tester for Windows
• Purify dynamic tester for Unix (but apparently not Linux) and Windows NT
• Optimizeit dynamic tester for Java - do you know many Java programs have memory leaks? Can you understand why? Not just Java but any garbage collected program.

Finally, to really come to understand the software quality problem in the industry and what you can do about it, read The Forum on Risks to the Public in Computers and Related Systems also available on the Usenet News as comp.risks. The book The Software Conspiracy exposes the complete disregard the commercial software industry has for serving the consumer by providing quality products - I haven't read it yet but it looks interesting.

A very interesting methodology that emphasizes personal responsibility and puts the fun back into programming as well as maintaining quality from the very start is Extreme Programming. I'm starting to adopt extreme programming (the the extent a one man operation can - I can't work in pairs :-/ ) and find it a tremendous benefit.

The Forum on Risks to the Public in Computers and Related Systems

The Software Conspiracy

While there will always be quality problems in software, current practice in many companies is to not even try to do the basic things that tend towards improving software quality. Until the public wakes up and realizes they're being ripped off, and their safety and corporate information being put at risk, we will always have this problem.

One solution is to get every programmer in a company a copy of some good quality tools, static analysis tools like PC-Lint and dynamic (runtime) analysis tools like Spotlight (for the MacOS) or BoundsChecker (for Windows) or Purify for Unix (but apparently not Linux) and NT.

As a Spotlight user and a long-time reader of the Risks forum, I wouldn't dream of shipping a Mac product unless it tested absolutely cleanly under Spotlight and had zero memory leaks.

But it is amazing to try Spotlight on a mature commercial product for the first time. Think you're program's free of bugs? Guess again. I proposed using Spotlight to my manager, on our program which had been shipping for several years and cost $600 retail. It was a serious product for high-end users. My manager said it would be a waste of time because "Our program has so many bugs, Spotlight would keep finding them and progress would be very slow." And you know, he was right. I persisted anyway, and spent three months ferreting bugs out of that program with Spotlight.

There's a lot of tools out there (and there's tools like these for Java too, like OptimizeIt - do you know many Java programs have memory leaks?). You don't have to pick the tools I recommend, but look out for what's available there and make sure you have something for every developer seat in the house.

It will be the best investment you make. The $199 for Spotlight will be paid for in the day it's first used.

And free software writers, I suggest writing free software versions of these. It would be possible in principle to write a special version of gcc, or an command-like option to it, that when your program is linked to a special library all your memory accesses are boundschecked. Note that Spotlight can validate memory reads as well as memory writes.

1. Microsoft has pulled the plug on its support for VJ++, and it will not appear in the next installment of Visual InterDev. The Rational Corporation is taking over the J++ side of things. 2. Where do you get the idea that MS J++ is widespread use? Just beacause a company has a licence for the MS InterDev, doesn't mean that they use J++. The majority of Java developers that I know of, either use Cafe, or JBuilder. Some of them use vi/emacs and the JDK! 3. Claiming the Jini is dead generally comes from ppl that don't know anything about the technology. Jini is totally new protocol with a new architecture and it is NOT designed for backward compatibility with existing CORBA, RMI or EJB. In short, it is a technology for the future. Hence, many telcos are investigating Jini for future use. ys

Everyone knows C++, but not everyone knows OO in the ture fashion. Does this book take you from the design process with an OO architechure which will really drive the OO development or does it just use object while maintaining a structured core?

A good place to check out OO design paterns an software would be www.rational.com.

As an individual, I could use some SE methods to develop an Open Source app, but who does that? No one I know of. I actually think that it might work and produce some good quality stuff if they did. Especially if all the people working on it have access to the same tools.

One important issue is the tools. KDevelop may be nice, but how does it help you do software engineering? It doesn't. What we need is quality CASE tools. ArgoUML shows promise but is lacking a lot of features and is still early on in its development. Together/J is pretty nice, but you need the commercial version to get all the features.

I have never seen an open source app that deals with requirements and design documentation. The thing we like to be able to do in industry is trace (follow) requirements to their implementation in design and code.

And then there's version control. CVS doesn't have all the features of something like ClearCase, but bitkeeper is looking good.

Why does so much commercial software suck when compared to open source? Probably lots of reasons. Market timing pressures, poorly documented legacy code, bad management. But maybe the most important one is lack of large scale peer review. In open source there are a lot of fresh faces who are free to come in and say:

"This design sucks!! We should scrap it and start over and we will come up with something better. Fine, i'll do it myself in a few hours."

Maybe you had a bad professors for your courses. Mine really knew his stuff. In fact, he recently started a Software Engineering major at MSOE.

There were a few good things about my SE class. (I only had one). One thing was that we were split into teams (not of our choosing). This simulates the real world. We also had project to work on where the professor was the client. And we did the project in 2 phases. (We only had 10 weeks!) The 2nd phase added some requirements and we got to see how good our design from the first phase was. We got to use Rational Rose, which is a pretty nice CASE tool. Once you put your model in as UML, you click the "Generate" button, and Bam! Out comes the skeleton code in either C++ or Java. We used C++ and put a MFC based front end on our app. Doing the actual programming was the easy part!

Then as an outside project I took the back end code and wrote a KDE front end for it!. And I did it in you a couple of hours!! I think this shows the importance of creating a design that is as non interface-specific as possible. (Depending on the purpose of the app, of course). One thing I like to do is think of what the back end code would have to look like so that the interface could be either text mode or GUI. It makes you think! Perhaps a good example of this is Linuxconf, with a text, X, and web interface, but I haven't looked at the code at all.

The SE course I took was probably on of the hardest (most work) courses I had in my four years, but it was also the most interesting.

I do agree that SE is a young field. Compare it to something like Architechtural Engineering. Architechture has been around for thousands of years. Computers have only been around for, what, about 50. And the idea of actually doing software engineering is even younger.

Hopefully the good ideas (I hate the phrase "best practices") in Software Engineering will stick and we will have better software to show for it soon. I agree with another poster though in that market pressures make this difficult for commercial software development.

Not internally, though some had an idea this may happen, it won't affect me much anyway.

Rational makes diverse sw engineering / development / testing tools, for quite a few platforms though windows more than most.. Also does a lot of process oriented stuff, and all the tools are migrating towards supporting the UML, so that small/mid companies can buy 'process in a box'. The hard part is keeping enough flexability so that places who already have a well developed process are not restricted.

I work on the Unix side of things here and while not perfect, I'm glad I made the switch from my old 'dilbert-esque' employers.

Look at the website for lots of info and gratuitous advertising ;)
www.rational.com

First of all the article calls Rational software a "tools rival." Hhmmm.... I wonder how you can be a rival and a be in a strategic alliance at the same time? This allaince was started back in 1996 and renewed July of this year.

My take: They have a vested in interest in Microsoft surviving its probelms intact. Rational's website tauts MS as a "powerhouse" in the industry and refers to this as a "Good Thing" TM. Rational Software will be able to develop J++ along the same lines as Microsoft but w/o all the "restarints." Back to square one Sun.

Check for yourself:
Proof

Corporate intrigue...

• Put all your code into a single function. (I've seen functions over 2000 lines in length.) After all, those nasty functions generate overhead on each call, and you want your code to be efficient right?

• Use hungarian notation for variables. Then instead of the overly verbose

  int numLinePayments; char *maxTypeCode;

  you have the nice and compact

  int iNmPt; char *szTyC;

  BONUS: With compact hungarian notation, you can become even more descriptive! So really the above becomes:

  int iLnNmMtCsByPt; char *szMxQtBlTyAcC;

  So much more descriptive information, all in the same amount of space. I've been on projects using this, and the sheer of joy of it cannot be accurately described in words.

• Don't indent your code uniformly. (This is a variation on #11 from the article.) Use Windoze or vi editors, with non-standard tab widths, for tabbing and indenting, which means that no one can see your code indented properly unless they use the same tools you use, with your same editing configuration.

  BONUS: Write extremely long lines of code, well over 80 characters per line.

• If using C or C++, don't use memory analysis tools like Purify, or its open source equivalents. After all, if you find your bugs too quickly, you might lose your job.

• On large projects with several programmers, make sure you change global header files that cause everybody else's code to break but yours. Do this late in the afternoon, so all hell breaks loose breaks right before people are going home, or late at night, so that everybody comes in fresh the next morning and wonders what the hell happened to the code that compiled perfectly when they left the day before. Either way, make sure you are not around when they find out! Otherwise you spare them the joy of figuring out what you changed, and why.

  BONUS: Do this right before a major deadline.

• Do really stupid stuff that you were taught from day 1 not to do, but everyone seems to do anyway: don't check for NULL, fix array sizes where you hardcode the max size everywhere, don't check for invalid or oversized input, etc.

• Use preprocessor macros. Lots of them. (I was actually on a project where someone suggested using cpp to define macros. For Java. Absolutely brilliant!) The key is to use a single macro for multiple statements, in effect using macros as function calls. Example:

  #define DO_STUFF(x,y,z) if (x else more_stuff(z); \
  mystery(a*2, z-1); \
  for (int n = x; x != foo; x--) \
  more_stuff(n - x);

  Notice the "hidden" use of external variables and functions. Remember, you want to avoid those expensive subroutine calls! And think of the joys of setting breakpoints and stepping through a debugger on that code!

  BONUS: Don't use the all uppercase convention in macro names; use the same naming convention as function calls. It's even more fun to debug when you have to spend time actually figuring out do_stuff() isn't even a function call!

  MORE BONUS: Nest macro calls. Use the naming convention above.

  EVEN MORE BONUS: Use macro calls as variables. Make sure the expanded macro makes function calls. Or uses other macros.

• Don't use source code control. Or, use it, but never unlock or checkin your files. Feel free to steal locks on others, though.

• Write code only for yourself. Assume no one will ever need to figure out how to use your code without poring through it in painstaking detail. Do not make it easy to use, interface with other code, or even compile. Include 30 caveats that would take you only a few minutes to fix, but you're just too lazy to. In other words, write as if no one will every look at or use your code, yet release it to everyone to look at and use. Defend your laziness, which is causing thousands of lost hours of work to others, by uttering useless and stupid "cool hacker" mantras like "Real Programmers don't write documentation" and "If it was hard to write, it should be hard to understand."

Lets all mail rational and see if we can get them to port some of there products to Linux..

Here is the person I dealt with, send a polite email expressing your interest in their products and hoping they get ported to Linux. (If you are interested in there products.)
Franco, Kathryn