Brian Keller

Director of ALM Evangelism for Microsoft

Students choose Visual J# over BlueJ, JCreator, and other IDE's

Students choose Visual J# over BlueJ, JCreator, and other IDE's

  • Comments 14

I received this note from Brian Scarbeau, a high school AP Computer Science teacher in Orlando, Florida.

Thought I’d pass this along. . . My AP students are now using the MBCS hands on.  I don’t require them to use an IDE and they choose either bluej, JCreator or VS. Some started to use Visual Studio for the first time today and they were blown away by the intellisense and how easy it was to use. Needless to say that got the attention of the other students that were using the other ide’s. Guess what IDE all my students will be using tomorrow in class?

At Microsoft we spend lots of time, money, and energy educating the academic community about the merits of our tools and platform, but we obviously can't talk to every student or teacher out there. So when students independently choose Visual Studio over other IDE's - without any influence from their teacher - it reminds that we're building a development tool that makes life easier for millions of people - students and professional developers alike.

One of the main reasons I came to Microsoft to do marketing in the Visual Studio group is because of my academic experience. I graduated from the University of Florida (Go Gators!) the same semester that Microsoft released Visual Studio .NET. I remember reading about the product and trying it for the first time and being so amazed at the capabilities. The only unfortunate part about my experience was that the timing of my education didn't permit me to use Visual Studio .NET as part of my college career since it wasn't released yet. So when I was given the opportunity to come work for Microsoft and help teachers and students realize how Visual Studio .NET could help them be successful in their college careers and beyond, I couldn't pass up the opportunity. I am living my dream job every day, and my only regret is that I don't have more hours in the day with which to code. =)

  • On the contrary, I think that having intellisense and a powerful IDE like VS is *BAD* for students just getting into the world of programming and CS.

    It robs them of all experience working with command line tools and utilities, which are often just as powerful (if not more so) than their GUI brethren and can often save time over using GUIs

    And it's a shame. They'll get so used to working in IDE's and using intellisense that once you take away their fancy IDE and intellisense, they're practically useless. Not only that, getting young programmers into the game with intellisense robs them of the appreciation for documentation.

    It's a shame that anyone teaching CS at an introductory level would actually use visual IDEs instead of starting students from the basics.
  • Hi Charles, thanks for your reply. I tend to agree with you that using IntelliSense (and other productivity aids) can hurt the learning process in the beginning. However, note that it's more than half way through the school year and they are just now picking up an IDE. I think the approach varies by teacher, but they do have the full range of options here - they can start with the command-line compilers (which ship with the .NET Framework SDK) and then work up to the IDE. This is part of the reason we are building the Visual Studio Express products - to help students transition from command-line to "Express" and ultimately higher end versions of Visual Studio, if that's their goal.
    Another thing you said - "once you take away their fancy IDE" - is odd to me. You're assuming they have to stop using the IDE at some point? If it's a productivity tool that helps them code, then they should continue to use it. Now of course, on the written tests they need to know their stuff. But once they get into their jobs or higher-ed why shouldn't they continue to use the tool they know, which helps them focus on coding concepts instead of having to memorize the 15th overloaded method for creating a circle?
    I am sure the hardcore assembler programmers said the same thing when english-like programming languages came out, but I don't see anybody saying we should all learn assembler nowadays.
  • Charles, I think that it is worth noting that these are students who are in Advanced Placement and have pretty good programming backgrounds. A key element in keeping students interested in programming and development is giving them opportunities to feel successful. Intellisense can help students feel successful and help them avoid some of the frustrations that can undermine the work that their teachers have done to get (and keep) them interested in programming.
  • This debate (command line v. IDE) comes up all the time in CS education. I learned using command line editors and compiliers (none of this modern graphic editors like EMACS, VI and IDEs back then). I've also taught using IDEs. I think that intellisense teaches a lot faster than reading the documentation. This is especially true as it is so difficult to get students to read documentation. There may be times when a command line compilier is better than an IDE. Other than doing batch builds of large applications like operating systems I'm not sure what they might be though. Generally only a few people know how to do large batch builds. When I was an operating system release engineer I think that only 3-4 of our group of 70+ know how the batch build worked. There is time for command line compilers later. You need to get students interested and not try to scare them away when they are first starting.
  • "Intellisense can help students feel successful"

    Feeling successful and being successful are two different things.

    "You're assuming they have to stop using the IDE at some point?"

    How about if it's an exam and they're asked to complete a section of code? What if it's a technical interview? What if you're in a situation where you don't have an IDE/GUI and you have to get something done (FTP comes to mind)? You would agree that a UI developer that knows the ins and outs of HTML, JavaScript, CSS, etc. is more desireable than one that is just really good at slicing up Photoshop files yes? If I ran a web company, I would *insist* on my web devs. being able to write DHTML from scratch using a text editor instead of an IDE...it's simple as that. I would expect the same from a developer. If I take away your IDE, can you still be productive?

    Yes, yes, powerfule IDE's are great for productivity, but it also restricts your knowledge in a sense. Creating a .msi package using WiX is 10x more insightful and intuitive than doing so with VS Setup Projects. Not only that, it can be easily automated into an NAnt build (look at that, another great command line utility).

    And, like I said, in an environment without an IDE, students can gain a better appreciattion for the importance of good documentation.

    I personally don't think students should be exposed to IDEs until their junior/senior years in college or in the private sector (internships). If you get them hooked onto one IDE early on, it can be devastating in the sense that it ties them into a platform/system (perhaps that's Microsoft's goal) because they will be dependent on that IDE to be productive.

    "Charles, I think that it is worth noting that these are students who are in Advanced Placement"

    All the more reason that they should be using text editors and command line rather than IDEs. ***You would expect kids in AP Calculus to be able to solve an integration problem without using their TI graphing calculators right? Similarly, I would expect an AP CS student to be able to write, compile, and run code without an IDE***

    Just my $.02 ;)
  • > I don’t require them to use an IDE
    > and they choose either bluej,
    > JCreator or VS.

    No Eclipse? The jUnit integration alone is worth it.
  • AP CS students do have to write tests without an IDE. And most AP CS classes are taught using IDEs. Students do learn well with IDEs and some of us have years worth of experience teaching AP CS and other programming classes to support the idea that it works.
    A graphing calculator is more or less required for the AP Calculus exam BTW.
  • All good points, Charles. I can definitely see your viewpoint. And like I stated earlier I think command-line builds have their place at the beginning of the semester for the first few weeks. I guess we should agree to disagree on some of your points, though. If I ran a Web development company (I actually did for a few years and it's been very successful, but I won't plug it here <g>) then I certainly don't expect all of my devs to know how to code DHTML or HTML from scratch when there are tools that abstract this away from me, for the same reason that if I was hiring C++ devs I wouldn't require them to know assembler (unless the job required in-line assembler, of course). Of course, maybe a few folks in my company should know how to hand-code in the event that the automated tools need tweaking, for example. But like Alfred said, I think that's the minority of people in the org instead of the majority. IMO, students can be far more successful in most roles using Visual Studio (or any IDE for that matter) than they can without the IDE. Maybe we need to sanction some kind of in-depth study?
  • "Maybe we need to sanction some kind of in-depth study?"

    Actually, that's a very interesting idea. I think that such a study would be valuable not only to the professors/teachers and students, but also to companies that produce visual IDE's like Microsoft.

    Don't get me wrong, for my day to day, I do my dirty deed with VS.Net 2003 and I love it and I look forward to 2k5 (tremendously) ;) but I think that if I had started out on VS IDE, I would have missed out on a lot of finer details of working with software.
  • Any thoughts on how we could best approach an in-depth study? I could lobby for funding on my side. I agree, I think it would be great to pull out the tape measure and see exactly which approach works best. Of course, some students may learn best with different methods, but if you had to pick one which way should you go? I have no idea how to go about researching this in a way which eliminates bias.
  • Okay, looking over Scott Bellware's slides for a presentation he gave on TDD at the Austin Software Process Improvement Network (http://geekswithblogs.net/sbellware/) finally made me realize whey I think VS is a bad way for students to get started in development.

    And the real culprit is the RAD (Rapid Application Development) aspects of the IDE. They oversimplify the complex task of produciing good software just as Dreamweaver oversimplifies the complex task of producing good markup.

    Some points from Scott's PPT:
    * Many RAD-dependent developers don't have experience or guidance on where RAD use is a detriment (i.e. Dropping data components on a UI designer)
    * Sacrifices project and product sustainability and maintainability
    * Rarely pays off except in very small projects (and I would personally add prototypes to that statement too).
    * We wanted non-programmers to produce software
    * The grand "users-can-program" experiment rarely, if ever, produced sustainable projects or products
    * Obsessive focus on developing and buying tools that do as much as possible in drag-and-drop designers
    * We don't believe we can ever truly succeed because we've even failed with the "best" tools in human history
    ** Created a massive population of developers who have few real skills
    * Created unreasonable expectations for the cost of software development
    ** We've pushed RAD too far (Visual Studio is *not* OptimalJ)
    * RAD depends on simple drag-and-drop tools
    * Lots of duplication due to locally generated code vs. shared code (especially true at the web forms level)
    * The product of these tools is rarely component-based and n-tier
    * Most (if not all) code in a single architectural layer (usually the UI)
    * Typically, the code isn't (reasonably) testable

    This is an "Aha!" moment for me. The point I've been trying to make all along is that graphical IDE's like VS which feature heavy drag/drop and emphasizes RAD are a dangerous way to introduce young, aspiring programmers and developers to the world of software development. I think it "contaminates" them to some degree and makes it seem like it's *easy* to make good software (it's not).

    I've known a lot of guys who were masters of VS. And yeah, they could get the job done and make the stuff work. But at the end of the day, their solutions were ugly, hacked together, and totally unscalable because they were dependent on the GUI to do the magic for them (and it really is magic, some people don't even realize what's really happening when they drag/drop).

    I think that we should point the kids along the right path and not the path that's gonna please the most mid-level managers. RAD should be the *last* thing in their education that they encounter so that they have a solid foundation to build from. Yes, they feel successful early on with RAD since they can get stuff working fast, *but* this comes at the price of being weakened once they start working on anything beyond a "toy" project. I don't think that 1-2 high school semesters without RAD/GUI IDEs like VS is enough; I think that to bring up the next generation of CS students and developers to higher standards, they have to be kept away from those tools for as long as possible so that when they are introduced to them, they will truly understand the code, truly understand the framework, truly understand why the magic happens.

    Whew! That's a lot of typing.

    Well, anyways, check out Scott's blog for more stuff. I guess I'm just more of a purist since I see how many developers are competent with VS and .Net, but at a very basic level. Once you take away the tools or once you get into a project where the tools aren't applicable, they stumble because they don't have the necessary background to be productive.
  • Another point that I would like to make is that I think that when teaching at such an early stage, it is a mistake to even get started with code. A total mistake.

    Yes, students would get bored otherwise, but it's still a mistake nonetheless. My suggestion is that they are not taught a particular language, as is the case here, but rather taught *several* languages, even if on an introductory level. The main goal of teaching CS students is not so they are productive (not this early in their education anyways), but they they can understand logic, so that they can solve problems, so that they can teach a machine to do their bidding. Often times, a general purpose language like Java or C# is easy to learn and easy to use, but it's entirely clumsy at doing some tasks that, for example, Prolog or Scheme excels at. Students should not be tied to a language at this level, ever. I feel that that type of experience should come from internships and outside of the academic arena.

    In addition, I think that the first few course of any CS curriculum should really focus on software engineering (testing, orthagonal, documentation, design, programming practices, teamwork, did I mention testing). I've found that these are always the *last* subjects to be covered (if at all)!

    If I were to compare CS to physics for example, the main course should cover the theory and the ideas. The actual programming and should be relegated to labs, just like experiments in any low level collegiate physics course.
  • PingBack from http://paidsurveyshub.info/story.php?title=brian-keller-technical-evangelist-for-team-system-students-choose

Page 1 of 1 (14 items)