Coding Classes & Required Development Environments?

Sadistic Yoda asks: "I walk into my entry level C++ class and the TA informs us that the code must compile under CodeWarrior for Windows, which is included with the text (Problem Solving with C++: The Object of Programming, Second Edition, by Walter Savitch), to receive passing grades. Personally I would rather use vi and g++ on the department's Debian machines from the shell. Will I run into any problems or do I bite my tongue and make it through class using their program?" I find it disappointing that schools think that "teaching programming" involves locking their students into a specific environment. I know it makes it easy for the teachers and TAs when it comes to technical support, but what about those students who already have a handle on their own system, are willing to learn the language (and its pitfalls in all environments) who can't (or won't) run the required software for whatever reason? Is this limited form of teaching really teaching?

Teaching on a specific platform cuts the BS.

You're in college to learn the fundamentals of programming.

It's easiest to teach the entire class by making sure everyone codes on the same platform, using the same development toolkit.

If you already know how to code, by all means, petition the college to allow you to skip the intro courses. Later courses will allow you to program in whatever development environment you wish, in my experience.

Freshman-level courses, though, NEED to be taught on a STANDARDIZED platform/environment, because it's hard enough to teach people to think like a programmer; it's even harder to teach them if they're not using the exact same frames of reference as you are.

If you really want to skirt the rules, try installing CodeWarrior for Linux, programming your assignments there, and making sure they compile under the Windows version. Other than that, forget about it.

- A.P.
--

"One World, one Web, one Program" - Microsoft promotional ad

Re:Cliff is a fool

Judging by the comments here, it looks like there are a lot who have had similar experiences.

Having been in a similar situation myself, I think the reason for the frustration goes beyond simple convenience (although that certainly would play a role).

I'm guessing that if a lot of Linux users are like me, most of us did use DOS/Windows/[insert inferior platform of your choice] earlier in our hobby computing experience. Then, when we found something that was so much better, we thought, "Why haven't I been using this all along? It's so much better, does all the stuff I need it to do, all the source is available, AND it's FREE!" (as in beer, because upon initial introduction, we probably haven't quite yet learned the concept of free as in speech.)

Then (speaking from personal experience here), one walks into an educational institution with the mindset of having discovered these great tools which cost nothing and blow the $100/copy commercial-ware out of the water (in some areas, but maybe not all). We soon discover that many in the organization -- especially the ones making the crucial decisions -- are simply NOT INTERESTED, despite all the advantages. This can be quite befuddling.

After all, we managed to switch to what we think is a far superior solution. We took the time and effort to repartition our hard drives, read the HOWTOs, tweak the modelines in our XF86Config, recompile our kernel, and twiddle with the rc files to get everything perfect. And we are very pleased with the result! Therefore, we wonder why they seem too stupid and short-sighted to do the same?

This is especially true if you believe that open source/free software is the way of the future. Who wants to be stuck learning how to train dinosaurs, when the dinosaurs will all be extinct in ten years?

That said, I do believe that I personally learned more about writing portable code as a result of having been forced to make all my stuff also work under VC++. As one of the other commenters also mentioned, I also discovered to an even greater degree why I find it so much more pleasant to work under Linux. ;)

Re:Well, It's probably fair

It sounds like you're not locked into actually using it for anything but a quick run-through at the end to make sure it compiles right.

I know of no commercial developers who use g++ to develop on. It's just not practical. Like it or not, IDEs increase productivity, and that's why we use them. If these students are going to be professional programmers, they're going to be using IDEs their entire career. Why the hell shouldn't they be learning from the get go how they function?

Any CS program that doesn't teach a student how to use and IDE is being negligent in their curriculum.

Re:similar experience

absolutely right!

having just ta'd intro to c++ last year, i can think of a miriad reasons for sticking to one commercial dev environment only - you don't have to worry about non-standard implementations of c++ (ie. "what do you mean my code can't work? it works just fine in my turbo c++ 0.39beta for dos!"), you don't have to worry about students using environment differences to cheat (ie. "what do you mean my code can't work?", again), you don't have to worry about usage differences (ie. "to insert a breakpoint hit F9, unless you're using xgdb in which case you hit C-space, or if you're using codewarrior, in which you right-click in the margin to the left of the line in the editor, or if you're using turbo c++ 0.39beta for dos..."), you can actually teach very environment-dependent uses like debugging tricks and project management, et cetera, et cetera... :)

but, we've always made a point of allowing people to use unix tools if they want to. it makes us very happy if someone asks to do that - it usually means they know what they're doing and they'll be a good student. :)

Another point to consider...

