Please create an account to participate in the Slashdot moderation system

 



Forgot your password?
typodupeerror
Programming IT Technology

Coding Classes & Required Development Environments? 377

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?
This discussion has been archived. No new comments can be posted.

Coding Classes and Required Development Environments?

Comments Filter:
  • by Anonymous Coward
    ******** After i asked, the teacher had to explain what vi, g++ and linux was to the class. Seems a lot more people are coming into computers for money and not the love of the game. ******** I don't find this statement fair. I'm starting my first year in Comp Eng very soon (this september) and I have a lot of previous knowledge. But I also realise that most other people will not have a clue. That's what they're going there for, to learn. There are no programming/engineering prerequisites to get into the program. They don't expect you to already have knowledge, they will teach you everything you (supposedly) need to know. This is like saying that anyone who doesn't know how to fill a cavity but wants to be a dentist only does it for the love of money.
  • I long for the days when such intelectual questions eisted for oneself and not the social or work environment of the moment. I wish I were walking into such new territory with my eyes wide open. I am 28, yet feel so old. God, can't I be 19 and a blossoming programmer again? Again you ask? You are not even a programmer now, you are an Internet infrastructure Consultant. Yahoo should have been my idea, or I should have just been a musician. Oh well, next time.
  • by Anonymous Coward
    Same issue is happening at my school, to some degree. I don't program anything at all, however both my roomates are taking a Java course at the college here. That's the write once, run anywhere language, right?

    I offered to set up a guest account on either my O-BSD or Linux machine for them, however one noted that the teacher specified they use the Windows JDK to write the programs and create the java classes with (or something like that) and they're afraid the differences (if any???) might lower their grade. I'd appreciate it if anyone could tell me if this is a valid concern.

    Anyway, this is college we're talking about. The teacher can pretty much demand anything they want, and your only options are to take another section , do it their way, or suffer...
  • by Anonymous Coward
    would this be a slashdot story if the course was using a gnu compiler and the student wanted to use visual c++ ?

    my school uses unix hardware so we have to submit stuff that can be built on the school machines.

    relevance?
  • by Anonymous Coward
    he was almost overcome with joy?

    Then consider the very real possibility of a contractual arrangement between his school and Micro$oft that prohibits the instructor from mentioning any alternatives to Micro$oft products unless a student asks. That one student's question opened up the door.

  • by Anonymous Coward
    I know of no commercial developers who use IDE's to develop on. Like it or not, XEmacs and GCC increases productivity.

    If these students are going to be professional programmers, and they're still clicking and drooling in an IDE by the time they graduate, they will be incompetent.

    Any CS program that doesn't teach their students how to develop using the command line is incompetent and should not be accredited.

  • by Anonymous Coward
    The post never said that you are forbidden to use anything but Codewarrior, it just said that it had to compile under Codewarrior to get credit. Use whatever you want to write and compile it... just make sure when you turn it in it will compile under Codewarrior.
  • This professor apparently said code must compile on Codewarrior for grading. He can NEVER mandate that you develop on codewarrior. If you stick to ANSI standard stuff, you can build/test/run on Debian, and just open everything in Visual C++, codewarrior, etc to create the project, then submit it for grading. I've been doing this for 4 years at Virginia Tech, no problems yet. Of course, all bets are off if you're required to use MFC or some platform dependant extensions.

    Platform requirements are good. In the real world, you'll probably not be shipping a product on Linux, at least, not as the target platform (a port would be likely, though). Cross platform code is important, and this will force you to learn how to write it. Requirements for the platform are also good in that the majority of the class needs to learn to CODE, not learn a new IDE. If the department standardizes on one IDE, professors can teach it as they need to, students don't need to learn a new one each semester, and projects can be graded fairly and consistantly.

    On a side note, the required platform for my Operating Systems class at VT is any linux system with kernel 2.2.x. You might find that IDE's are forced on you in the intro level classes, but in the more advanced ones, that will be left open. Someone in my class asked if they can use VC++, and the professor said "well, if you can build a Linux kernel in there, you definately deserve to pass this class... but I wouldn't recommend it..."

    --

  • Most colleges have huge computer labs with a variety of machines. I find it hard to believe that a few of these machines can't be made available to TA's for the purposes of grading projects.

    So you're saying the TA's should go to the extra work of having students specify the platform they used, sorting assignments by platform, and testing the code MANUALLY on all the types of machine used? Then what happens if the code fails to compile because the student had a slightly different environment (which could be something as simple as different paths, environment variables, etc.)? Since you've obviously completely failed to comprehend what I'm talking about, let me use a SPECIFIC example then. What if the student used Visual C++ 5.0, and the computer labs only have version 6.0 installed? Is the TA supposed to MANUALLY load the project and figure out what needs to be done to convert the project? And is he supposed to repeat this MANUALLY for HUNDREDS of assignments? How exactly do you propose to handle such situations?

    Impossible? Do you honestly believe that? Have you tried? That's the reason why I posted this question. If it's so impossible (read: "highly improbable") then why is that, and what might be taken to make the improbable, possible?

    Yes, I do honestly believe that. If you want to disprove my claim, then I would be happy to hear you describe how you would develop a course, with automated marking of assignments, while allowing students to use any platform and environment they choose. If your marking scripts use g++ and GNU make on Linux, then explain how you would allow students to use MS Visual C++ or Borland C++Builder without making any changes to fit the platform you run your scripts on, or testing their code on your platform. Now describe how you would extend this to work for arbitrary compilers and types of makefiles.

    No matter what you come up with, I will be able to find SOME incompatibility between environments that you haven't considered that would cause a program to work on one system but fail on your marking scripts.

  • I apologize for misinterpreting your commentary, although judging by some of the other comments in this thread, I don't think I'm the only one who thought it was motivated by an over-zealousness to advocate Linux.

    Sure if you go to class and you want an easy time staying with the professor, then use the same environment that he is using, but ANSI C++ is ANSI C++ and if the professor is not teaching to the standard then that is a problem. ANSI C++ code should compile fine on any compiler from Solaris to BSD to Windows and Macintosh ...

    Not necessarily. The ANSI/ISO standard for C++ has been a moving target for years, and there is still a lack of standardization amongst compilers. Of course, it's getting better, and most code should compile and run the same using any modern compiler. But in every C++ compiler I've used for a reasonable period of time, I've still encountered many quirks. I speak from experience. I have even run into problems between different versions of gcc when submitting code for an assignment. Secondly, the submittor nowhere said his professor isn't teaching according to the C++ standard.

    Also, if you really think telling students "you can use any environment you want, just make sure the code is ISO-compliant" is at all a feasible alternative to telling them "make sure your code compiles and runs using CodeWarrior for Windows", then you've obviously never taught or TA'ed a course before! The less explicit you are, the more students you're going to have screwing up somehow, and complaining that "it worked fine on my system". Moreover, there are things to consider outside of the language itself, such as what kind of project management to use (i.e. makefiles), libraries, etc.

    Why not give students the tools and knowledge they need to work under any environment?

    Because that's impossible!

  • I have a copy of Code Warrior for Red Hat Linux (Gnu edition) version 4 right here.

    Basically, they ported the editor, and project manager, and use egcs as the backend compiler.

    It's decent, but I found myself missing their backend compiler (It kicks serious butt).

    They were working on a full port of the entire package (editor, compiler, debugger, etc) to Linux, but I don't know what the status of that it.
    --
  • I didn't make the claim, but yes, I do have a job programming on Linux and FreeBSD with gcc/egcs. I'm a firm believer in having design meetings over pizza and and a few pitchers, which makes them go by much faster, and tends to get everybody involved relaxed enough that it removes a lot of ego from the design.

    Not to be rude, but it sounds to me like you need to spend more time looking for a job that suits you well.
    ----------------------------
  • Yar, but the printf's are ugly -- you need to either have different debug and release versions (if you use the precompiler to remove them before release), instrument your code manually for testing (ugh!), and furthermore they don't help much if the problem is somewhere other than where you anticipated that it might occur. In my experience, problems are usually where you DON'T expect them to be, and thus where you don't have printf()'s.

    Besides, printf-style debugging does you little good when figuring out the error involves stepping into some library call you happen to be using...

    I agree, though, that having well-written code helps a great deal.
  • Trust me, printf statements don't hold a candle to a proper debugger. Learn to use gdb, or ddd (if you like the right-click-to-set-breakpoint thing rather than typing "break somefile:50").

    Needing a debugger isn't the same as needing an IDE. You probably don't need an IDE -- but start doing Complex Stuff, and you _will_ need a debugger.
  • No, no, no! Avoid not starting any kind of confrontation. If a later employer insists on that nasty 'Y' platform, quit. You'll have a new job by the time you get to your car in the parking lot. As a student, fight the fight every single day, never let up, and never give an inch. If the TA is uncooperative (likely, they really aren't paid to take your shit), talk to the professor, then the chairman, then the dean, then the vice president(s). Schedule an appointment with the directors or trustees or board of regents at your university, or the president. Never stop, never give up. Remember, most of these people are basically droids - they have zero understanding of technical issues and they probably don't understand why Microsoft products don't help their students get an education. You need to tell them! And be ready with viable alternatives.

    I an the systems administrator for a computing center at a university. The machines are half peecees running some type of Microsoft OS, half SGIs with IRIX. Every single day I fight with the lab manager over her priorities - she seems to favour the Microsoft platform, and I insist repeatedly that Unix is, if not dramatically superior, at least more important for students. The most important thing I've found is to always have answers to "yeah, well, I know how to do 'Z' in $FUCKED_UP_OS, but how the hell do you do it in Unix?" I have answers - viable answers that involve well-known, very usable software - for hundreds of those questions. The lab manager isn't stupid, just too tied to what she already knows, which unfortunately isn't Unix.

    I will admit that I'm getting tired of fighting. After a while I do start to wonder whether there's an agenda involved; there have been several well-known incidents in which Microsoft has offered various bribes to schools to get them to teach only on their platforms. Any school that accepts these bribes is doing their students a terrible disservice, of course, but some still do. We aren't involved in such a thing, but I do sometimes wonder just how much pressure Microsoft and certain of their apologists are applying. Don't get me wrong - virtually every vendor offers bribes in the form of educational discounts - but Microsoft seems to be the only one to insist on exclusivity. And they're also the only one known to have offered bribes for favourable mention in papers and classes. This certainly seems contrary to a university's educational mission, but again, most of the higher-ups at a university are completely obsessed with money and have no real concept of education at all. Certainly that's true here, and that's really what makes it so hard to fight them and win. Both technical and educational goals take a back seat to money. It's interesting, then, that telling them about the enormous costs - licensing, maintenance, lost work due to unreliability - associated with the Microsoft platform doesn't seem to have any real effect. So it's hard not to become paranoid and assume that something bigger is afoot.

    It's unfortunate that many if not most students enter the computer science field (which, incidentally, has little to do with coding, really) just for the money they can get when they leave. And certainly many of them have the mistaken impression that the Microsoft environments are where the money is. Fortunately, unlike most of the high rollers, the students can be convinced otherwise. I make it a point to mention, for example, that knowing Unix makes it much easier to get a job, and will almost always result in higher pay. Of a completely unscientific survey of several recent graduates I know, the ones doing only Unix work are being paid about $10k a year more than those doing mixed Unix/Microsoft work, and about $20k more than those doing only Microsoft work. It may not be scientific, but it is compelling.

  • At least they choose probably one of the few dev environments that, in my experience, tends to avoid propriatary enhancements to the language. That is, as long as you avoid anything GUI and the course is mainly for C++ programming, you can probably port the code from a *nix style environ to CW with minor hassles (project management). I doubt that it's that easy with Borland or MS given what I read in programming trade journals.

    Of course, the key thing in any C++ programming: AVOID PRAGMAS, as this seems to be the largest area of differences between win dev environs.

  • My father has taught Data Structures, which was also used as an intro to C course. We learned it on Linux boxes using vi or pico. That was the only way he wanted it done.
    Is this any worse?
    A prof has to grade all of the homework. If your code doesn't quite work, you do want partial credit. By keeping the base for the code the same, it is easier to pickup on student mistakes.
    Also, by keeping the base the same, it is easier to pick out those that are cheating, wich is something all too common in the lower level CS classes.
  • Seems a lot more people are coming into computers for money and not the love of the game.

    I agree, and I wrote about it:

    Bad Geeks in Information Technology [monickels.com]

  • That's because you called it t.c and used gcc to compile it, so it was compiled as a C program.

    Instead, either call it t.cxx or use g++ to compile it. Treated as a C++ program, it compiles fine.

  • If you want to use vi/gcc then you should learn how to write portable code which will compile in that environment and the CodeWarrior environment.

    I don't understand what the big deal is. You seem to be accusing the TA of trying to lock you into the CodeWarrior environment, but on the other hand the only way you're going to have a problem is if you lock yourself into this gcc environment.

  • In theory this is true. In practice there are many quirks in the various virtual machines that make this a tad more problematic than Sun's marketing people will have you believe.

    One of my 1st year courses involved programming in Java. I spent a few hours once chasing down a null pointer exception that crashed on my computer, but worked perfectly on the SunOS machines at uni, and the windows machines of the other people in my group.

    This was multithreaded code, so I spent some time checking for deadlocks caused by the faster speed of my computer. It eventually turned out that another group member had done:

    for(i=0;i<=array.length;i++) { stuff with array[i]; }

    and this worked perfectly on evryone elses system, except on the linux JDK, which ended up a few lines later with a NullPointerException. I never worked out why it didn't give ArrayOutOfBoundException, but hey... I couldn't get a simple test case either, to report the bug.

    Every CS project I've done (I'm in the 2nd semester of 2nd year, doing some 3rd year courses as well) so far has had me finding some bugs in whatever language/compiler/utility library I use. This includes the assembler course, where I managed to get SPIM to misassemble some of the pseudoinstructions.

    Just because it works on one computer doesn't mean that it works everywhere - thats why porting software involves more than typing make.

  • ...if you're writing your code portable?

    Never use any compiler specific extensions and compile everything with something like
    g++ -Wall -pedantic -ansi

    As long as the other compiler is ansi compliant you shoulnd't have any problem.

    I've done this lots of times. To name a few:
    * Using Visual C++ for developing for a HC16 processor (just recompiling with the appropriate compiler later. Created a massive HAL/HEL for that, but since the hardware prototype wasn't done yet I saved the company lots of time by being able to have code up and running before the hardware could even power up.)

    * Using g++ for developing windows apps (did the algorithms in g++, doing the hardware specific stuff in VC++)

    * UN*X (Solaris actually) programming using VC++. Since it was console only, the only thing I needed to do was recompile the code. No errors, no warnings, and a fully working program.

    Unless you have to write platform specific code ofcourse, but if you're set on using g++ as development platform an emulation layer isn't that hard to implement.

    I say, try to write code as portable as possible! Don't rely on nonstandard libraries. Unless they're ported already or you want to implement them yourself under the new platform.

  • 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).

    We do that too, (heck, I was marking first-year courses when I was in second year), but if you didn't set up automated testing, it would still take them far too long - the supply of undergrads with clue is finite (and doesn't seem to be growing nearly as fast as enrolments in CS subjects).

    ...and I've had classes YOU PICK YOUR LANGUAGE OF CHOICE! How cool is that.
    Particulrly in upper-level subjects and where the enrolment isn't too outrageous, this is quite sensible. Usually, though, we restrict it to "must compile under platform foo".
  • We actually had a "verify" that did this, and you're right, it's a good idea. However, it's amazing how often the private TA-only test cases depend on some part of the project spec that students interpret differently than you do.

    One other general point - it's amazing how *hard* it is to write good test drivers, isn't it?

  • 1) Is this another way for MS to gain student mindshare?

    MS already has mindshare, that's why their software is bundled with textbooks.

    2) Why were they forced to buy a product for a single use in a class?

    Since you're asking this, I assume you've never been to college (not trying to insult you). At the University professors routinely require an exorbitant number of texts and materials. So many in fact that there must be some sort of grift involved.

    On several occasions, I was required to buy some rinky-dink 100 page manuscript that was written (or edited) by the instructor themself, for an insanely high amount of money ($40+ for a cheesy velobound stack of photocopies). This is part of the cost of your education.

    3) Are universities being co-opted to provide MS based programming tools instead of other alternatives? Eg.Linux/Gcc/as/Qt/Gnome?

    Some of the classes I took had over a hundred people in them. Would you want to be the person who the students would call everytime they couldn't find a file on their Linux machine? Would you want to be the person who they'd call when Enlightenment crashes? The fact is, as much as I like Linux, it's a difficult operating system. The mind-numbing usability hasn't been programmed into it yet.

    This whole issue is really a non-issue, though. Anyone who can learn the skills needed to design and implement a program in Visual Basic can learn to apply those same design principles to C++ or Java or anything. The classes we are talking about aren't classes to teach student how to use a programming environment, they're basic skill classes. Once the ideas are learned, the students will have to take grammars classes to learn other languages (which is much easier to do once you have full command of one).

    BTW I took CS 161/162/163 (Intro to programming, data structures and algorithms) at Portland State University, and we did it all with cc. The instructor insisted that our programs compiled without error in cc, and warned us of the differences between cc and gcc.
  • Btw, java code on Windows == Java code on Linux == Java code on Solaris ==

    In theory this is true. In practice there are many quirks in the various virtual machines that make this a tad more problematic than Sun's marketing people will have you believe.

    I prefer java, but I wish to hell they'd open the standard up.
  • The real purpose is to teach you something about how a computer works -- from both a formal math point of view and a practical point of view. Hence, the reason that most people have to take a courses on computation theory, language theory, compilers, operating systems, etc.

    True, but would you rather have to take a specific class to learn how IDEs work, or would you rather learn as a beneficial side effect of a low level course? Personally, I'd rather not have to take a separate course to learn.
  • Um...hate to burst your bubble, but there are jobs out there for people who (gasp) don't program using Windows.

    Who said anything about windows?

    If there was an effective IDE for Solaris and AIX, you bet your ass that the fairly large company you work for would require you to use it, because it WOULD enhance your productivity. Time is money, and IDEs save time.
  • If you have an alternative policy that is even slightly practical for a class with 800-odd students, I'd sure like to hear it!

    Well, here's what I did when I had to write test drivers for an 150-person class: In addition to automated tests for the TA's, I also wrote
    sanity tests that the students could run themselves. In other words, when you thought you had finished problem set 5, you typed:

    verify ps5
    . This would remove any object files, try to recompile, make sure that your code provided the right interfaces (it's amazing how many people forget to capitalize function names), and so on.

    Later on, your TA would do:

    test ps5 <username>
    . This would run the same sanity checks, and then perform the tests.

    After a few iterations, it actually started to work. Students realized that they could avoid pissing off their TA's by running a command line program.

    In any case, it's not going to hurt you to be exposed to a different programming environment. At worst, you'll know *why* Windows programming is as horrible as Slashdotters often regard it :)

    Agreed.

  • This is just like anything that you will encounter in the job world. A company wanting you to use a certian product. This is what they use, for some reason or another. So you use it. Don't like using it? Look for another job where they use what you want.

    Should you learn differnt enviroments? Yeah. But looking for a school is just like looking for a job. You should have checked to see what they used for their classes. My old college got into bed with Microsoft pretty nicely. Their whole CS program ended up being a glorified MCSE program. So I transfered. Maybe you could do the same.

    But my point being. Just use what they have and like it. You're in no real position to really change it. And they really don't care what one guy thinks. If you get enough student support or something to warrent a change then maybe. But here's the big thing alot of people don't understand. The world doesn't revolove around them.

    Too many open-source zealots go into places and as soon as they get there babble on to no end about it. And just expect everywhere they go to just to drop whatever they are using now, and use something open source. Yeah, this has being working really well, but this new kid says open source is the way to go, so let's drop what works and do it. It doesn't work that way.

    But oh well, this will just be marked flaimbait anyways. Don't even know why I posted it.
  • Are you a developer? Are you still in school? No offense, but you seem a bit naive. There are no jobs out there where you get to do all the things you want to do, with all the toys you want to play with. Even if you did manage to get a job coding on Linux with gcc/egcs, chances are you'd still spend huge amounts of time in design meetings, and arguing with your team about the new database schema proposal. That's the real world, learn to accept it.
  • When I was at University I had to walk 10 miles to class uphill both ways, chop wood and haul water before and after class.

    To add insult to injury, we had to write our programs on in Pascal on a CDC Cyber-series mainframe.

    To make matters worse, the Cyber accounts had accounting enabled on them. You only had so many connect hours and CPU time before your account didn't work at all. This wasn't actually a problem unless you were fairly retarded or got stoned and forgot you were logged in.

    Fortunately, the TAs only graded our printed source and the sample output. I wrote most of my programs in Turbo Pascal on an AT. Making it "work" for the TAs was just a matter of avoiding the TurboPascal stuff like strings and doing them the hard way with arrays of char.

    Anyway, don't complain, at least you're not solving text mazes with Pascal!
  • Teaching environment-dependant debugger tricks in a general programming class is a pretty dubious concept. While being able to assume that you have a consistant environment may make things easier for the instructor, it is often doing a disservice to the students, many of which will find that when they get to the real world they will end up working with more than a few different environments in the future. If you are more able to adapt to different environments and aware of pitfalls to avoid when writing code as far as portability goes, I think you are going to be better off in the long run.

    Think about it this way, if this is a general college course, you should probably be teaching programming language, concepts, algorithms and problem solving skills rather than teaching how to use a specific tool. It is hard enough to cram enough concepts, algorithms and problem solving skills into a semester without spending time messing with vendor-specific tricks. Teaching how to use a specific tool is probably the place of a vendor sponsored/affiliated training class of some sort, the kind that is 3-5 days and intended for people who already know the base language and generic programming techniques.

  • Unfortunately, at Drexel University [drexel.edu], they crammed CodeWarrior down our throats. In our first C++ class, if we didnt turn in CodeWarrior project files, we would lose 50 points (give or take, it's been a while). And the reason? "It makes it easier for the TA's." Give me a break. I had three programming classes, a physics class, calculus class, and history class that term. I didn't even have a machine that would RUN CodeWarrior for Windows, or Mac for that matter. I used pico/jed/vi and g++ on my dinky 486 linux box. And my code was cleaner, faster, and tighter than any other students' code. I eventually had to go to the professor and DEMAND he regrade my projects, because I was getting shafted out of my points just because I didn't use CW. Of course, he preferred solaris to windows, so that helped.

    The moral of the story? Sometimes, even begging wont get the TA's to let you use what you want. You may get stuck with the shitty tools.
  • Oh, I was using version 2. Had support for C, C++, and PASCAL. Maybe I just never got the hang of it...

    Eric
  • That's great, but in my similar experience, I was told that I would most likely fail the 'lab' section of the course if I didn't use CodeWarrior. I found out later that it was all a crock of shit. The only thing it did was make debugging a bit easier.

    Some of the exercises had us put break points into pre-written code to determine how the value of a variable would change. This was easier with the IDE, if you could ever get the hang of it, but I'd rather have just put in statements to print the value of the variable at the right time.

    I did all of my projects in vi/g++, and when they were done, made sure that they compiled in CW, because you automatically got a 50 point deduction if it didn't compile there.

    Oh, and I've never used it since! It doesn't understand Perl too well ;)

    Eric
  • I have to just throw in an agreement on what you've said about STL.

    Although it SHOULD be entirely portable, it isn't. I develop for CrystalSpace [linuxgames.com], and we can't use STL due to some of the ports not working at all with it. Kinda sucky having to reinvent the wheel, but unfortunately it has to be done.
  • IN the real world, unless you are programmng solo, or on OSS projects that are almost always unix based.. your company will *TELL* you what the build environment is, and what tools are available.

    Will they force you to use CodeWarrior as an editor? No.. but they will not grant you any slack if others can't just fire the code up in codewarrior and do their builds.

    And for the purposes of learning to code c++, what difference does it make anyway?
  • Your teach just said 'When you submit your chit, it must work on this version of Codewarrior here.'.

    He doesn't *care* how you develop it, he's saying that your *objective*, your *mission*, is to produce code that he can compile under codewarrior.

    How is this 'bad'? or 'narrow minded?'.

    When you get your programming job.. and they say 'we use IRIX servers, so your code better work on irix'.. what are you gonna do.. code it for Linux and then say 'but you're being narrow minded?'
  • Well, speaking as someone who's prefered language is java, I can say that java code compiled on linux will be exactly the same as Java code compiled on any other platform. There may be some irregularities from platform to platform depending on what you test on, and you may want to test on the target machine at least once to make sure you don't get any surprizes.

    If you just doing pure console mode stuff, you don't have to worry at all, I've had almost no issues writing C++ in windows and running them with gcc on the Linux and HP/UX boxies my school uses, when doing pure text based stuff. (There was one thing that gcc could do that VisualC++ couldn't, so porting in the other direction might have taken some work)

    Basicaly, the 'write once, run anywhere" Mantra is true, and there will be absolutly no diffrence in the bytecode produced in linux vs the stuff in windows.
  • The real moral of the story is that your prof was a jackass. You took some code, and made it to compile in another environment? Sounds like a non-trivial task to me, and certainly demonstrated knowledge of the material. Combine this with previous grades, and you certainly should have gotten an A in the class.
  • ...so I've got some suggestions. (for the freshman, not for the pseudo-intellectual questions that Cliff added)

    I don't know how your school runs the intro C++ classes, but I imagine that because of the large number of students and necessity for individual attention, the TA does quite a bit of the teaching and grading.

    The class dictates the use of the single development enviroment and platform because of the necessity of standardization when dealing with such a large group. It's like the regulations in the military - some things just have to be done a certain way in order to effectively manage a group of that size. Imagine how difficult it would be for *you*, if you had to grade 30 different projects, coming from 3 different plaftorms and 6 different development enviroments? Each platform has it's own quirks, and you've generally got to fundamentally think a little differently to put the code into the context of the OS. If the grader has to shift gears with every student's work, he can never get into the groove of grading. Not to mention, most of the time, the majority of TAs/Graders for these intro CS classes leave a little to be desired in the 'clue' department.

    It's CodeWarrior on Windows because a) it has to be Windows and b) CodeWarrior is cheaper than Visual Studio. CodeWarrior really sucks on Win32, and it creates a lot of headaches for even the computer-savvy. (we used CodeWarrior, too) Microsoft has started courting colleges in the past few years, offering deals to departments and students if they adopt Visual Studio as their default development enviroment - but that's really irrelevant to the point.

    So now, hopefully, you understand why they insist you use the same platform, and why they insist you use CodeWarrior. Now let's talk about exceptions.

    It all depends on who grades your work. If your TA does all the work for your section, go to him/her and ask. Most likely, since you've got a clue, he'll be pumped, know he really won't have to baby you through the semester, and will be perfectly happy to let you use g++. But remember, he might be one of those without a clue and deny you the opportunity. If that happens, well, heh, it's still early in the semester, switch sections. :-)

    J.J.
  • Arguably even if you weren't formally taught the concept of a source file in class, you should pick it up over 4 years of CS training. I wonder how many applicants would stumble.

    Sadly, I graduate with people who still had trouble with the concept. 8*(
  • 5. Ease of interface (why spend time trying to teach kids to use a command-line debugger, a command-line compiler, and vi or emacs--none of which _directly_ contributes to your ability to produce C++ code--when it's easier to spend a day showing people the "new file" and "compile" buttons)

    Because the rats will leave the ship without even knowing what a source file is. I completed my undergrad at the Armpit of North Carolina Universities. The had mandatory usage of some crappy M$ DOS IDE. It took forever for the system to come up on the schools network, so I'd just use DOS edit to modify the files. The TA was astounded when I opened one of the source files in a text editor!! He was completely baffled when I showed him that you could call the compiler from the command line and save 5minutes waiting for Windows and then the IDE to come up.

    IDE shouldn't be allowed until students know what they are doing with the IDE in the same way that gradeschoolers shouldn't be allowed to use calculators until they know how to add.

  • I don't see why this is a big deal...think of it as training for the real world, where you will not always have a chance to use what YOU want.

    Besides, you will a learn a lot this way...everyone at slashdot values cross-platform development right? And what better way to learn than by coding your project in code-warrior, and porting it to g++, or vice-versa?

    Instead of making this a religious issue, treat this as a real learning opportunity for yourself. You will become a much better programmer for it!
  • Here at ASU, we have a very simple answer to this problem. Write the code wherever you want. When you are done, upload it to the schools General server. Compile it there, and make sure it runs there.

    Then, use a program in the professor's user directory to submit your code. Now you're done. It standardizes to a particular complier when you are done, but you can use any "environment" to write and test your code.

  • Unless of course the language is elisp where the language *is* the ide :-)
  • If you actually knew the tool you'd know there's an option to fix that, it's not the default because so much pre-existing code breaks when you turn it on.

    Oh, like VC++'s own header files? Oh, and I have used the tool.

  • I'm going to be starting another school next year which I *know* has a unix focus (they make you install linux/unix from day one).

    What school would that be?

  • VC6 has a number of incompatabilities in the *core* *language*. For example, consider this:

    for(int i=0; i10; ++i) {;}

    for(int i=0; i10; ++i) {;}

    Perfectly legal in The Standard and any other compiler, but it breaks in MSVC because the i isn't part of the for loop scope.
  • Linux is not a difficult operating system at all. It is virtually impossible to use at all without being educated properly in how to use it.

    Yes, it's called reading the documentation, something Windows users have grown unaccustomed to. Windows may be easier to learn, but Linux/Unix is far less painful to use.

    Colleges don't exist to hold your hand and walk you through the easiest possible way of doing something. They exist to provide *knowledge* to students attending (and paying for) them. Are you paying to be taught the easiest, quickest, least reliable and most propreity way of doing something? That's what I'd expect from a public school.

  • I suspect that many who are unfamilar with the programs and terminology associated with various unixen such as vi, linux and g++ are not necessarily in it for the money; it just means you haven't been exposed to those terms yet. After all, we were all newbies once.

    As for the use of console-based editors such as vi and emacs, that's a matter of personal preference. While I'm ready to dive into emacs as needed, today's large class libraries and practicing reuse make it practical to use and IDE that features things like class explorers, and that "Intellisense" feature that tells you what the properties and methods of the object you're using are.

    I do agree with your take on the compiler -- as long as you're handing in ANSI C++ (and getting the assignment right, of course), it shouldn't matter which compiler you're using. However, for the beginner, I'd recommend C++Builder over MSVC or vi as the editing environment.

  • Well, here's what I did when I had to write test drivers for an 150-person class: In addition to automated tests for the TA's, I also wrote sanity tests that the students could run themselves. In other words, when you thought you had finished problem set 5, you typed:
    verify ps5

    This sounds very much like the DejaGnu [gnu.org]:

    DejaGnu is a framework for testing other programs. Its purpose is to provide a single front end for all tests. Beyond this, DejaGnu offers...

    It's manual can be found at this link. [gnu.org] It's interesting that this came up in this thread, though it'll probably be largely ignored considering how deep it is in the thread and how many people have replied to this topic. I've been contemplating trying to get the crew at work to write their code with a number of tools that they're not using right now, such as DejaGnu, Nana [gnu.org] (a nice library for assertion checking and logging), Autoconf [gnu.org] and Automake [gnu.org], and perhaps even Autogen [freeservers.com]. I think it would give a good, standardized base from which to work, and force some of these half-assed coworkers to live up to the name "hacker"! Alas, the troubles of trying to convince coworkers of a "better way" is not the topic of this thread, but I thought the mention of the tools would relate well.

    ...make sure that your code provided the right interfaces (it's amazing how many people forget to capitalize function names), and so on...

    *cringe* It sounds like you've enforced some coding style standards upon your students that are not "C-compliant". Yet another topic for discussion, "What stylistic standard is 'right' for C programs? C++ programs?" We've all got our preferences, and were I a student of yours, I'd cringe every time I wrote a capatalized function. *double-cringe*

  • Not at all. They are teaching you the concept of debugging a running program. They cannot teach you to use every damned debugger on the planet. Once you've learned the concept of break points and such, it's easy to figure out how this works with other environments. As for people working in multiple environments, over time, yes, you'll be exposed to multiple environments, but you generally will not be working with three different IDEs on windows at the same time.

    They are teaching you those things. However, they have to do it with a specific tool. There's no way a university can teach dozens of students to use every compiler environment on the planet -- nor do they have the budget to go buy every one of those compilers. In the real world, you have to learn to adapt to the compiler you're forced to use -- and with C++, this is a big issue as they all do things differently.

    In order to learn to program, you have to compile your code. The instant you compile your code, you've locked yourself into dealing with that compiler. Trust me on this; I know far too well how non-portable C++ code and compilers are. (Several problems with the DCTI clients were attributed to various C++ compilers -- a few years ago. I've spent several months converting C++ code designed for Sun Workshop 4 to work with MSVC++ -- no template repositories and draconian type casting rules... The Cosm code base is 110% C to avoid all the C++ compiler bullshit.)
  • > > Your account may be revoked and disciplinary action
    > > may be taken if you are running an unsupported OS.

    God damned police everywhere. The most insignificant details of one's personal actions constantly monitored like the gold vaults at Fort Knox. Do the school regulations specify which hand you're to use to hold your dick when you take a piss? For all the hot air about "freedom" being a uniquely Amerikan ideal, a panoptic police state fits the TV-watching morons (cf. "Survivor," "Big Brother," "Cops," etc.) who infest this country like a tailored glove.

    Just wondering, unless he tells them, how the Hell would those bought-off idiots running "ResNet" at your son's university know that he's running Linux on his computer in his dorm room instead of their beloved Windows?

    Yours WDK - WKiernan@concentric.net

  • ) You will always have employers asking you to develop using 'Y' platform (X is an overused buzzword). Even though we all know that practically any development environment can be coerced into making any program, you have to do it the way they want it, or you will quickly be looking for another job.

    You say this as if it was a bad thing. However, in today's hot CS job market, finding a new job is no longer the choire it used to be. I say: go for it. With a little bit of luck and planning, you'll be able to use your favorite environment at your new employer's. You might even get better pay.

  • A school worth its salt should not forget to teach the useful skill of writing portable programs.

    At the introductory level? Mind you, teaching non-conformant C++ at the introductory level is as bad of a crime as not teaching them C++, but portability, IMO, shouldn't be the objective of a 100-level class.

    Mind you, my views are clouded because it seemed that almost all the departments in my school held their introductory-level courses as a "service" to the other departments. If you really wanted to learn, you continued on to the 200 and 400 level courses (for some reason, the faculty at my uni were too snobby to have 300-level courses). Portability was a requirement when I took the higher-level classes (such as network programming), but at the lower-level, they just told us what environments were available to the TA's (which included AIX, SunOS4, Solaris 2.5, IRIX, and Linux), and told us to develop for those environments.

    Mind you, I ended up developing in multitude of environments, and I credit that with my current success in my career.


    --
  • First, an answer to the "Cliff" comment...

    Reading through the comments, it's fairly easy to separate those people who have been TA's from those that have only been students. To say that requiring a single development environment is the result of a professor's ignorance or the desire to make a student's life hard is ridiculous. It's not about you. It never was about you. You don't particularly matter that much.

    I don't know that Code Warrior is the best learning environment, but reasons to standardize on something, and typically something GUI include...
    1. Grading ease

    2. Availability of the program on campus

    3. Cost of the program

    4. Ability of most students to run the program on a home computer

    5. Ease of interface (why spend time trying to teach kids to use a command-line debugger, a command-line compiler, and vi or emacs--none of which _directly_ contributes to your ability to produce C++ code--when it's easier to spend a day showing people the "new file" and "compile" buttons)

    6. Ease of support (if you leave the option of the environment open, it's likely that someone will use a system that you are unfamiliar with, be it gcc&emacs, Visual Studio, Watcom, etc. To help the most students, you'll need to be able to do it quickly, which is not possible if you have to learn the environment, or several environments, first)

    Now, to answer "Sadistic Yoda," you should develop in whatever environment you like, but make sure to save at least a day to compile and run your software on the recommended system. You may learn more about the language this way, as different compilers will support different options, and you may be able to detect more bugs, since different debuggers might find different errors.

    At any rate, it shouldn't take that long to test w/ Code Warrior as long as you know and use the intersection of C++ that it and gcc support.

    "People can't go around doing things just because their right." -- Officer O'Clancey "Toxic Avenger"
  • I find that in a lot of my classes the "higher learning" aspect of the course gets bogged down and diminished because of the (lack of) techincal capabilities of students. They don't know how to use their compilers or unix (we have Solaris in the labs as well as Linux).

    Thus, professors usually have no time for people who are asking for help (or having problems with) technical things that are outside the scope of the class, and outside of the materials said to be supported at the start of the course.

    However, if you take the time to make an appointment and go talk to your professor -not after class, not during drop-in times that are supposed to be for people who are having trouble with the actual contents of the course- you'll probably find that your professor is very accomodating and helpful. They're there to help you learn the material, not kick your grade down a couple notches because you have a compiler or OS preference.

  • This won't really work because Codewarrior for Linux is just the IDE, it's not the Codewarrior compiler, headers or libraries - it uses the gcc and GNU headers and libraries that come stock on a Unix system. The IDE just launces gcc as a subprocess (this is also how the BeIDE, originally CodeWarrior for BeOS, works to compile Pentium code on the BeOS with gcc).

    Thus you'll still have to deal with compiler dependencies. In components like the STL and the names of header files, there are considerable differences between gcc/Linux and Codewarrior for Windows.

    I know this to be true because I wrote a magazine article (finished, but as yet unpublished) on cross-platform development. I advised the reader to test their code out for cross-platform correctness by building under two compilers for Linux - by using Codewarrior.

    Thanks be to the higher powers that I carefully checked all my facts before sending the article in to the magazine editors.

    It might be useful to some extent to do this, though to help in getting the code to build. I'm not sure if the Linux version supports it, but on Mac and Windows you can export your project as an XML file, and import it again. This makes for a nice way to handle the binary IDE project in CVS and such (the XML is text, not binary).

    What you may be able to do is create a project on Linux, get your code working, send the project and source over to Windows and get it working there too.

    This will only work well if you can create a Windows target under Codewarrior for Linux; I don't think it's very easy to add a target for a different platform to an existing project, something I'd really like to be able to do (for example, to copy a Mac-only project over to a Windows machine, then add a Windows target to it).

  • When I was a teaching assistant for Computational Physics [caltech.edu] at CalTech [caltech.edu] (an introductory numerical analysis course), we allowed the students a choice of languages - C, Fortran, Basic and Pascal.

    They were expected to have the programs run on the lab computers where the class was taught (IBM PC/XT's - this was in the early 80's) but if the student wanted to run their code on a Vax and transfer it over somehow we weren't stopping them.

    This worked in part because what we were teaching was the algorithms - first and second order approximations, the Runge-Kutta method and so on. The student was expected to know and demonstrate the algorithm, not a particular language.

    BTW, the class was not a programming course, but the students were not expected to know how to program when they started the class. There were texts on programming languages made available, and they were just expected to pick up the language as they went along. Learning a language in this course was a required skill but not the objective taught in the class, much like learning how to use the editors on the lab machines.

    BTW - looking at the web page now it looks like the class has advanced considerably since I taught it (they use Maple and Mathematica) but it looks like you don't get a choice of programming language anymore.

  • You know, I usually do try to write good posts on Slashdot (with occassional blatantly off-topic posts when I've got some political point to make - but I post under my own name and not anonymously), and my Karma has been good lately, but what really makes me feel good is when someone actually goes to the effort to say "moderate this up" in response to one of my posts, and then a moderator does.

    One thing I try hard to do is put good hyperlinks in my posts. Sometimes I have to hit the search engines to compose a post, so it will sometimes take me quite a while to write one up. If I mention a book I usually link to it on fatbrain [fatbrain.com] or amazon [amazon.com] or something or at least give the ISBN.

    (This, BTW, is how you can get good karma. You don't have to just parrot the party line as the trolls like to say. Actually be informative or insightful, and if you provide hyperlinks then you multiply the value of your post because you take the reader on a tour of the Internet quite outside the slashdot discussion itself. And because these discussions are archived, all these hyperlinks and comments are of immense value for people doing research at a later date.)

    BTW - If you think you'll be done with your education when you're done with college, or maybe after a year or two of on-the-job training, guess again! I set into my program of going back to the basics after thirteen years of professional work experience as a programmer. My first full-time programming job was in 1987.

    I feel like I'm only beginning to get a grasp of "how to really program." But then I remember I've felt that way several times in the past. What's really going on though is that one enters plateaus in ability, coasts for a while, becomes dissatisfied, enters the "larval phase" again, and eventually reaches a new plateau.

    Or maybe not. Many people get proficient enough that they make a living they're comfortable with, and then they stop learning, or at best learn only the minimum needed to keep up with the job market. I pray I will never become one of those people.

  • I have archived comment 125 [slashdot.org] on GoingWare Inc.'s Bag of Programming Tips [goingware.com] as Study Fundamentals, Not APIs, Tools or OSes [goingware.com].

    If you feel that the page is useful (and I hope it is), please pass the URL to your friends and colleagues and link to it from your own pages.

    Other tips on the slowly-growing site are MacsBug Tips and Tricks [goingware.com] and Market Yourself - Tips for High-Tech Consultants [goingware.com].

  • I should say, it is worthwhile to learn how to use some tool and platform well, particularly when you're starting out. Being good with your tools will make you more productive.

    But what I meant in my post was that you shouldn't get bought into a particular platform to the exclusion of others, and invest all your time in learning the intricacies of some API or toolset that's likely to be obsolete in a few years.

    It has the added disadvantage that when you've invested so much in getting good at an API, you're hesitant to move to a new one. (I helped a friend of mine who was out of work for a year get his first QA job. He'd often said he wanted to do programming, but after getting good at QA, when I urged him to continue into software engineering, he protested that he was "trained in quality assurance", and thereby permanently prevented his own advancement by trying to wring new value out of old skills.)

    But fundamental programming skills you can take with you, and they make it easier to pick up any new API. And knowing more than one tool and more than one language gives you greater insight and makes you better at whatever language and tool you are using at a given moment.

  • The school should not only allow you to use a different environment - it should require it.

    They should offer a choice of several development environments (on a Pentium box, you could use Codewarrior, Microsoft Visual C++, Borland, gcc under Windows with Cygwin or under Linux or BSD, or Solaris with the Sun C++ compiler).

    The best thing would be to have machines that have multiple operating systems installed mounting your home directory off a server so you can reboot and try a different compiler.

    Not only is it educational to compile under different environments, it helps to keep you from using compiler-specific features that lock your code into a specific platform (you use the pedantic option on gcc and don't use the gcc extensions, do you), but also building your code under multiple compilers will find bugs in syntactically incorrect code that won't compile in one compiler but will compile and run and do who-knows-what under another.

    (This is one of the reasons Be, Inc. [be.com] still supports the BeOS [be.com] under PowerPC even though Pentium has an overwhelmingly larger customer base - it helps them to validate their code and keeps their code portable. They found lots of bugs when they moved from Codewarrior to gcc on their Pentium version, and so did I in my BeOS products.)

    For example, I recently found that using auto_ptr< char > on a character array seems to work just fine under Codewarrior for Windows [metrowerks.com].

    (I use it because I like the IDE's UI and it's great for cross-platform development - it also works with any text file format (MacOS CR, Unix LF, or or DOS CRLF) so you can easily share source files between any kind of machine, unlike gcc which only accepts Unix newlines).

    It is not correct to use auto_ptr on an array because it deletes the pointer it holds with delete, rather than delete [] which is the required operator to delete arrays (this is needed so you can call the destructor separately on each element of the array; it doesn't hurt to fail to call char's destructor because it doesn't have one, but the memory allocation format for an array in C++ is different than in C because the number of elements has to be stored somewhere).

    It is no real fault of Codewarrior that it works but I wouldn't expect my code to work if I moved it to a different platform - or worse, got into the habit of managing array pointers this way and maybe wrote a big library full of auto_ptr's of arrays. It would be perfectly within reason for a different development environment to cause my code to crash if I did this.

    Take my word for it, I am a professional cross-platform developer [goingware.com] with with extensive experience shipping on a variety of platforms [goingware.com] including my current project which builds from the same C++ source base for MacOS and Windows.

    (My friend Andy Green wrote the cross-platform application framework I'm using, which will be released under the BSD license soon. It also works under BeOS and XWindows/Posix, including Linux).

    If you or your TA's wish to discuss this directly with me feel free to email me at crawford@goingware.com [mailto]

  • Dunno if I really agree with this. The main reason I've found for using a debugger is to find out where an app core dumped & look at the variables at that point (plus try and trap illegal memory accesses & unexpected exceptions).

    For everything else, printfs (or stream constructs) do me just fine, and allow me to format the data flow @ that point in the code in such a way to make it more easily parseable in the output.

    Most of the code I've run into that I REALLY needed a debugger to figure out how it was working, was because the code was not very good quality and I needed the debugger to help me figure out how the data was flowing through it. Once I rewrote it to be simpler to maintain, I didn't need to use the debugger to maintain it anymore.
  • I really don't see what all the fuss is about. I work on a C++ commercial library and I compile the same code on g++, Visual C++ and C++ Builder. As long as you keep the implementation specific code in different files, your program is just a few #ifdef's away from being portable.
  • Is this limited form of teaching really teaching?

    Accusing the TA of "not really teaching" is quite a bit unfair. Asking the TA to be able to replicate any student's programming environment in order to grade code is ridiculous.

    Joey has GCC 1.0 on BeOS? gotta get that installer. Susy has egcs on Solaris? gotta get THAT installer. How about Bobby who has Visual Studio 4.56 running on windows 3.1? Better sharpen up those quintuple boot skills. Or figure out how to use use VMware in a hurry. Either way, give the TA an extra semester or two to finish grading.

    According to this question the textbook comes with a compiler. This means that lots of the sample code, excercises, and information in the class is geared to work on that particular compiler. Answering questions on why "Foo didn't work for me during the homework assignment" is a waste of class time.

    Would this question have been framed so negatively if the class required GCC/Linux?

  • ...just that your source had to be able to compile on it. That's an important distinction.

    When I took c++ the instructor told us we could use any compiler we wanted to. The school only offered M$VC++ and Borland C++ on the lab machines, but we were welcome to use whatever we could get our hands on. Of course, he didn't have a TA and he didn't grade us by running our program. We had to hand in hardcopies of our source. He also had a godlike knowledge of c/c++ and had seemingly memorized the standard libraries included with many and various compilers (as in "Yes that will work, but only under M$VC++. To run it in Borland you'll have to change MFoo() to Bfoo(), or you could use SFoo1() with SFoo2() and it will compile under both of those and under Unix as well.").

    I wouldn't execpt that level of knopwledge from most instructors (although maybe we should...) and I especially wouldn't expect it from a TA. Just write it in whatever environment you want, save it as a standard text file, and make sure it will compile under whatever they want you to use. Porting is a valuable skill that you will need when you get into the "real world" anyway.

  • I use three different versions of GCC (for Linux [gnu.org], DOS [delorie.com], and even Windows [mingw.org], and they all accepted the DOS-style CR+LF newlines in my game [8m.com]'s source code. Could that be because CR+LF is also the standard in many RFCs?
    <O
    ( \
    XGNOME vs. KDE: the game! [8m.com]
  • In my CS I and II classes, programming in C and C++ respectively, we were supposed to be using Borland's C++Builder. I approached my TA, and asked if we were going to be using ANSI C and C++, nothing more, nothing less. I also asked if I could just use gcc/g++ on my own machine. He said we were, and also said that I could use gcc/g++, but that they wouldn't be able to help me necessarily with any problems I would be having getting it to compile. This was for 350-person classes. I knew other people who were also using gcc/g++ on their own and the school's Sun boxes.

    But then again, we also were handing in our assignments on paper, which is worse to me (9 assignments in the semester, each and average of 9 pages- a good 24000 pages of homework over the semester, wasted). I had a little email war with the professor over it (he said electronic submission doesn't work- it worked for my highschool in non-computer related classes!), but was stuck with it. The TAs weren't recompiling out programs, but checking places for a correct algorithm and other specs of the assignment. Frankly, I don't know why this made it onto Slashdot- I would guess that for most simple C/C++ assignments (and some not so simple, provided they're using stdin/out), code that compiled on gcc/g++ probably does CodeWarrior too.

    I also had to pay for the computer access fee for the course, which is used towards the development machines and software for the class- which I didn't use all year.

    What also bugs me is that this coming year we have to use C++. Hell, I even offered to write Motif wrappers for GNU Smalltalk or Squeak so I didn't have to work with such a primitive language. Not surprisingly, the prof wasn't down with that.

    Moral of the story? Try to work something out with the TA, deal with using CodeWarrior, or transfer schools. Probably in that order.
  • You have to appreciate their p.o.v though, they're going to have hundreds of students handing in code of varying levels of legibility. Trust me, marking that is no easy task. Requiring it to work under a given platform goes a long way towards helping the TA's.
    At my school, for instance, they now use Java for first year programming. They provide an environment, and if you want to code in a different setup they give you the information. Java solves this problem a little, since it's fairly standard.
    And once you're halfway through second year, what language you code in is irrelevant. Sometimes they limit you to a collection of 3-4, (C, C++, Modula-3, etc) but by and large you can do what you want.
    Of course, every school won't have the resources (and TA's) to do that. But then again, if they did, maybe we'd have more competition in the ACM contest. ;) (Go Waterloo!)
  • Is this limited form of teaching really teaching?

    Yes. It teaches you that you can't always have things your way.

  • This may reflect more on the crummy cs program that I was in, but nobody in my classes liked programming with emacs/vi and g++.

    We were forced to use a buggy version of ddd, despite the fact that the version that the school used did not work on the public workstation!

    IDE's are a good thing for people who are new to an enviroment, especially students. I used an old version of Delphi to automate a couple of menial tasks for our operators, and had a working program written in about 5 hours. If i was using a new language to develop something with just a text editor, I would not have had the time to develop the gui or add extra functionality.

    In my view, if it saves my time (and works), it is good. IDE's are good. I could care less about ideology.

  • Codewarrior is actually a pretty awesome development system. It can do things more elegantly than G++ (project coordination comes to mind). These things can be done in G++ but with significant effort. I say bite the bullet and get Codewarrior. You will have other teachers that use G++, and some that use totally other systems. Stick your tongue in your cheek and forget about it.
  • One of the biggest problems I had at entry level comp-sci was that in anticipation of not having to teach the hard stuff, a lot of the code was in pre-written libraries provided by the university.

    I guess with C/C++ if the libraries were written well, they might be able to be cross-compiled. When I was doing it in 1997 we had to learn structured programming on macs running a version Think Pascal that had an irritating habit of locking up whenever you hit the wrong enter key.

    A lot of the library was for things like opening up graphical windows, reading mouse positions/button clicks etc. We were writing very simple painting programs, and so on. So the actual coding we needed to do was very simple stuff, but at the same time we were able to make interesting things with it because the hard stuff was already done.

    I ended up re-writing much of the library so I could do my coding at home in DOS on a PC. (I was using Borland Turbo Pascal at the time.) I just gave up when it came to the graphical routines and I did those assignments at the university.

    Four years later I am a TA, and the first years are coding in java which makes things a lot easier. (Also they threw out the macs and they're all P3's running BSD, now.) As a marker it makes it a million times easier to work out people's code, too, because everyone's code looks relatively similar and I don't have to re-learn a structure every time.

    Bulk first year marking usually means taking marks off for mistakes -- not rewarding marks for good ideas. There are exceptions, but typically (from me), high marks go to the assignments that are easiest to read, and that I don't spend more than a few minutes looking at. Specifically because I don't have to.

    If the code isn't strightforward to read though, being able to simply go away and run it is really useful.


    ===
  • I have learnt Turbo C++. Now teach me how to do it in VC++.
    That sort of questions bombarded our teachers when they taught our class C/C++ last semester (note - only DOS apps...no windows ones).
    They first gave the class Visual C++ installed on computers, and taught them how to "create a new project", etc. etc. Then they happened to install Turbo C++. Students didn't use it - We have learnt Visual C++, not Turbo C++. Then some students attempted Turbo C++ - and were suprized to find it was similar to Visual C++. "They have copied it from Microsoft...", I heard. Then some students became proficient in using the Turbo environment and forgot about Visual one. Now - "I have learnt Turbo C++. But forgot Visual C++."

    Then people ask me - I typed:
    10 PRINT "HELLO"
    20 END

    in BBC BASIC a long long time back, will it work in GWBASIC ??

    I take a sigh, and tell them "YES, it will" as the last explaination of the fact that they have to deal with language, not environment or compilers.

  • I've used codewarrior on my mac to build up code to run on Solaris. For the vast majority of cases it has been instant compile. In the cases where g++ didn't play the same as Codewarrior, it was g++ being a whore. Quite frankly, if you're taking an intro course, you should be open to new and innovative ways of doing things. The compiler package that metworwerks has put together is IMHO first rate, far more informative for debugging code, nicer to assemble stuff in, and completely compliant and up to date. Furthermore, I can do Codewarrior on Mac, Windows, I bought a copy that runs on Solaris and prefer that environment to emacs for most stuff ... it's a sweet package. I'd recommend bringing up that you currently compile stuff on an alternate platform, and ask if it'll be an issue, it's a good introduction to where C becomes platform specific. Then use both environments for a while to understand what they each have to offer. The time to be obstinate is not when you are a freshman. Take that from a fifth year senior. (double major, not just slow)
  • I hate to say it..but you're right.

    Turning it political was stupid. Asking the techincial question of the differences between CodeWarrior and g++ isn't.

    Worse case scenerio...write it in g++ and then bring it over to code warrior and clean any environmental issues in code warrior before turning it in.

    No offense folks..but when I went to college (all of what, 7 years ago?) they were still using mainframes for some of the courses.

    Presenting the college with a new way of doing things is good. Demanding you be allowed to do it your way is bad. Look at it this way...you can show them the better product..you can't fix their intelligence...if they want to be stupid they're going to be.

  • 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

  • by Bitscape ( 7378 ) on Saturday August 26, 2000 @05:38AM (#826490) Homepage

    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. ;)


  • by Mike Buddha ( 10734 ) on Friday August 25, 2000 @11:54PM (#826491)
    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.
  • by r ( 13067 ) on Saturday August 26, 2000 @04:00AM (#826492)
    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. :)
  • 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.
  • by Maurice ( 114520 ) on Saturday August 26, 2000 @05:50AM (#826494)
    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.
  • by MaestroSartori ( 146297 ) on Friday August 25, 2000 @11:29PM (#826495) Homepage
    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++).
  • by Snocone ( 158524 ) on Saturday August 26, 2000 @06:28AM (#826496) Homepage
    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!)
  • by mu_cow ( 168630 ) on Friday August 25, 2000 @11:43PM (#826497)

    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.

  • by Harik ( 4023 ) <Harik@chaos.ao.net> on Friday August 25, 2000 @11:34PM (#826498)
    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

  • by werdna ( 39029 ) on Saturday August 26, 2000 @01:45AM (#826499) Journal
    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.
  • by digitalbeing ( 84400 ) on Saturday August 26, 2000 @12:24AM (#826500) Homepage
    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!
  • by goingware ( 85213 ) on Saturday August 26, 2000 @02:39AM (#826501) Homepage
    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.

  • by Zordak ( 123132 ) on Saturday August 26, 2000 @08:18AM (#826502) Homepage Journal
    >>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
  • by lars ( 72 ) on Saturday August 26, 2000 @12:27AM (#826503)
    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), tough. Sometimes the software needed isn't available on Windows, so students who use Windows at home have no choice but to use the school's Unix facilities. And even if you're using Linux, your code is not guaranteed to compile on their system - differences between gcc versions, etc. may cause problems. If your code doesn't compile, tough - it fails the automated testing, and you lose a bunch of marks. Presumably if there's a problem the TA's are nice enough to try and fix code that doesn't work, and/or assign some marks, but I don't see what's wrong with expecting students to test their code on the school's systems before submitting it.

    This is no different than being forced to do assignment questions out of a $100 textbook, even if you really don't need the textbook to learn the course material. This happens ALL THE TIME. You most likely buy the textbook anyway, and use it, but you can also just find a copy in a library or borrow from a friend. Likewise, in this case, if you don't want to buy Windows, you can either find a public workstation (presumably your University has some), or find a friend who runs Windows and compile on their system. How hard is that?

    Ok, I'm on a bit of a roll here now. I'll probably get moderated down for this, but I don't even understand why Slashdot would post this question. Actually, the question is a good one; he merely is asking a technical question. It's Cliff's attempt to turn it the discussion into something political with his commentary that's stupid. Oh, poor Linux user! The horror of having to use Windows for 2 minutes to verify that the code compiles and runs on it (assuming they're not using features or libraries specific to CodeWarrior, which for an entry-level C++ course I would assume they're not)! I know we're Linux zealots, but why can't some people in this community just accept the fact that NOT EVERYONE USES LINUX, and there are going to be occasions when you're FORCED TO USE WINDOWS (or Macs, or...) For god's sake, stop WHINING and being offended and deal with it!
  • by Taco Cowboy ( 5327 ) on Saturday August 26, 2000 @12:29AM (#826504) Journal


    "When all you have is a hammer, everything
    else look like nails."

    The axiom above is true for many real life situation, including programming.

    If you are limited to only VB or G++ or vi or whatever, make the BEST of it.

    After all, you are in the class to LEARN something, might as well do you best LEARNING THE PROPER WAY TO DO THINGS RIGHT THE FIRST TIME.

    VB or vi or G++ or whatever are just tools. You do not have to be attached to ONE SPECIFIC TOOL. What is MOST important is the SKILL TO CREATE, and that skill should NEVER be limited to any specific tool. You can "graduate" from using M$ stuffs, but as long as you have that skill to create newer and better things, you can always migrate to OTHER KINDS of tools available.

    Hope all of you can glean the skill to create despite the obstacles the power-that-be want to throw at you.

  • When I was a TA, many CS projects in the subjects I taught had the testing automated (Perl is a marvellous thing . . .). Testing was performed on a Solaris machine using gcc, and it was the student's responsibility to write code that worked correctly in this environment.

    Of course, many students wrote their code in (insert favourite moronic Windows IDE here), and just copied the code directly across to the Solaris box, and submitted without even checking to make sure that the program compiled. Many times, the program failed to work, and the students were marked down regardless of their protests of "but it worked at home". How are we supposed to know whether it worked at home or not? In any case, a little bit of investigation usually showed that the program had a combination of bugs that gcc/glibc/Solaris trigged but DroolIDE's compiler environment didn't.

    If you have an alternative policy that is even slightly practical for a class with 800-odd students, I'd sure like to hear it!

    In any case, it's not going to hurt you to be exposed to a different programming environment. At worst, you'll know *why* Windows programming is as horrible as Slashdotters often regard it :)

  • by earlytime ( 15364 ) on Friday August 25, 2000 @11:53PM (#826506) Homepage
    I can speak from experience on this one. I took an intro to c++ class a few years ago, and they were using borland c++. Rather than pay $90 at the bookstore, and install windows on my machine, I just used gcc.
    Everything worked flawlessly until the final. I had a 98 average in the class, but the final exam was to take a program and modify it. Well wouldn't ya know it, the stoopid program wouldn't compile under gcc, cuz of a few function calls depended on a library that was different in gcc than it was on borland.
    So being the procrastinator that i am, i found this out the night before the final was due, and by 8 the next morning i had the program compiling/running with gcc. It was due at 10. So I had to hand my port to gcc, but of course i got squat on the final, and my final grade ended up being a b. sucks huh??
    the moral of the story is, yes there are valid reasons for a class to require a consistent work environment. This is a prime example, If i'd used the borland thing, i wouldn't have had that problem, but i'd be out 90 bucks and i'd have to have used windows. I'll take the B. ;-)

  • by xavii ( 92017 ) on Friday August 25, 2000 @11:24PM (#826507)
    i was in almost the same exact class. the teacher explained that everyone should use Visual Studio 6, because that is what is provided by the school.

    All i had to do was raise my hand and ask if i could use vi and g++ on my personal linux box and he was almost overcome with joy, i actually had previous knowledge.

    After i asked, the teacher had to explain what vi, g++ and linux was to the class. Seems a lot more people are coming into computers for money and not the love of the game.

    just ask if you can, usually they are flexible for students who actually have some original thinking in their skulls. Also, on the plus side, they will probably remember you and possibly favor you for taking a unique approach to the first problem of the class.

    xavii aka bob
  • by nullity ( 115966 ) on Friday August 25, 2000 @11:29PM (#826508) Homepage
    Its not about tech support. If that's all the problem was schools wouldn't care too much. The problem is really cross-platform/compiler compatibility. As sad as it may be...something written for g++ *might not* work on Code Warrior for Windows, or Visual C++. This is less of a problem with C compilers, but still an issue. Your TA needs to be able to compile whatever it is you wrote, and so they pick one platform they will use.

    For example, at my school they recommend a particular compiler, and ask everyone to use it (under the Macintosh, since that's what dorm clusters have)...for lower level C/C++ classes. At higher levels they reccomend gcc/g++. But the issue is that you really should be running the same compiler that your TA/TF is, or the results will be somewhat unpredictable. You could probably get by, but its always a major risk. And if it doesn't work on their machine, you can't just say "well it worked on mine" because you were using an officially non-kosher compiler to test.

    In contrast, Java classes (where most compilers are relatively conformant) encourage the use of whatever compiler you want. They say it might be wise to test on the "target" compiler (JDK 1.2/3 on Solaris), but that its not necessarily "required".

    My advice is develop at home - just make DARN SURE you test it thorougly on the foreign compiler and fix all compiler errors before submitting. (and you probably will have some)
  • by wmoyes ( 215662 ) on Friday August 25, 2000 @11:32PM (#826509)
    I have 24 credits left until I graduate, and I have been dealing with this through my entire collage carrier. The best option is to just deal with it.

    1) You need to learn how to LEARN TO USE new tools. If you think what you have is bad, I took a course that required all programs to be written using MFC and Visual C++. Now that was a nightmare (spend 80% of the time trying to find what you need in the docs, 10% actually writing code, and 10% debugging). What made the class even more fun it was my Operating Systems class where we did some basic networking, threading, and deadlock avoidance.

    2) You will always have employers asking you to develop using 'Y' platform (X is an overused buzzword). Even though we all know that practically any development environment can be coerced into making any program, you have to do it the way they want it, or you will quickly be looking for another job.

    I don't mean to be a pessimist, but for your own sake, avoid starting any type of confrontation. By the way did you ask the professor on the first day of class? In my classes we usually get about 3-4 question on this very topic the first day.

UNIX is hot. It's more than hot. It's steaming. It's quicksilver lightning with a laserbeam kicker. -- Michael Jay Tucker

Working...