通过

Does Visual Studio make you stupid?

  • 项目

I know everyone's talking about this, but it IS a good question...

Charles Petzold recently gave this speech to the NYC .NET users group.

I've got to say, having seen Daniel's experiences with Visual Basic, I can certainly see where Charles is coming from.  Due partly to the ease of use of VB, and (honestly) a lack of desire to dig deeper into the subject, Daniel's really quite ignorant of how these "computer" thingies work.  He can use them just fine, but he has no understanding of what's happening.

More importantly, he doesn't understand how to string functions/procedures together to build a coherent whole - if it can't be implemented with a button or image, it doesn't exist...

 

Anyway, what do you think?

Comments

  • Anonymous
    October 26, 2005
    The comment has been removed

  • Anonymous
    October 26, 2005
    I would argue that there's a certain evolution of knowledge in any field, and that in order to advance in overall complexity, that you must simplify/consolidate/hide the lower-level tasks. This lets you focus on innovation because less energy is spent simply making something work.

    Take photography, for example. 99+% of people don't have their own dark rooms, and have no idea how to develop film or make their own prints. Digital photography has even taken the film out of the picture (pun).

    Sure, there are some die-hards out there who still do everything end-to-end because they enjoy it. But, for the most part, people are happy snapping pictures on their Canon Powershot and emailing them off to Grandma. Are modern photographers worst at their art because they don't know how to do all of the low-level work that photographers of 50-100 years ago performed?

    I for one welcome the Intellisense-Code-Generating overlords. They allow me to put my ideas into code much more quickly than when I had to do everything from scratch.

  • Anonymous
    October 26, 2005
    The comment has been removed

  • Anonymous
    October 26, 2005
    Using Visual Studio 2005 makes me about as stupid as when I transitioned from programming in assembly to C. I got rusty on the various instructions, registers, etc. and started to get actual work done. I sure didn't feel very stupid at the time, now that I think about it.

    I don't buy the Petzold's argument at all. It's just a tradeoff between productivity and detailed control via abstraction. I don't know what is so hard to understand about that, since this has happened in this industry 'n' times already.

  • Anonymous
    October 26, 2005
    The comment has been removed

  • Anonymous
    October 26, 2005
    I thought it was decadent when I bought a macroassembler so I didn't have to look up opcodes in the 6510 reference manual. But, I've never again wasted an hour recalculating branch offsets to fit in an extra instruction.

  • Anonymous
    October 26, 2005
    While intellisense is an intelligence multiplier, “closed” code generation forces me to deal with black boxes all the time, which spoils my intellect. It is one of those things that should be available in source code, or maybe redesigned to be template based.

  • Anonymous
    October 26, 2005
    I'm of two minds on this. I think several of his points are valid. At the same time, I look at the tremendous productivity I have made as a developer. Things that would have taken months to develop now take weeks. Performance-wise and maintainablity-wise, I think things are better now.

    Of course, this doesn't mean that I blindly accept the fluff that VS.NET has to offer. Over time and with experience, you see where the fluff is just fluff and where you really need to dig deeper and do things differently. Especially if you are developing a software product, as opposed to a simple quick-and-dirty project.

    Very interesting none-the-less.

  • Anonymous
    October 26, 2005
    The comment has been removed

  • Anonymous
    October 26, 2005
    The comment has been removed

  • Anonymous
    October 26, 2005
    The comment has been removed

  • Anonymous
    October 26, 2005
    Well, by a similar token, then, doesn't using the BCL itself also promote laziness?

    I mean, developers can now decode UTF-8 documents without knowing how UTF-8 works at the byte level. Developers can Base64-encode a byte array without knowing how Base64 works. With a couple of lines of code, a developer can retrieve a file from a web server without knowing anything about the HTTP protocol, let alone how TCP/IP works.

    Get even lower than that. A lot of people out there do not know how to do math anymore (beyond arithmetic). And do they need to? Just pull out a computer, fire up Excel, and let it do the work for you. I'm sure that at one time, the academic world was up in arms about how computers make people lazy because they aren't able to use logarithms or whatever.

    But this is what innovation is all about--it's not just finding cool new ways to do things. But rather, it's about allowing me to forget all of my previous skills so that I can concentrate on developing new skills.

  • Anonymous
    October 27, 2005
    The comment has been removed

  • Anonymous
    October 27, 2005
    The comment has been removed

  • Anonymous
    October 27, 2005
    What I think is going on here is us folks that grew up having to understand the stack order in C vs. Pascal calls. So we see these new folks, quite happy not knowing the plumbing, and wonder if they can possibly do things bug-free enough. Our industry is maturing; I am sure there are engineers that wonder how one can do a bridge without drawing SOMETHING in pencil. My opinion is that 80% of the time they don't have to know the plumbing. And when they do, they will come to us an ask. We need them, and they need us. As in nature, a symbiotic relationship.

  • Anonymous
    October 27, 2005
    "Does Visual Studio Rot the Mind?"

    Have calculators rotted the mind?

    :-)

  • Anonymous
    October 27, 2005
    The comment has been removed

  • Anonymous
    October 27, 2005
    My father (a now-retired programmer) remembers a co-worker who would declare:

    Assembler programming promotes brain rot! Unless you're programming in the raw hex code, you can't really understand what the computer is doing!

    So yes, these sorts of concerns have been going on for ages, and in general they don't win.

  • Anonymous
    October 27, 2005
    I don't think Visual Studio makes you stupid, but it certainly tends to push you towards a particular style and organization for your programs. One where you build things bottom-up and, as Larry said, "if it can't be implemented with a button or image, it doesn't exist." There's not necessarily anything wrong with that style, but I think a lot of people use it because Visual Studio makes it continent, rather than because it's the best way to build whatever it is they're working on.

    There's an old saying, "If the only tool you have is a hammer, every problem starts to look like a nail."

  • Anonymous
    October 27, 2005
    I think Petzold's comments aren't as black and white as many of the commenters here seem to paint them. There are pros and cons to using Visual Studio's features, and I think he, like other mature programmers, are trying to find the highlights in a big gray landscape.

    Abstraction and detail-hiding are great things. They let us be productive by freeing us to think at a higher level. That's a powerful tool in dealing with complexity--assuming your abstractions don't leak. Detail-hiding is great for coding, but lousy for debugging (one of my chief complaints of STL).

    Intellisense will quickly remind me that a certain function returns a HANDLE, but it doesn't tell me if the function uses NULL or INVALID_HANDLE_VALUE to signal an error. I've been around long enough to know that I've got to check the reference materials on these. Other programmers don't, and will blissfully believe Intellisense has improved their productivity while they incorrectly check return values.

    But many of the tools we use to deal with software complexity (e.g., VS code generators) are Band-aids that give us a handhold on complex systems. If the handholds are good enough, we postpone taking the time to simplify by refactoring. In the long run, though, only the only scalable solution to managing complexity is working relentlessly to reduce it.

    Use VS to start building a Win32, application, and look at the boilerplate code it inserts. It has errors. The return value of GetMessage in the message loop is not checked properly. Mischecking this value is such a common problem that the help writers have made a big point of it in the MSDN topic. The boilerplate also introduced globals, doesn't have consistent formatting, and doesn't seem to adhere to a single set of style guidelines. Nothing there reduces complexity. MS didn't abstract away the hard and tedious bits into a library. Instead they gave us imperfect sample code to use as a starting point.

    And so much of the VS productivity tools seem to be geared toward dealing with the GUI work that I suspect it's leading developers to tightly couple UI and program logic. This is not really productivity-enhancing, though it may feel like it at the time.

    I'll keep Intellisense, though.

  • Anonymous
    October 27, 2005
    The comment has been removed

  • Anonymous
    October 27, 2005
    It used to be that to be a good computer guy you had to know your way around hardware as well - as in you had a wire-wrap tool in a drawer somewhere and knew resistor color codes by memory.

    Nowadays I know plenty of talented programmers who wouldn't have a clue where to begin if you asked them to draw a basic logic diagram for, say, an adder. And it doesn't really matter that they don't know either.

    I see this as part of the muturation of the industry. People specialize and work at different levels of abstraction.

  • Anonymous
    October 27, 2005
    No, VS doesn't make you stupid. But it is getting better and better at delivering on one of Microsoft's long-standing goals: allowing non-programmers to write programs. That was what VB was all about from the beginning; we can't be surprised that it's successful with as much attention as it's received from Microsoft.

    We're seeing it on the kernel side too - the upcoming WDF architecture, with the kernel-mode driver framework, will be yet another step toward ease-of-coding, and yet another step away from an understanding of the underlying fundamentals of the OS.

    There is a reasonable question to be posed here: at what point does it become bad, in general (for society, not for Microsoft), for relatively unskilled coders to work on [kernel-mode] software? Microsoft is in business to sell development tools and kits; it should sell as many as it can. Good for Microsoft. But I'm skeptical that the "market will get it right" on this one, at least not without a bunch of broken software making its way into the world to make all our lives more difficult first. Things like Blaster have real consequences.

    "With great power comes great responsibility" - these tools are designed to deliver great power to people who are new to this, and may not understand or accept the great responsibilities.

  • Anonymous
    October 27, 2005
    The comment has been removed

  • Anonymous
    October 27, 2005
    I write code that goes into a realtime embedded system and my development environment is unix and gvim. I've used VS in the past and while I was pleasantly impressed by intellisense I wouldn't trade the productivity I get from gvim for it. But I can see how somebody working on plain Windows code would like it.

    I don't care for the code generation stuff though. This seems like a poor tradeoff between short term and long term productivity. Sure, you are more productive in the short term but sooner or later you'll need to understand how stuff really works and I for one hate having to do that when I'm in a time crunch. Again, maybe if you are writing a generic business app you don't need to know what goes on behind the curtain, but I'd be willing to bet you are more hireable if you do.

    Thanks for the link!

    Andrew.

  • Anonymous
    October 27, 2005
    The comment has been removed

  • Anonymous
    October 27, 2005
    Odd, I made two replies this morning. Did I get moderated for some reason?

  • Anonymous
    October 27, 2005
    I disputed Petzolds arguments elsewhere so not going to copy paste here, but let's talk about...

    re: newbies

    It's not long ago since I started C# with VS. At first I just wanted to get fancy alpha-blend stuff work in the simplest of WinForms, but gave up eventually since it didn't get me anywhere. Then I took on the challenge of asynchronous socket programming, which took a while to grasp and eternity to get right in a rather unusual scenario. I haven't gone back to doing WinForms since I figured I had to learn threads and delegates first. And while I had UML and Java in school, coming from script languages made grasping OO at first a long process. Some of the errors one gets when one has little understanding of OO are quite intimidating to a total OO newbie. After few books and lot of blogs and samples I started to know what sample code was bad and what was good. Well thought out and designed samples are important so newbie won't get bad ideas if (s)he doesn't understand to question the sample code at every step. From the basic concepts, delegates were a pain to start getting right, less so I believe with VS2005 snippets and anon delegates etc.

    Now with all the new things like W*F, LINQ and Sparkle coming I find the challenges change a bit and newbies like me may get to avoid horrible ADO and WinForms, which I've avoided so far nicely. If only Intellisense had worked perfectly with XAML I'd have started with it already, but the lazy me waits for Sparkle now. Another matter is that coding without a lot of automatic completions is too much exercise for my bad memory and in certain foreign keyboard layouts < > () etc takes double-triple effort. If switching to VS automatically switched the kbd layout to a programming friendly one and back, then I'd consider learning another layout. :-)

  • Anonymous
    October 27, 2005
    Thursday, October 27, 2005 12:00 AM by Nicholas Allen
    > I thought it was decadent when I bought a
    > macroassembler so I didn't have to look up
    > opcodes in the 6510 reference manual. But,
    > I've never again wasted an hour
    > recalculating branch offsets to fit in an
    > extra instruction.

    Seems to me that if you need to fit in an extra instruction and if recalculating branch offsets is a necessary part of getting it done, you're going to have to do some of it by hand anyway.

    But again that's part of the point of letting mechanics be mechanics and teaching drivers how to drive. Yes we still need some people to be mechanics, but that shouldn't be everyone's priority.

    Thursday, October 27, 2005 10:30 AM by Jeff Parker
    > There is nothing like sitting at a Vax
    > terminal at 2 am with a compiler saying
    > "Syntax Error missing semi colon" and you
    > screaming back at the compiler "Yeah but
    > where"

    You had a terminal? With a backspace key that let you fix mistakes oh so easily? And I'll bet you had an insert key and a full screen view? Such a soft life you had. Wanna know what other things there are like that syntax error? Here:

    Unexpected end of file.

    So you know you had a missing brace, but where? You can get this error message from Visual Studio or you could get it from a Fortran compiler 50 years ago. (Oops, 50 years ago it would have been "err3" and you'd have to look up error 3 in a printed manual, because the computer didn't have enough disk space to hold all error message texts.)

  • Anonymous
    October 27, 2005
    The comment has been removed

  • Anonymous
    October 28, 2005
    Such an interesting topic. I guess I'm on the other end of the spectrum on this issue. I've been using VS for a very long time and I wouldn't even know where to begin if I ever had to develop a GUI with it. I just select "File->New->File" and start typing.
    Guess that makes me look like the stupid one! (^:

  • Anonymous
    October 28, 2005
    I disagree completely on the point that IntelliSense forces you into a bottom-up programming model. It's just as easy, if you have refactoring available (Resharper for VS2003, the built-in support for 2005) to use it to stub out each previously nonexistant class/method as you mention it in the top-level program.

  • Anonymous
    October 28, 2005
    The comment has been removed

  • Anonymous
    October 28, 2005
    The comment has been removed

  • Anonymous
    October 30, 2005
    The comment has been removed

  • Anonymous
    November 02, 2005
    You use Visual Studio, right?

    And a few days after posting this blog entry, you posted about a bug that you made using Visual Studio, right?

  • Anonymous
    November 03, 2005
    Yes, I use visual studio. But I didn't learn to program using Visual Studio.

    And the blog posting I made wasn't done in Visual Studio - I cut&pasted some code from my favorite editor (Epsilon), neutered it and ran it through a web colorizer.

  • Anonymous
    November 06, 2005
    Thursday, November 03, 2005 9:56 AM by LarryOsterman
    > Yes, I use visual studio. [...]
    > And the blog posting I made wasn't done in
    > Visual Studio [...]

    Doesn't matter how you learned to program or how you created the blog posting. It matters if you used Visual Studio before making the bug and/or if you used Visual Studio when making the bug.

    I worry now that the teasing I posted on Nov. 2nd and today might not be obvious though. Despite the particular issues on which we have hugely differing opinions, I don't think you're stupid. I was just teasing about the observation that your subsequent blog entry might have answered the question you posted in this one ^u^

  • Anonymous
    November 17, 2005
    "they seem to reflect our fear of being forced into a dehumanizing relationship with a machine that imposes its jerky digital rhythm on our normally analogue souls."

    I can't agree more with this. An example:

    Windows XP has a "feature" for sending files to email recipients by right-clicking the file and selecting Send To|Mail Recipient.

    Now if the file is an image, it kindly (or should I say annoyingly?) offers you to resize the image. That could be a nice feature if it actually worked as it was intended.

    I was sending an image approx. 430x490 pixels in GIF format and it offered me to "make all my pictures smaller" and amongst the options I got 640x480 pixels and 800x600 pixels. Now how is that smaller than 400 something x 400 something really beats me. What is the point? There is NO WAY to turn this wizard off so each time you send the picture you have to select the option and click OK. Two more steps than necessary. Aren't the computers supposed to help us AVOID boring repetitive tasks?

    I checked sendmail.dll which is responsible for this feature and it just has this code inside:

    if (PerceivedFileType == image) {
    AnnoyTheUser(); // without checking
    // the actual image
    // or file size
    } else {
    DoWhatYouWereTold();
    }

    Needless to say I quickly devised a patch to get rid of it.

    About the Visual Studio making you stupid -- it is possible. If you are a first-timer to Windows programming and you start messing with MFC you won't learn how to directly use Windows API and common controls for example. If you don't use MFC then you have a chance but you will be thoroughly annoyed by the MSDN help system which will bombard you with MFC definitions for say WM_COMMAND even if you set your filtering preference to Platform SDK.

    Moreover, I am annoyed by this overflow of new programming languages. Why do people need more languanges? If you don't have adequate programming skills even writing programs in plain English won't help you.

    I am beginning to believe that "language mess" is sort of a conspiracy against real programmers. It is as if someone said "Why not make programming popular by making it easier to create 'Hello World' programs in all sorts of languages. A bunch of monkeys bashing at their keyboards working for peanuts will eventually have the same effect as the smart guys whom we have to pay some real money."
    So yes, it can make you stupid, just pick your poison -- C#, J#, whatever#...

  • Anonymous
    November 30, 2005
    Stupid is as stupid does. - Forest Gump

  • Anonymous
    May 29, 2009
    PingBack from http://paidsurveyshub.info/story.php?title=larry-osterman-s-weblog-does-visual-studio-make-you-stupid

  • Anonymous
    June 08, 2009
    PingBack from http://insomniacuresite.info/story.php?id=4679

  • Anonymous
    June 18, 2009
    PingBack from http://homelightingconcept.info/story.php?id=2742