A few people have mentioned instructors being overjoyed or at least pleased that some of their students have prior programming knowledge in their entry level classes, but this brings up another question: if you've already been using vi and g++ for some time, perhaps you'd be able to test out of the class and free up some time on your schedule (or take another elective, or whatever else suits you). Many colleges will let you test out of a class within the first week or so.

And to address another point that was mentioned in a few peoples' posts, the college where my son will be attending has a very strict policy on students' computers in their dorm rooms which are connected to the ResNet. To quote from their FAQ:

Q: Can I run Linux, Unix, BeOS, or any other operating systems that aren't listed on the minimum configuration list?

A: No, this network is not set up to handle the types of operating systems. You will not be allowed to get an account if you plan to run one of these operating systems on the network. Your account may be revoked and disciplinary action may be taken if you are running an unsupported OS.

Their "minimum configuration list" for PC's includes Win95/98, NT 4.0, and tentative approval for Win2K after May 2000 (I guess they haven't updated that page in a while) This, of course, is a whole 'nother can of worms, that's probably been discussed in previous topics.

Re:Like it or lump it, it's necessary

In my uni they just hire a bunch of upper level undergrads to grade the assignments for intro CS classes (the ones with lots of people). They pay them like $7/hour and free pizza during all-night grading sessions. Sometimes you just demo your program to the consultant, in the computer lab assigned for the class. Such a demo is good because then you have no excuse for it not working.
FYI for the intro CS class they use CodeWarrior here too, but for other CS classes it's either Visual Studio or gcc/g++ and I've has classes where YOU PICK YOUR LANGUAGE OF CHOICE! How cool is that.

Valid Teaching Method

Since it is an entry-level course, I think its a perfectly valid way to teach programming - all the class organisers are trying to do is to keep a level playing field, as well as to encourage co-operation (note to students: NOT plagarism!!! ;o).
Things at this level are all about getting the basics in place, and forcing one platform onto all students is one of the best ways of making sure that knowledge assumed by later classes is definitely given in the early ones. Oh, and it makes the lecturer's job easier if you have to submit code for marking if he can load all code into one app instead of having to go to different machines or reboot into a different OS just to check one student's work. Do what I did - code the uni stuff the way they want it, then redo it in your preferred environment (or indeed language - I converted stuff from my Java classes into C++).

Re:That's way the world works

Poster, what this really means is the TA, much less the lecturer, is NOT EVEN LOOKING AT your code to start with.

As a former TA speaking here: No fucking shit. You think the TA gives a toss about your worthless self? It is to laugh. Ho ho! The TA is trying to get through school just like you, and wants to put in the least possible effort for the money. Like, duh.

You are being deprived of informed criticism of your work by a competent and skilled instructor/authority beyond your own judgement.

If you don't understand something, then come ask about it in office hours. If you don't, then I assume you figured it out and I give you perfect marks, that's far easier than actually bothering to figure out if you have a clue or what.

I've got better things to do, like my own work, drinking beer, and shagging all the little hotties in the class. (Note to prospective TAs: Your school probably has some equivalent of mine's CMPT 100, "Introduction to BASIC programming for Business Students". It is full of 18 year old wannabe MBA hotties with no fucking clue whatsoever who look up to you as second only to God. Can you say "target-rich environment"? And this nincompoop thinks I give a flying fuck about whether some geeky frosh can write code or what. Hah!)

What education is for.

Often education is much more about life skills than people think. At some point, most people have complained to their teachers that what they are learning is pointless. The answer always comes back that we are not just learning the material but also study skills. In the work I have done I have not learnt much about computers but I have learnt a lot about working for people (they never know what they want and they force you to do stupid things). If you work for people, they may force you to work in their standard environment. They may force you to use a commenting style you are not used to. They may make you use libraries that you do not like. The teacher here, while making life easier for himself is mirroring what some companies will do. Now is the time you have to learn to be flexible, even if you think the people in charge are wrong.

You probably want to do it their way...

The fact is, there's some good reasons to do it. For one, it's exposure to multiple environments. (And that's a good thing, despite what the anti-anything-but-linux trolls will tell you) The world isn't linux centric, nor is it M$ centric. Knowing both is really important. Even if you don't intend to develop with CodeWarrior You'll probably run into code written in it that you'll need to maintain/contribute to. ESPECIALLY in entry-level/intern programming positions. I'm a unix admin/developer and i still end up working with M$ C (and various other development environments) on a fairly frequent basis.

Secondly: It's a kickstart to learning the language. I wouldn't reccommend attempting to map codewarrior quirks to gnu quirks in your first few programs, especially when you're trying to learn.

Lastly, to actually LEARN you can always develop on the unix boxes and port it to codewarrior. That's valuable practical experience in writing portable code.

And tell the TA you're doing it, too.

--Dan

Many reasons . ..

I can think of many reasons why I would require students to use a single environment, particularly when teaching an OO language. Some of these include:

(1) so the professor can distribute lines of code and libraries for all to use in projects;

(2) to assure that code may be tested directly and automatically against testbed code; (the single worst part of graduate school for me, was the process of grading computer programs);

(3) to facilitate group programming projects.

Former TA

In the first- and second-year CS courses I TAed
(waaaaay back in the Dark Ages when Pascal was standard), the reasons we specified the environment included:

1) Availability of lab resources. Often times the computer lab is only going to have one type of machine with a limited selection of development environments for the various classes. Today this is less of an issue, because most students will have their own computers (further increasing their desire to use a custom platform).

