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 (43)

  1. Norman Diamond says:

    Some countries require the ability to fix at least some kinds of mechanical problems in cars before issuing a driver’s licence. In some of those same countries it’s standard practice to run red lights, run down pedestrians in crosswalks, etc.

    If someone can "drive" VB enough to have fun for themselves but also learn (or be in a sandbox) to avoid hurting anyone else, well fine, let them. Let mechanics be mechanics.

  2. JasonF says:

    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.

  3. Someone says:

    His rants on Visual Studio sounds like the a "Real Programmers use Fortran" phase that all programmers with a lot of experience seem to go through. Years ago, when punch cards were on their way out, there probably was someone complaining how programming had become just conversations with a text editor, and how it rots your brain because you can start banging out code without thinking about your algorithms carefully, etc….etc. Wash, rinse, and repeat. Yawn.

  4. tzagotta says:

    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.

  5. JPrice says:

    I don’t think the photography argument holds up though – most people who snap photos on their Powershots and email them to Grandma wouldn’t claim to be "photographers". I think if you talk to a photographer-by-trade, you’ll find that they at least have an understanding of how aperture settings, shutter speeds, and development techniques can lead to very different outcomes. Sure, they may leave the darkroom work to someone else so they can get more pictures taken (and maybe as a result their darkroom skills have become a little rusty), but they’re not completely clueless as to what takes place in there.

    A good software developer should work the same way – in order to get your project completed, most of the time you want to work at a high-enough level of abstraction that you can actually be productive. But if you haven’t got a clue what’s going on at a lower level because you’ve relied entirely on Visual Studio keeping the guts hidden from you, that sounds like a recipe for disaster.

    If you understand what VS is doing for you, and why it’s doing what it’s doing, great, let it save you some time. But if you’re just letting it do it because "that’s how Visual Studio works", then it’s making you dumber.

  6. 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.

  7. Diego V says:

    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.

  8. John Walker says:

    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.

  9. MSDN Archive says:

    Of course it makes you stupid! And allows you to be otherly-smart. (Which is what everyone else is saying, too.)

    Then again, going against what I’m sure most other ‘softies would believe, I claim that the world needs average-skilled productive devs more than it does 133t ones. Nothing personal against the gurus, but I don’t see a sustainable business model for us if we’re interested in making it MORE difficult to write code so that only the highly-trained, experienced graybeards know how to do it.

    I saw a link to Petzold’s speech on /. and followed the link, but skipped the commentary because this is exactly the kind of thing that crowd seems to love. After all, it’s an excuse to do some sparring for alpha geek territory. Garbage!

    3rd party devs aside, IMHO if Daniel gets interested enough in coding he’ll start to dig deeper because that’s where some of the really fun (meaning difficult) challenges lie. I wouldn’t think that currently lacking depth of knowledge is anything to worry about. He’s probably busy solving the problems that are interesting to *him* and that’s the kind of empowerment I think Microsoft ought to be focused on. (Note: modding games is also a very common way for kids to get into coding today and I think that’s cool, too.)

    Crap. I read like a glossy brochure. I’d best lay off the Kool Aid for a while.

  10. Rob says:

    In my opinion good programming has nothing to do with the language or the tools you use to build a program / system. It has everything to do with mindset and your ability to work professionally, turn problems into solutions in an efficient way (both logically, technically and time wise).

    I could build a solution in Assembly, C(++), C#, VB, VB.NET, HTML, Pascal and I could do that with a simple text editor, with a DOS copy con line or an elaborate IDE.

    I prefer the latter, as do my clients, since it usually cuts time and makes everything much more manageable.

    So I do think it is necessary to at least know how a computer works and the platforms you are programming on (Windows and .NET for example). Now you don’t have to be an expert, but it is good to know how multithreading works under Windows for example. And how this doesn’t work under COM with Visual Basic if you are developing in that language.

    Rob

    visuar@iname.com

  11. Mike says:

    I dubt it makes people stupid, but the VB-ifying (dumbing-down) of it sure makes new users ignorant and some (many?) existing professional (C/C++ only?) developers more than frustrated (*).

    I believe one part of the problem is VS gives you basically two choices. Either use all the (ohhh, new, shiny!) whistles-and-bells and be treated as a child – having code generated for you and do exactly what Microsoft thinks you should do in exactly the way Microsoft thinks you should do it (no matter how illogical or stupid) – or turn off all that shite and go "hard-core old-school".

    I suspect this is in part due to trying too hard to please the previous VB "developers" in the "test groups" from the large companies MS check with, that mostly or even only use it for in-house work. Perhaps it could be good to again start paying attention to the ones that makes Windows a viable platform – the developers that makes Windows software for the public?

    (*) The frustration I’ve experience is of the kind making you more than once both hear and voice the opinion that "If I had the bastard/moron even allowing this shit, I’d use a baseball bat and a pound of salt in more imaginative ways than you can dream of. Without KY!"

  12. JasonF says:

    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.

  13. Tim Smith says:

    Someone else hit it right on the head with the photography analogy. Just because I can take a picture and email it to grandma, I don’t claim that I am a photographer. In programming, people who build simple HTML pages think they are programmers.

    VS.NET any other productivity aids do no make old programmers stupid, they make stupid new programmers.

    In the case of RAD tools for UI, products such as Delphi and VS.NET have allowed programmers to create complex (and usually bad) UI beyond their ability to create and support the code required to bring that UI to life. When we looked at moving our tools development from Borland C++ Builder to VC7/MFC, one of the arguments against doing such a thing was that the UI building tools in VC7/MFC were primitive compared to Borland C++ Builder. My counter argument was that the amount of time we spend working on UI is very small compared to the amount of time working on the UI and non-UI support code. Does this mean our new UI’s are of less quality? In reality our UIs are of better quality because the UIs tend to be simpler, more in line with standard Windows UI and have the quality support code needed to bring the tools to life.

    If I had my way, I would train new programmers without many of the productivity tools we currently have available.

    P.S. The idea that we don’t need "gurus" anymore is just silly. The difference between a well crafted program done by "gurus" and a functional program done by code monkeys can be very substantial. But sometimes the hard part is getting the "guru" to stop playing and release the software before it is a masterpiece.

  14. Tim Smith says:

    UTF-8? Base64?

    The problem isn’t about knowing how to decode UTF-8 and other such formats. The problem is knowing what UTF-8 is, the relationships between UTF-8 and other encoding systems and the impact of one encoding scheme compared to another. We have encoding schemes such as UTF-8 because they meet specific needs that other encoding schemes did not. However, UTF-8 has limitations that makes it harder to use than other encoding schemes in different applications.

    When the software is made available to the programmer without the programmer being required to understand what he is working with, then you get case after case of inappropriate usage.

    This is why I am still trying to get someone like Michael K. to talk about internationalization where I work. I know just enough about the subject to know that we currently have no clue what we are doing. The problem is that the high availability of conversion software has made it easy to get the software to work without knowing if what we are doing is the right thing to do.

  15. James Risto says:

    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.

  16. Kazi says:

    "Does Visual Studio Rot the Mind?"

    Have calculators rotted the mind?

    🙂

  17. Jeff Parker says:

    I am going to have to say yes and no. For the new programmer, yes it most certainly does. My nephew is in a Computer Science course in high school and is really interested in technology, now unfortunately I am the only one that can help him with his homework although it is interesting because I see a lot of myself at that age. I won a copy of VS Pro at my local user group and I already had it through my MSDN subscription so I gave it to him, only 15 year old I know developing with VS.

    Now I spend most of my time in code view in VS. He spends most of his time in a designer where he can drag and drop. Now he is the future of developers. He is constantly asking me how I know all the stuff I know. The other day we were having a conversation about things he should learn on his own, somewhere he learned that regular expressions exist but they are not teaching them that in class so I sat down and walked him through some examples. Anyway, he asked what else he should learn on his own that they wouldn’t teach him in school, I said well eventually you should really learn assembly the root of all evil. He looked at me with disgust and said why on earth would I ever want to learn that. There is no dragging and dropping or anything in there you have to manually do all that.

    This I think is the problem, so many new programmers are not even aware of the struggles we had to go through to get to where we are. 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"

  18. Peter Smith says:

    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.

  19. Chris says:

    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."

  20. Adrian says:

    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.

  21. D.J. Stachniak says:

    Visual Studio doesn’t make you stupid, but cheating your way to get things done without understanding how they work is why we have SO many crappy programmers out there. Programming is a TOUGH thing to learn and takes a LONG time. Visual Studio (VB was the initial culprit) allows you to jump right into calculus without learning basic arithmetic. Ask most programmers today who Von Nuemann is/was and they will tell you he was a German World War I fighter ace. You HAVE to know the fundamentals BEFORE you can use the shortcut tools. That’s the problem Visual Studio is exacerbating.

  22. Mike says:

    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.

  23. 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.

  24. Feroze Daud says:

    I am of the opinion that VS (like anything else) is a tool. You can use it to your advantage, or shoot yourself in the foot.

    I see no problems in people using Intellisense, or using the designer generated code to write applications. It is not a bad thing, necessarily. I can remember back when I first got started doing GUI programming (first with X-Windows and then with VC) and honestly, it was a pain in the butt. Instead of focusing on my application, I was spending more time writing message loops etc. Not that it is a bad thing to do so, but it distracted me from my main task which was to write a small GUI application.

    I would be concerned if newbie programmers started depending on VS as a whole for developing their programming skills. For eg, I once had to interview a person, and asked him to write a simple liked-list algorithm, and he said that he doesnt have to do that anymore because there is the System.ArrayList to use! Thank goodness it was for a temp position and he was promptly dispatched!

    When I got started programming, I learnt things from the bottoms up, meaning assembly -> C -> datastructure/algorithms etc. I can see why VS would encorage a more top-down approach since most of the things like Hashtable/List etc are already available. Is this necessarily a bad thing, and encourages bad programming practice? I am not sure. I guess VS or no VS, most programmers learn some bad programming habits over time, and with maturity and experience, hopefully, they can question them and change them.

  25. Andrew says:

    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.

  26. Philip Taron says:

    I think that there’s a topic that you’ve touched on in the pat, Larry: in order to understand and use a system, you have to understand the layer under it.

    In the case of the graphical UI designer in Visual Studio, you need to understand the code that Visual Studio is hiding away from you in that big generated region. You have to know why it is adding events, what adding an event means, and how you can add and remove events if you wanted to. The test really is: if you had to, could you write a WinForms application without the designer?

    This test applies to all levels of abstraction. I use C++ every day. I should know what the layout in memory of a virtual class is. Given the disassembly view of my program, I should be able to give a reason for each line of code that the compiler has generated, and why it is either necessary or not. I should be able to understand how one might implement templates, virtual functions, multiple inheritance, and object allocation in assembly, and what these features would look like in memory.

    This doesn’t mean I need to be an assembly programmer, or produce any assembly code, although that’s a good way to test to see whether I really understand what’s going on.

    This also doesn’t mean that I need to understand how chips work on a detailed level. That’s what the assembly programmer has to do. But what I’m building on, that I need to know in order to build further.

    The law of leaky abstractions applies, of course. There will be times that assumptions from the design of the chips bubble up to me (I’m thinking of endianness here.)

    So what should the C#, managed programmer know? She should know how the CLR works, what IL code is generated for her programs, and what the JITter will do to that code. For the CLR specifically, she should know how one would go about making the methods in the FCL: none of these are magic, though some require support from the CLR.

    Etc.

    So does Visual Studio rot your brain? Entropy is the fundamental natural process: yes it does, if you let it.

  27. Tim Smith says:

    Odd, I made two replies this morning. Did I get moderated for some reason?

  28. Joku says:

    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. 🙂

  29. Norman Diamond says:

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

  30. David Candy says:

    Because I had to spend may a boring, sunny, afternoon in classrooms learning how to design ALU, registers, and other wierd digital circuits my concept is at the physical level.

    I visualise two numbers being added as

    [Why did they remove line drawing characters – I know – IBM used them]

    0 ——- l———l ——–1

    0 ——- l ALU l ——–1

    1 ——- l l ——–0

    0 ——- l———l ——–1

    l l l l

    l l l l

    l l l l

    l l l l

    0 0 0 1

    Which adds 0010 with 1101 as 0001 is the ALU code for add (on a 10Hz computer).

    Now if daniel doesn’t visualise VB in this context I don’t know how he could use it. If a C or assembler programmer also doesn’t visualise it like this, how can they program as their frame of reference is the CPU rather than the heart of a CPU.

    I actually visualise electrons whizzing about.

  31. 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! (^:

  32. Adam G says:

    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.

  33. JasonF says:

    Just thought of something that sort of puts this into context: Petzold is the guy who wrote a book about creating computer circuits out of telegraph relays. Now that’s hardcore!

  34. Brooks Moses says:

    I think we’ve all seen examples of poorly-written programs that we can tell are poorly-written even without access to the source. My example is the calendar program my university uses (which they bought from a well-known database company). On my old computer, when I clicked the "login" button, I could watch each individual control disappear in order off the login dialog box before the box went away. And any time it wants to synchronize the local and remote versions of the calendar, it has to transmit about 500kb of data each way over my dialup-modem connection, and the conflict resolution system is horribly brain-dead.

    Now, I suspect (though it’s just a hunch) that that calendar program was created in a remarkably short amount of time due to a whole host of canned routines and autogenerated code. And I further suspect that the reason that it’s so poorly written is because some of the canned routines are "something close enough to work" rather than an actual solution intended for the specific problem at hand.

    From a user perspective, it’s things like that that worry me. I’m concerned that more and more applications will end up written like that, and that we’re getting into a place where quantity of programming is much more important than quality of programming.

    I don’t know if this is a result of Visual Studio, or a cultural result of how programming companies expect to make money, though. Probably some of both, combined with a "if the tools exist, people will use them" thing.

    Meanwhile, I’ll just keep on writing my command-line-interface Fortran programs. In, ironically enough, Visual Studio, since that’s what Intel Fortran uses for its IDE.

  35. Andras Ludanyi says:

    I don’t see how can one BECOME stupid, maybe STAY stupid but definitely not BECOME. So Visual Studio can’t make you stupid, if you know something and you want to learn something you will do it regardless of your tools. Visual Studio is the other name for progress in the programming world, but there is something that we almost always fail to remember, to notice, the fact that there are two kind of programmers. There are PROGRAMMERS in a sense of Computer Science (and I wouldn’t call anyone a PROGRAMMER {of this kind} if he doesn’t know Knuth’s Art of Computer Programming inside and outside. This kind of PROGRAMMERS are the ones who makes the OS, the Tools including the compilers and they design languages, the system software including the .NET Framework or the OS kernel or Java, this kind of programmers design the protocols, the class libraries and other similar stuff… And there are the second kind of programmers the DEVELOPERS, which is usually application programmers, they don’t need (it’s won’t hurt, but not a mandatory thing) to know Knuth’s Art of Computer Programming, they don’t need to know regular expressions; they don’t need to know binary trees or CPU registers or any other hard/core stuff. They are DEVELOPERS which usually need fast and easy tools, they need results ASAP, and they build business software using controls and forms and these applications 90% of the time write/read data in a database and make some relatively easy transformations or calculations with those data. These DEVELOPERS are in high demand and even with this sophisticated tools like Visual Studio there is a shortage of them in the market. And if there is no Visual Studio these developers would never became programmers, because the “hard/core” approach, the Computer Science approach is something far above their abilities or they wishes. After all if we put everything in the place they are belong the whole thing will looks different. But even this theory isn’t complete. I am the Computer Scientist kind of PROGRAMMER, who are around for about 20 years and know the hard stuff, but occasionally have to do some business application development, and sometimes I find myself disabled, working with those young DEVELOPERS who don’t understand the low level stuff, because sometimes it would be better to forget some stuff because its acts like a brake, the young developer find more creative and easier, or would I call more elegant solutions, because they mind is not blocked by some old stuff, they don’t consider stuff like we the “old guys” because they are not even aware of it. But if things go wrong then trust me this is not a questionable thing, the Computer Scientist kind of PROGRAMMER will worth of pure gold. At he end of the day, as I mentioned before, everything needs to be where its belongs.

  36. Norman Diamond says:

    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?

  37. 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.

  38. Norman Diamond says:

    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^

  39. Igor says:

    "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. 430×490 pixels in GIF format and it offered me to "make all my pictures smaller" and amongst the options I got 640×480 pixels and 800×600 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#…

  40. Stupid is as stupid does. – Forest Gump