2) Compatibility. Besides basic issues with the compiler and standard libraries, we often provided completely or partially implemented code in the course of assignments, and could only afford to make sure that it worked on the specified platform. Imagine if you were a student trying to get an assignment working and discovered there was a bug in the code provided with the assignment when compiled in your environment. Clearly we had to define this
behavior as "at your own risk".

3) Proprietary native interfaces. In the very introductory class, we were using Pascal on Macs, and provided native widget libraries so the students could create more visually interesting programs than println('hello world'). Today of course there are cross-platform alternatives.

4) Mechanical concerns. As others have pointed out, testing submitted programs generally involves both compiling (to make sure there are no warnings) and executing them to evaluate that the output is correct. In classes of up to 200 students, no way can you be prepared to do that on 4 systems.

5) Support. TAs could not necessarily be expected to help with compiler or dev environment issues for more than one platform.

Today students have the luxury of a well standardized C++, that allows you to write compliant code that will compile under g++,
msvc++, or one of the edison design group
based compilers, not to mention Java. Nonetheless, in the context of a particular course I would still expect to see a pretty standardized configuration designated as the target platform for assignments.

That being said, advanced students could and
can still always follow whatever development process they wanted "at their own risk". Just don't expect your TA to bail you out if you run in to trouble!

Study Fundamentals Not API's, Tools or OSes

I heartily agree.

I'd further like to say that I think everyone should spend less time concentrating on learning specific API's in great detail, and instead focus on improving your core skills and fundamental understanding of programming.

I used to spend a lot of time learning API's (bought every volume of Inside Macintosh as they came out, and when I was just starting out and broke and hungry, used to read them in the bookstore before I could afford to buy them).

I prided myself on knowing all the little bugs and intricacies of the MacOS so I could just know to code around an OS bug without having to research why my code didn't work. I got so good that I was hired as an OS engineer at Apple where I concentrated on debugging the MacOS system software with MacsBug (a machine level debugger) - I had the MacOS source code at my disposal but that usually didn't help when I was visiting a tester's cubicle to diagnose a machine with a hard-to-reproduce crash.

Then I moved to the BeOS, shipped a product and wrote a lot of code but got fed up with their lack of commitment to their developers. And without getting paid to write BeOS code, I never could keep up with the BeOS API's I wanted to work with, like the new Media Kit (which I do know enough about to say it is pretty cool).

A couple years back I stopped spending much time learning and mostly just cranked out routine code. I felt I didn't want to learn anymore because, as I would sometimes say:

I feel that if I have to learn another API my head will surely explode.

Ever since I read C++ Answers from Bjarne Stroustrup [slashdot.org] I got the gumption to start learning again. What I decided to do was go back to learning the basics.

I read Scott Meyers' Effective C++ [fatbrain.com] and More Effective C++ [fatbrain.com] and as I read through each item I inspected my program top to bottom and applied the advice to it (thus fixing a lot of bugs).

I also bought Bjarne Stroustrup's The C++ Programming Language: Special Edition [fatbrain.com] (I recommend the special edition to professional programmers).

I started reading the newsgroups comp.lang.c++ [comp.lang.c], comp.lang.c++.moderated [lang.c.moderated] and comp.std.c++ [comp.std.c] and posting questions there - in one case I found a construction on the very edge of the C++ standard and as a result of a compiler bug managed to instantiate an object of an abstract base class - its pure virtual function had a nil pointer in the vtbl and my program would crash when this function was called. An engineer from the compiler vendor read my post on the newsgroup, agreed that it was a bug that his product would compile my code, and logged a bug.

I didn't used to use the Standard Template Library very much at all. I had read too many mailing list and newsgroup postings from people whose code wouldn't compile when they changed platforms.

But I figured that by now compilers must have matured enough I could reasonably start trying out the STL. I bought STL Tutorial and Reference Guide [fatbrain.com] by Musser and Stepanov and actually only read a little bit of it before I realized that the STL is actually really easy to use (the API is very simple and uniform), so if you know only a very little bit you can go a very long way.

In part because of challenging myself I became overwhelmed with programming stuckness as discussed in Overcomming Programmer's Block? [slashdot.org] (sic) and I suppose grew a little bit by taking a week off without pay to rest, contemplate, study and take a broader view of architectural issues.

One thing that helped quite a bit was learning about Extreme Programming [c2.com].

These things have all had direct payoff in my code, both in making my code quicker to write, easier to debug, easier to make my classes more reusable within the one program I've been writing the last few months, and I'm pretty sure more likely to make some of the code I've written reusable in most any program in the future.

It's also made it a lot more pleasant.

But don't listen to the headhunters [goingware.com] - what they're looking for is "skill sets" and industry buzzwords (COM, COM+, DCOM, TCP/IP, Visual C++, ASP, SQL, device drivers, CORBA, Unix internals, Java, Perl, PHP, JSP) - I get recruiter calls looking for all kinds of acronyms, most of which I don't mention anywhere on my resume.

Even I advise listing every skill keyword you can legimately claim on your online resume in Market Yourself - Tips for High-Tech Consultants [goingware.com] - but while listing skillsets may be a valuable jobhunting tool in your resume, acquiring them should not be your focus.

BTW, when someone asks me whether they should learn Java or C++, I usually advise beginners to learn Java as it's easier to get something working reliably without crashing, but emphasize they should learn both languages as well as at least one kind of assembly code. I stress that it's important to learn both C++ and Java well enough to understand the strengths and weaknesses of each (pop quiz - why does Optimizeit [optimizeit.com] claim to remove memory leaks from Java programs, when Java is a garbage collected language?).

Most new programmers these days are most concerned with which language will make them the most money the fastest. I tell them that they won't go anywhere until they can pick up any new programming language as a matter of course and have at least a couple under their belt.

I've got bad news for you neophytes - friends, just knowing a programming language doesn't win you very much in the work world, you have to understand the concepts and how to apply them, and you have to know how to apply them in a production environment, working in a business under pressure, shipping working products and dealing with people who don't understand anything of substance about computers.

Your focus should be on acquiring skills that will be applicable to any program you write. You should just learn enough of a skill or tool to get the job done and then leave it. Take with you what can be applied anywhere.

BTW - learning the fundamentals and not getting too specialized enables you to develop for any platform, as I do - you can see this from my homepage [goingware.com]. (Perhaps one reason why I prefer understanding the fundamentals is that my degree is in Physics, and I've always wanted to understand things at a fundamental level - Quantum Mechanics, Particle Physics, Cosmology and so on.)

One final word of advice - read The Forum on Risks to the Public in Computers and Related Systems [ncl.ac.uk]. It's often entertaining and funny, occassionally tragic, usually insightful and will make you a more responsible programmer and a wiser computer user. You'll certainly learn to avoid using computers for anything of real importance and take extra caution to protect yourself when you choose to do so.

Re:Valid Teaching Method

>>Things at this level are all about getting the basics in place

Which is why I would think that the standard should be ANSI C/C++. That way you are guaranteed to have the solid foundation, and if you later move on to fancy IDE's with extensions, it doesn't matter which one you (or your Prof. or boss) choose, because your knowledge will translate into that environment. If that environment has nice extensions and handy non-ANSI classes and such, you'll be ablt to appreciate those better. For instance, I use C++ Builder at work, and it's nice to use AnsiString, which has features like an overloaded "=" operator, but when I recently worked on a demo project that needed cross-platform compatible code, it was good to still know how to use strcpy with char *'s.

By the way, I had a class like this too. We were told that our code had to compile in Borland C++ 4, and to submit our source code and program to the grader. It turned out the grader was running a Solaris box, so he just pulled the source files out, discarded all of the IDE bloatware, and compiled with gcc. My point is, since it was all standard console-type code, it didn't matter how we developed it. Make ANSI your class's standard (that's why it's a standard), have the students submit the ASCII source code, and then let the TA/Prof compile it in whatever combination of environment and OS they please.

Do not teach Confucius to write Characters

Cliff is a fool

Does the school have Windows machines with Code Warrior on them that you can use to compile your assignments? If so, I don't understand what the big deal is. I don't think it's unreasonable to expect the TA's not to want to bother fudging around with code to get it to compile on the platform they're using. If they don't provide the environment on machines at school, and expect you to go out and purchase your own box which runs Windows, then maybe I'd complain. (Although apparently many schools in the US expect students to purchase their own computers and do everything at home; here, the labs on campus provide all the facilities you need for your courses. In this case you may have no choice, but see the texbook analogy below.) But otherwise, who cares?

Most CS courses here are the same way. If your code doesn't compile on the platform being used (often g++ on Unix)