Does Visual Studio Rot the Mind? (2005)(charlespetzold.com)
charlespetzold.com
Does Visual Studio Rot the Mind? (2005)
http://charlespetzold.com/etc/DoesVisualStudioRotTheMind.html
121 comments
Keep in mind that this is 15 years old. Intellisense and the whole compiler were quite different back then. And it often not possible to hold a ton of things in memory - like modern IDEs do it with easy.
Also in VS 2005 you didn't have compilation on-the-fly - so you wouldn't get the annoying squiggly lines for undeclared properties. That only came in 2008 SP1 I think. And Generate property was also added to VS quite a long time ago - but sometimes it doesn't have enough information of course like
if (object.nonexistant != null) ....Anecdote from this week: I've been working on a Python project that uses several classes and subclasses, with code paths that move around a lot through the class hierarchy. I was trying to add some functionality but kept getting bogged down trying to make sure all the subclasses implement the same interface, using Atom as the text editor.
Then I installed PyCharm and completed the task in just a few hours thanks to the "find uses" and jump to definition functionality. I was also able to refactor some less-than-good variables names. I've always hated IDEs for personal projects (to avoid mind-rot), but now I'm starting to think for large enough projects you just need an IDE.
The only drawback I see is a few millisecond lag on all actions. Every time you scroll, or clock on something there is a lot of things going on in the background, vs. Atom which feels near-instant.
Then I installed PyCharm and completed the task in just a few hours thanks to the "find uses" and jump to definition functionality. I was also able to refactor some less-than-good variables names. I've always hated IDEs for personal projects (to avoid mind-rot), but now I'm starting to think for large enough projects you just need an IDE.
The only drawback I see is a few millisecond lag on all actions. Every time you scroll, or clock on something there is a lot of things going on in the background, vs. Atom which feels near-instant.
You definitely don't need to go to a full IDE just to get find-definition and find-references. Those are basic features of any ctags-enabled editor, and nowadays with the momentum behind LSPs you get carrier-grade versions of it without even needing to generate a tag file. (In fact, Neovim's next version will actually ship with an LSP client, you won't even need an extension for it).
I just bind 'gd' and 'gr' to go to definitions and references, respectively, and I'm good to go in vim.
I just bind 'gd' and 'gr' to go to definitions and references, respectively, and I'm good to go in vim.
Emacs has dumb-jump, which is just... Fantastic. Absolutely fantastic.
It doesn't perform any deep semantic analysis; it just abuses whatever existing grep-like tools you have and a bare minimum understanding of the language syntax to find likely correct definitions.
https://github.com/jacktasia/dumb-jump
It doesn't perform any deep semantic analysis; it just abuses whatever existing grep-like tools you have and a bare minimum understanding of the language syntax to find likely correct definitions.
https://github.com/jacktasia/dumb-jump
Holy hell, it's the missing companion for Hippie Expand! For non-emacsers, hippie-expand completes the word you're typing by throwing a bunch of heuristics at it, most notable of which is "search this and every other opened buffer for the last few things before the cursor, and see if this produces a completion".
(A funny side effect of this heuristic is that it essentially behaves like a Markov chain. If you have it bound to a key, say M-/, then you can type a starting word and repeatedly press "M-/ Space", and it'll start generating text based on what you have in your open buffers.)
https://www.emacswiki.org/emacs/HippieExpand
(A funny side effect of this heuristic is that it essentially behaves like a Markov chain. If you have it bound to a key, say M-/, then you can type a starting word and repeatedly press "M-/ Space", and it'll start generating text based on what you have in your open buffers.)
https://www.emacswiki.org/emacs/HippieExpand
Very popular LSPs actually have poor support for basic definition/reference jumping.
`javascript-typescript-language-server` sticks out to me as my first disappointment. And the only implementation of a vue language server is no better, where tls would just throw errors for mixing HTML templates with scripts even if it handles the Javascript properly.
`javascript-typescript-language-server` sticks out to me as my first disappointment. And the only implementation of a vue language server is no better, where tls would just throw errors for mixing HTML templates with scripts even if it handles the Javascript properly.
Whichever language server the tide package uses in emacs has excellent jump to definition abilities.
There's also YouCompleteMe, which gives you completion for half a dozen popular languages.
I think visual studio code strikes the right balance between performance and functionality
I don't understand why people like VS Code. Are they coming from Eclipse, or writing code in Notepad?
It's light for an Electron app, but that still makes it a bloated pig compared to Sublime or Geany or any of the older Scintilla/SciTE editors.
It can't do multi-window at all, which is a disqualifying mark in my books.
It's light for an Electron app, but that still makes it a bloated pig compared to Sublime or Geany or any of the older Scintilla/SciTE editors.
It can't do multi-window at all, which is a disqualifying mark in my books.
I come from Vim, Sublime Text, Jetbrains IDEs, and have tried a lot of other stuff as well, but not as thoroughly.
At some point VSCode became snappy enough for me to use as my main editor, and Sublime Text really spoiled me in that regard. What pulled me over was that VSCode implements a lot of features from bigger IDEs without installing extensions, and they also seem to work better in VSCode than in Sublime Text, let alone Vim.
The ecosystem is amazingly alive and well, and the pace of development is really impressive. The user interface is in my opinion the best of any editor I've ever used.
While I was transitioning I still used Sublime Text for quick edits to text files, but now I am using VSCode for that as well.
Also, it can do multiple windows, as well as vertical and horizontal splits. If you're not using VSCode because of some missing feature, check back every month. It might very well have been implemented in the latest version.
At some point VSCode became snappy enough for me to use as my main editor, and Sublime Text really spoiled me in that regard. What pulled me over was that VSCode implements a lot of features from bigger IDEs without installing extensions, and they also seem to work better in VSCode than in Sublime Text, let alone Vim.
The ecosystem is amazingly alive and well, and the pace of development is really impressive. The user interface is in my opinion the best of any editor I've ever used.
While I was transitioning I still used Sublime Text for quick edits to text files, but now I am using VSCode for that as well.
Also, it can do multiple windows, as well as vertical and horizontal splits. If you're not using VSCode because of some missing feature, check back every month. It might very well have been implemented in the latest version.
It is very well designed. Probably the most well designed editor/IDE ever created. (This is coming from a long-time Emacs enthusiast who still uses it most of the time.) Everything is modular and pluggable, like the extension system, tasks, the formatter, the debugger, language server. It offers a consistent API for any language or build system to tool against, so one improvement in the core editor can improve the experience of every language/build system.
It is heavy because it pulls in Chromium, but this is also one of its strengths. User extensions run on the same V8 that the entire editor does, so when you make an extension, it runs as fast as it would if it were part of the core editor. (This is a huge downside of Elisp's and Vim's interpreters.)
It is heavy because it pulls in Chromium, but this is also one of its strengths. User extensions run on the same V8 that the entire editor does, so when you make an extension, it runs as fast as it would if it were part of the core editor. (This is a huge downside of Elisp's and Vim's interpreters.)
VScode is a glorified text editor. It pales in comparison to a real IDE like Visual Studio
Thank you. I honestly get the sense that people calling something like VS Code an "IDE" have never worked with an actual IDE.
I have barely used Visual Studio, so maybe you're right. I did use it a few times for C++, and the version of it from circa 2006 is what I learned with. Visual Studio is very good, especially the debugger, but honestly VS Code with the C++ language server is good enough (80%, Pareto equivalent). Emacs with clangd is also decent while being lightweight.
What does an IDE do? VS Code can refactor, rename symbols, run a graphical debugger, parse a semantic outline of code, do version control with the mouse. A pure editor is like vi/ex/notepad.exe. VS Code is definitely closer to IDE than it is to an editor on that continuum.
Obviously for .NET, it's another story. Hands down the best way to make Windows desktop applications. You can build entire worlds without ever leaving the IDE. Thanks to Unity and Xbox, you can even do professional game dev with it.
Personally, for me it doesn't matter how good Visual Studio is or becomes because it'll take too long for me to learn Windows. I'm (happily) vendor locked in to the GNU ecosystem.
What does an IDE do? VS Code can refactor, rename symbols, run a graphical debugger, parse a semantic outline of code, do version control with the mouse. A pure editor is like vi/ex/notepad.exe. VS Code is definitely closer to IDE than it is to an editor on that continuum.
Obviously for .NET, it's another story. Hands down the best way to make Windows desktop applications. You can build entire worlds without ever leaving the IDE. Thanks to Unity and Xbox, you can even do professional game dev with it.
Personally, for me it doesn't matter how good Visual Studio is or becomes because it'll take too long for me to learn Windows. I'm (happily) vendor locked in to the GNU ecosystem.
I have used IDEs. I get how some might refer to VSCode as an IDE, although I don't use it in that way (or do I?).
If you read about the typical features of an IDE on Wikipedia, VSCode checks most boxes. So I don't see any point in complaining about it being called one, unless you're trying to be a snob about it.
If you read about the typical features of an IDE on Wikipedia, VSCode checks most boxes. So I don't see any point in complaining about it being called one, unless you're trying to be a snob about it.
Yeah. But, I mean, what development tool doesn't pale in comparison to Visual Studio, right?
Basically IntelliJ and its variations. That's it, that's the list.
And they've only got one kitchen sink, not the triple commercial sink of features VS lugs along.
And they've only got one kitchen sink, not the triple commercial sink of features VS lugs along.
as a very loyal long term emacs user I have to agree. I find myself using vscode more and more just to how more pleasant refactoring and debugging python code is.
I almost switched to VSCode for JavaScript but I’ve found that tide-mode (for JavaScript) and lsp-mode (for other languages) have really closed the gap. (If you turn off lsp-sideline-mode)
I dallied with VSCode when work forced me to deal with a gigantic lump of Typescripted React, but in the end I found that emacs with tide/prettier was a nicer experience, so I ended up going back, as I always do, to emacs.
I miss the raw text editing and no-mouse flow when on vscode.
Yes, and mostly out of the box, too.
How is your grep/sed/regex fu? learning these tools will pay big time.
> ses several classes and subclasses, with code paths that move around a lot through the class hierarchy
The flip side I see more often than not (no idea if it applies here) is that IDE's are the enabler that allow such terrible code where less tooling would force a much simpler and more readable design. The more tooling you need to navigate a codebase the less readable it is. The reason "you need an IDE for java" is so prevalent isn't so much because of the language but because of the "enterprisy" OO code the ecosystem is famous for.
IDE's can certainly help, especially once projects reach a certain size, but reliance on them is an indicator of greater problems.
The flip side I see more often than not (no idea if it applies here) is that IDE's are the enabler that allow such terrible code where less tooling would force a much simpler and more readable design. The more tooling you need to navigate a codebase the less readable it is. The reason "you need an IDE for java" is so prevalent isn't so much because of the language but because of the "enterprisy" OO code the ecosystem is famous for.
IDE's can certainly help, especially once projects reach a certain size, but reliance on them is an indicator of greater problems.
Codebases get unwieldy because lots of people make small, individually reasonable changes to them over years, and it adds up.
I don’t need an IDE to add another invocation of the method. I need an IDE when the signature has to change.
I don’t need an IDE to add another invocation of the method. I need an IDE when the signature has to change.
You don’t need an ide, you need a list of potentially affected lines.
And they don't get wieldly again because Ides are so enabling.
While some of his complaints now have solutions[1], when WPF (previously known as Avalon) is used with care, the resulting XAML is much more diff-able and code-review-able. The CodeDOM serialization method is dense and small changes can cause huge code diffs.
On the other hand, WPF is a lot more complex than WinForms. There are a lot of different ways to use, many of which involve data binding that is not evaluated till runtime. There are ways to make some databinding type-checked at compile time, but it is not built in. WinForms data binding is pretty limited, so generally it is easier to track down what piece of code is causing something to display on the screen.
WinForms (and the Win32 resource scripts that can before it) are more limited in what they can easily express. So the resulting UIs tend to be a bit visually and behaviorly similar. This is nice for devs because you have a design already laid out for you. It's also nice for users since the apps are more consistent and predictable. WPF gives you a big blank canvas where it is hard to make something look decent. And enables making your app look completely different than anything else.
So in conclusion, I agree that WPF enables more understandable code to be created by people who care. Unfortunately it is often to used to add a bunch of needless complexity.
[1]: For example, the GenerateMember option in the WinForms design can be used to suppress generating fields for controls.
On the other hand, WPF is a lot more complex than WinForms. There are a lot of different ways to use, many of which involve data binding that is not evaluated till runtime. There are ways to make some databinding type-checked at compile time, but it is not built in. WinForms data binding is pretty limited, so generally it is easier to track down what piece of code is causing something to display on the screen.
WinForms (and the Win32 resource scripts that can before it) are more limited in what they can easily express. So the resulting UIs tend to be a bit visually and behaviorly similar. This is nice for devs because you have a design already laid out for you. It's also nice for users since the apps are more consistent and predictable. WPF gives you a big blank canvas where it is hard to make something look decent. And enables making your app look completely different than anything else.
So in conclusion, I agree that WPF enables more understandable code to be created by people who care. Unfortunately it is often to used to add a bunch of needless complexity.
[1]: For example, the GenerateMember option in the WinForms design can be used to suppress generating fields for controls.
Every couple of years I take another look at WPF but it always feels like wading through treacle for me. I'm so much more productive in WinForms. Perhaps if I dedicated a year to it I might come out the other side a productive WPF programmer but I have my doubts.
I'm in the same boat as you. The windows forms designer is such a joy to use. But as soon as you need to add special behavior to some controls it can get quite hairy. I've never encountered a complete roadblock, but we have a ton of code for windows forms controls which look more like workarounds or cheap hacks. But hey, it works.
I also like the consistency of windows forms. This is awesome for administrative and business users, who just want to get their work done. There are no UI surprises. But your tool will look like an ugly duck, if it is used in an environment with shiny Web and WPF applications.
For this reason alone, we had to make a split between forms and WPF applications. Windows Forms for administrative UI, WPF for end users. (By the way: I recommend outsourcing the design part to another company specialized in WPF design. Designing nice WPF UI is a black art.)
There's also the fact that Microsoft calls forms legacy tech, but I'm not yet too concerned. I would be more concerned to rewrite all WPF application with the next shiny framework coming around...
I also like the consistency of windows forms. This is awesome for administrative and business users, who just want to get their work done. There are no UI surprises. But your tool will look like an ugly duck, if it is used in an environment with shiny Web and WPF applications.
For this reason alone, we had to make a split between forms and WPF applications. Windows Forms for administrative UI, WPF for end users. (By the way: I recommend outsourcing the design part to another company specialized in WPF design. Designing nice WPF UI is a black art.)
There's also the fact that Microsoft calls forms legacy tech, but I'm not yet too concerned. I would be more concerned to rewrite all WPF application with the next shiny framework coming around...
Have you ever tried any of the Metro styled WinForms component kits?
https://www.google.com/search?hl=en&q=metro+styling+for+winf...
Styling WinForms to look the way you want is certainly possible, but I would agree that it's even more of a black art than designing a WPF UI.
https://www.google.com/search?hl=en&q=metro+styling+for+winf...
Styling WinForms to look the way you want is certainly possible, but I would agree that it's even more of a black art than designing a WPF UI.
Hoesntly the one thing that's always turned me off of WPF was how had styling was. iirc, doing minor style modifications on a simple Uai involved writing a boatload of markup and overriding stuff I didnt want to have to worry about
"Twenty years ago, in November 1985, Windows 1.0 debuted with approximately 400 documented function calls.5 Ten years later, Windows 95 had well over a thousand.6
Today we are ready for the official release of the .NET Framework 2.0. Tabulating only MSCORLIB.DLL and those assemblies that begin with word System, we have over 5,000 public classes that include over 45,000 public methods and 15,000 public properties..."
This is our constant struggle in the modern world where the complexity is simply outstripping the capacity of the human brain. It's happening in physics, biology, genetics... Some authors question why we need all this complexity? Isn't complexity bad? I'm forming a view that the complexity is in fact necessary and we try out best to minimize it but beyond a certain level, it's simply isn't possible to get rid of it. This is only accelerating. Classic physics was easy to understand but all the advances have made physics (and other fields) slowly inaccessible to a larger and larger population without going through intense add-on multi-year narrowly scoped learning. It seems we are at the point that to comprehend the latest in quantum mechanics you need yet another 16 years of learning after you already had 16 years of high school+college. In other words, time to climb the knowledge pyramid doubles approximately every 100 years. By that speculation, in year 2100 the knowledge pyramid might have grown so big that to reach top might need 48 years! At this juncture, it might become apparent that the human life span is simply not enough to climb the knowledge pyramid starting from the basic arithmetic to the latest and greatest in physics anymore. We reach tipping point where biological limitation of life spans, memory capacity, recalls and search become truly limiting. I think this is where AI would be super important. From that point onward, we will need to rely on machines to tell us the simplified, intuitive but inaccurate version of the truth that we can sort of comprehend with our limited hardware, like automated machine-generated 1000+ steps proofs. That would be an interesting world.
Today we are ready for the official release of the .NET Framework 2.0. Tabulating only MSCORLIB.DLL and those assemblies that begin with word System, we have over 5,000 public classes that include over 45,000 public methods and 15,000 public properties..."
This is our constant struggle in the modern world where the complexity is simply outstripping the capacity of the human brain. It's happening in physics, biology, genetics... Some authors question why we need all this complexity? Isn't complexity bad? I'm forming a view that the complexity is in fact necessary and we try out best to minimize it but beyond a certain level, it's simply isn't possible to get rid of it. This is only accelerating. Classic physics was easy to understand but all the advances have made physics (and other fields) slowly inaccessible to a larger and larger population without going through intense add-on multi-year narrowly scoped learning. It seems we are at the point that to comprehend the latest in quantum mechanics you need yet another 16 years of learning after you already had 16 years of high school+college. In other words, time to climb the knowledge pyramid doubles approximately every 100 years. By that speculation, in year 2100 the knowledge pyramid might have grown so big that to reach top might need 48 years! At this juncture, it might become apparent that the human life span is simply not enough to climb the knowledge pyramid starting from the basic arithmetic to the latest and greatest in physics anymore. We reach tipping point where biological limitation of life spans, memory capacity, recalls and search become truly limiting. I think this is where AI would be super important. From that point onward, we will need to rely on machines to tell us the simplified, intuitive but inaccurate version of the truth that we can sort of comprehend with our limited hardware, like automated machine-generated 1000+ steps proofs. That would be an interesting world.
No. Reaching the top of the knowledge pyramid in your subfield over time has remained constant (typically in your early to mid 20s, as you complete your PhD).
We have more sub fields, but that’s not particularly a problem - once you’re an effective researcher, jumping branches - and even trunks - is far from impossible. A few months surrounded with talented people and dedication is typically enough - eg my grad school advisor, a CS HCI professor, got into genomics when meeting his wife and went on to publish, as first author, genomics papers in nature.
See also the recent rise of machine learning - many of the top contributors to that field were not doing machine learning research 10 years ago.
Similarly, motivated high schoolers now learn things that you needed a PhD to tackle 100 years ago.
Knowledge is weird and non linear, and as humans we have many super powers: we stand on the shoulders of our predecessors, we build better ways to preserve knowledge, to share it, better ways to teach, better ways to test our theories, etc.
It took thousands and thousands of years of man hours of work to get us to basic calculus, something that a motivated high schooler can get very comfortable with in a few weeks at most. The most educated Roman citizen would take a bit of time to compute something as straightforward as (8238*2949), which is now something you expect elementary school students to compute in minutes at most.
If we could jump in time 100 years in the future and see what 18 year olds know and can do then, we’d probably be blown away.
We have more sub fields, but that’s not particularly a problem - once you’re an effective researcher, jumping branches - and even trunks - is far from impossible. A few months surrounded with talented people and dedication is typically enough - eg my grad school advisor, a CS HCI professor, got into genomics when meeting his wife and went on to publish, as first author, genomics papers in nature.
See also the recent rise of machine learning - many of the top contributors to that field were not doing machine learning research 10 years ago.
Similarly, motivated high schoolers now learn things that you needed a PhD to tackle 100 years ago.
Knowledge is weird and non linear, and as humans we have many super powers: we stand on the shoulders of our predecessors, we build better ways to preserve knowledge, to share it, better ways to teach, better ways to test our theories, etc.
It took thousands and thousands of years of man hours of work to get us to basic calculus, something that a motivated high schooler can get very comfortable with in a few weeks at most. The most educated Roman citizen would take a bit of time to compute something as straightforward as (8238*2949), which is now something you expect elementary school students to compute in minutes at most.
If we could jump in time 100 years in the future and see what 18 year olds know and can do then, we’d probably be blown away.
>See also the recent rise of machine learning - many of the top contributors to that field were not doing machine learning research 10 years ago.
Machine learning is older than you think.
Machine learning is older than you think.
The previous commenter was not saying that machine learning didn't exist 10 years ago. They were saying that "many of the TOP CONTRIBUTORS TO THAT FIELD were not doing machine learning research 10 years ago."
There are also people who were doing machine learning 30 years ago and are still doing so. But there are people who were doing, say, fluid dynamics simulations 10 years ago who self-taught machine learning, and are now making significant contributions to machine learning, by transferring their knowledge of programming, optimization, calculus, etc.
There are also people who were doing machine learning 30 years ago and are still doing so. But there are people who were doing, say, fluid dynamics simulations 10 years ago who self-taught machine learning, and are now making significant contributions to machine learning, by transferring their knowledge of programming, optimization, calculus, etc.
Arguably, we're already past the point where it's impossible for a single human brain to retain all knowledge needed to build today's society, or even to fully dominate a field right physics, biology or genetics?
Complexity isn't "bad" - complexity is a property of all evolving things, from code to life. In sciences, it just means we're collectively learning more, faster and better. Complexity is beautiful!
Complexity isn't "bad" - complexity is a property of all evolving things, from code to life. In sciences, it just means we're collectively learning more, faster and better. Complexity is beautiful!
It's not even arguable. I mean, think about, say, databases. I've worked with people who have far deeper knowledge about them than I ever will. A few old timers working at Oracle know more about database keys than anyone else ever will, and that expertise is necessary to build a modern system.
And that's just one thing, databases. There are way more technologies out there. Even building my metal coffee cup requires deep expertise in metallurgy, manufacturing, industrial design, product design, supply chains, etc. etc. etc.
I think it's past the point for a single human brain to retain all knowledge about databases, unless they're a profound genius (don't underestimate how much there is to know), and that is one tiny thing that humans do.
And that's just one thing, databases. There are way more technologies out there. Even building my metal coffee cup requires deep expertise in metallurgy, manufacturing, industrial design, product design, supply chains, etc. etc. etc.
I think it's past the point for a single human brain to retain all knowledge about databases, unless they're a profound genius (don't underestimate how much there is to know), and that is one tiny thing that humans do.
On the contrary. For me, good intellisense just makes coding flow better. If you're just getting your feet wet with the API, auto complete greatly helps you discovering the API. If you're already a veteran, coding just flows at lightning speed as long as intellisense correctly predicts what you want, which is the case "most" of the time.
It’s been a few years, but for c++ on a large codebase I vastly prefer qtcreator. Intelligence regularly hung while doing some background rescan. It was infuriating.
Yeah, Visual Studio is more of a C# IDE than a C++ IDE I think; I don't code in C++ but if I did I'd never pick VS; Of course C++ is a vastly harder language to parse compared to C#;
I enjoyed the article, but I really want to hear the 1991 talk that he gave at the Boston Computer Society meeting re: early Windows development, OS/2, and the Microsoft/IBM split. I'm sure it's lost to the mists of time, sadly. I had no luck finding it doing some quick searching.
His email address is on his website... Maybe you should drop him a line. He might still have slides or notes.
I also wish to locate this video or maybe the speech text. Really interested in early history of MS
> You must define all variables before you use them. No more skipping around in your code.
I skip around all over the place, but I almost always throw in a definition for a variable at the point where I first decide to use it. Maybe that's why Intellisense never annoyed me.
As for the question of whether power tools like Intellisense rot the mind: No. What rots the mind is staying within your comfort zone instead of trying new things and challenging your capabilities. Power tools just let you tackle bigger challenges faster.
I skip around all over the place, but I almost always throw in a definition for a variable at the point where I first decide to use it. Maybe that's why Intellisense never annoyed me.
As for the question of whether power tools like Intellisense rot the mind: No. What rots the mind is staying within your comfort zone instead of trying new things and challenging your capabilities. Power tools just let you tackle bigger challenges faster.
Very nice flowing article. I think this quote feels ever prescient, "What the Internet seems to do best is make commonly available enormously vast resources of mis-information that we never knew existed."
> I’m prevented from ever achieving a fluid coding style because the coding is not coming entirely from my head. My coding has become a constant dialog with IntelliSense.
This.
Code should live in your head. You shouldn't need intellisense to see that a property doesn't exist in an object. I hate code completion, most of the time it gets in the way of your thought process. Even if it can gain you a little speed increase, it still is better to write things down for your 'codebase memory'.
That's why I despise the current web development stack. You need Typescript, otherwise you might make a mistake with types? Never had that problem in the past. And just like typo's I make mistakes a once in a while, but that's OK because it helps me to learn the codebase better. You need a linter? Same story, it's always in the way as if it is more capable than me writing code. Prettier? It automatically formats your code, so the codebase doesn't resemble the one in your head anymore.
I know it does work for some people and I can totally imagine that for a beginner developer it can make the difference, but for me it doesn't. In the current/modern web stack I feel like having brick walls everywhere around me and my code is definitely not getting better from it, I'm just constantly struggling with all those 'handy' and 'necessary' tools while my code memory deteriorates. Even worse is that on almost any project I professionally work on requires all those tools, not using them makes me an amateur, even in the eyes of junior dev's.
I believe in writing every character of my code and testing it thoroughly, I wrote many bug free codebases with it, that's my experience.
This.
Code should live in your head. You shouldn't need intellisense to see that a property doesn't exist in an object. I hate code completion, most of the time it gets in the way of your thought process. Even if it can gain you a little speed increase, it still is better to write things down for your 'codebase memory'.
That's why I despise the current web development stack. You need Typescript, otherwise you might make a mistake with types? Never had that problem in the past. And just like typo's I make mistakes a once in a while, but that's OK because it helps me to learn the codebase better. You need a linter? Same story, it's always in the way as if it is more capable than me writing code. Prettier? It automatically formats your code, so the codebase doesn't resemble the one in your head anymore.
I know it does work for some people and I can totally imagine that for a beginner developer it can make the difference, but for me it doesn't. In the current/modern web stack I feel like having brick walls everywhere around me and my code is definitely not getting better from it, I'm just constantly struggling with all those 'handy' and 'necessary' tools while my code memory deteriorates. Even worse is that on almost any project I professionally work on requires all those tools, not using them makes me an amateur, even in the eyes of junior dev's.
I believe in writing every character of my code and testing it thoroughly, I wrote many bug free codebases with it, that's my experience.
You shouldn't need intellisense to see that a property doesn't exist in an object.
So what do you do instead? Not just for intellisense but all other possible code completion solutions? Does that mean you always manually open a source file and look for the name of the function/member/whatever you need, then either copy/paste or manually type it? And try to remember all of them to avoid having to do that process again? I've done that from time to time and still do but it's just slower than intellisense and the likes, always.
So what do you do instead? Not just for intellisense but all other possible code completion solutions? Does that mean you always manually open a source file and look for the name of the function/member/whatever you need, then either copy/paste or manually type it? And try to remember all of them to avoid having to do that process again? I've done that from time to time and still do but it's just slower than intellisense and the likes, always.
Clearly, you just memorise / know everything. Jokes aside, there is a balance to be had between having to look up trivial, everyday things via intellisense, and expecting people to know every single method on a massive set of libraries. I'm always surprised by people who claim that the latter approach is a good investment of their time and mental capacity. At some scale, it simply cannot be optimal.
>At some scale, it simply cannot be optimal.
Time spent memorizing APIs is time that could be spent learning new problem solving techniques or interesting algorithms.
These folks have bad opportunity cost assessments. There's always some piece of knowledge more useful for memorization than an API function.
Time spent memorizing APIs is time that could be spent learning new problem solving techniques or interesting algorithms.
These folks have bad opportunity cost assessments. There's always some piece of knowledge more useful for memorization than an API function.
I think one problem is that some of these sorts of things always pop info up at you, instead of you the coder pressing a keystroke to have it help you.
There's 3 different models that happen:
1. Type in the entire thing
2. Type in a unique portion and ask it to autocomplete
3. On each keystroke, evaluate if the list of auto-popped-up completions to see if the one you want is quickly available yet.
Clearly the 3rd is slowest to interact with, and does not convey useful information for familiar interfaces.
If you do not know or cannot remember what the interface looks like, it might be a bit more useful, but gives you similar information as the 2nd above when you have little to autocomplete. But the 2nd option still leaves you in control of the coding flow instead of the system constantly interrupting you to ask you if it knows what you mean yet.
There's 3 different models that happen:
1. Type in the entire thing
2. Type in a unique portion and ask it to autocomplete
3. On each keystroke, evaluate if the list of auto-popped-up completions to see if the one you want is quickly available yet.
Clearly the 3rd is slowest to interact with, and does not convey useful information for familiar interfaces.
If you do not know or cannot remember what the interface looks like, it might be a bit more useful, but gives you similar information as the 2nd above when you have little to autocomplete. But the 2nd option still leaves you in control of the coding flow instead of the system constantly interrupting you to ask you if it knows what you mean yet.
I genuinely cannot tell if this is supposed to be satire or not.
Not satire, just hacker news.
As a sidenote: Did you know about Poe's law? :)
https://en.wikipedia.org/wiki/Poe%27s_law
https://en.wikipedia.org/wiki/Poe%27s_law
> I can totally imagine that for a beginner developer it can make the difference... I believe in writing every character of my code and testing it thoroughly, I wrote many bug free codebases with it, that's my experience.
I'm entirely split between vigorous agreement and shaking my head.
At some point I just lost interest in committing various interfaces to working memory. The more trivial the more virulent my disinterest. Web stuff, especially front end? Unless it's crucial UX for something Very Important, it's just not worth the effort. Bring on the program synthesizers, even if they're limited to tab completing. I would literally rather memorize gibberish. If I wanted to memorize things I don't actually need to, I would've gone to med school.
At the same time, for code that actually matters and requires deep thought, I type every character and think about each one a lot.
Hopefully at some point program synthesis will be good enough that we don't have to make this choice. In the meantime, pretty much everyone doing something other than code-for-the-sake-of-code is writing some software where understanding every character really matters and some software that just needs to do the dumb thing right more than half the time to be worth it.
> It automatically formats your code, so the codebase doesn't resemble the one in your head anymore.
Same thing. One the one hand, your coworkers are not your psychologists. On the other hand, who is going to explain the code if you can't? And again, the resolution is: does this code being correct really matter?
I'm entirely split between vigorous agreement and shaking my head.
At some point I just lost interest in committing various interfaces to working memory. The more trivial the more virulent my disinterest. Web stuff, especially front end? Unless it's crucial UX for something Very Important, it's just not worth the effort. Bring on the program synthesizers, even if they're limited to tab completing. I would literally rather memorize gibberish. If I wanted to memorize things I don't actually need to, I would've gone to med school.
At the same time, for code that actually matters and requires deep thought, I type every character and think about each one a lot.
Hopefully at some point program synthesis will be good enough that we don't have to make this choice. In the meantime, pretty much everyone doing something other than code-for-the-sake-of-code is writing some software where understanding every character really matters and some software that just needs to do the dumb thing right more than half the time to be worth it.
> It automatically formats your code, so the codebase doesn't resemble the one in your head anymore.
Same thing. One the one hand, your coworkers are not your psychologists. On the other hand, who is going to explain the code if you can't? And again, the resolution is: does this code being correct really matter?
I had the same reaction as you, for the same reasons. That said, I'm a bit more skeptical about the proliferation of automated code formatters run e.g. as pre-commit hooks. A project-wide consistent formatting style is the right thing to have in 90% of the cases, but neither the style guides nor the tools enforcing them are perfect. There are situations where a particular piece of code will suffer a readability penalty if formatted in a standard way. For those situations, the formatter must have a way to locally disable it.
> You shouldn't need intellisense to see that a property doesn't exist in an object.
I think, this is simply not possible nowadays in any professional environment, involving multiple players.
There are way too many frameworks within which you have to find your way relatively quickly and nevertheless often only for a short time. Many with idiosyncrasies, sub-par design, the wrong smell or simply not satisfying the own taste one way or another.
With C++ almost my first language, I was using Qt for many years. It was almost the only framework fitting expectations more or less intuitively the whole time (at this moment, PyTorch fits a similar spot). This specific example hasn't to be true for everyone, of course. But there are always things on the other hand of the spectrum, for which I immediately forget syntactical peculiarities again and again. There seems some inner resistance, accelerating this for some software artefacts. I have seen this this seemingly feeble aesthetic point with many - often very good - programmers, maintaining a strong inner image of the software they are responsible for.
I think, this is simply not possible nowadays in any professional environment, involving multiple players.
There are way too many frameworks within which you have to find your way relatively quickly and nevertheless often only for a short time. Many with idiosyncrasies, sub-par design, the wrong smell or simply not satisfying the own taste one way or another.
With C++ almost my first language, I was using Qt for many years. It was almost the only framework fitting expectations more or less intuitively the whole time (at this moment, PyTorch fits a similar spot). This specific example hasn't to be true for everyone, of course. But there are always things on the other hand of the spectrum, for which I immediately forget syntactical peculiarities again and again. There seems some inner resistance, accelerating this for some software artefacts. I have seen this this seemingly feeble aesthetic point with many - often very good - programmers, maintaining a strong inner image of the software they are responsible for.
> You shouldn't need intellisense to see that a property doesn't exist in an object.
I use code completion for exploratory programming all the time. Questions like "can I convert this to a string" become easy. My coding is much more fluid because of it - it's a dialog with an assistant - "help me with telling what you can do" - rather than me writing overly specific orders to a machine.
I use code completion for exploratory programming all the time. Questions like "can I convert this to a string" become easy. My coding is much more fluid because of it - it's a dialog with an assistant - "help me with telling what you can do" - rather than me writing overly specific orders to a machine.
I think if I want to solve a problem, intellisense already became a requirement for me, since it does increase speed and I would say that this helps "fluidity".
I see some other side effects though and that regards labeling. I spend much less time on thinking about fitting ones since they would be auto-completed on later use anyway. If I don't have intellisense available I spend more time on thinking about names just because I need to remember them. That makes the code much more readable in some cases.
Exploring APIs can be much more enjoyable if you have it and there is no thorough documentation available on the other hand.
Still, some projects have a lot of constants and variables, so in that case it really helps.
I see some other side effects though and that regards labeling. I spend much less time on thinking about fitting ones since they would be auto-completed on later use anyway. If I don't have intellisense available I spend more time on thinking about names just because I need to remember them. That makes the code much more readable in some cases.
Exploring APIs can be much more enjoyable if you have it and there is no thorough documentation available on the other hand.
Still, some projects have a lot of constants and variables, so in that case it really helps.
> You need Typescript, otherwise you might make a mistake with types? Never had that problem in the past
Project size metrics needed.
Project size metrics needed.
> Code should live in your head. You shouldn't need intellisense to see that a property doesn't exist in an object.
That may be well and good for you, but not everyone's brain works like that. My brain is more GPU than CPU: I don't deal well with holding lots of disparate pieces of information in working memory, but I can quickly look at a problem and see many solutions as routes of data through black boxes, and determine what pipes need to plumb to where.
Why should I waste time and neural cycles on code "living" (e.g. interpreting state) in my head, when I have a perfectly good "head" for it right in front of me? Types? Linter? Formatting? That's wasted focus that could be going towards cybernetics, architecture, API ergonomics, and performance.
Before IDEs, I had a tight loop of write code, run it in repl, squash bugs, repeat. Productivity skyrocketed once I started using Spyder/codeblocks, then once again in Pycharm/Clion, and then once again when I started using type hints in python. I just started using TabNine and it's like finally I feel like my code can keep up with my brain.
Www.tabnine.com
That may be well and good for you, but not everyone's brain works like that. My brain is more GPU than CPU: I don't deal well with holding lots of disparate pieces of information in working memory, but I can quickly look at a problem and see many solutions as routes of data through black boxes, and determine what pipes need to plumb to where.
Why should I waste time and neural cycles on code "living" (e.g. interpreting state) in my head, when I have a perfectly good "head" for it right in front of me? Types? Linter? Formatting? That's wasted focus that could be going towards cybernetics, architecture, API ergonomics, and performance.
Before IDEs, I had a tight loop of write code, run it in repl, squash bugs, repeat. Productivity skyrocketed once I started using Spyder/codeblocks, then once again in Pycharm/Clion, and then once again when I started using type hints in python. I just started using TabNine and it's like finally I feel like my code can keep up with my brain.
Www.tabnine.com
> Even if it can gain you a little speed increase, it still is better to write things down for your 'codebase memory'.
> [...] You need Typescript, otherwise you might make a mistake with types?
You can use your 'codebase memory' instead.
> [...] You need Typescript, otherwise you might make a mistake with types?
You can use your 'codebase memory' instead.
Intellisense allows me to write code without having to check definitions of types that I'm using.
e.g I'm using type<Person> and I can just check list of its properties at current place instead of having to go to the definition
same with liberaries, despite that it may not be the smartest thing to do (you should check docs) it works fine very often
e.g I'm using type<Person> and I can just check list of its properties at current place instead of having to go to the definition
same with liberaries, despite that it may not be the smartest thing to do (you should check docs) it works fine very often
>I wrote many bug free codebases with it, that's my experience.
Prove it. You seem to be claiming to be qualitatively superior to most developers, since most developers use an IDE or tool of some sort, so let's see an example of this nontrivial bug free code you've written.
Prove it. You seem to be claiming to be qualitatively superior to most developers, since most developers use an IDE or tool of some sort, so let's see an example of this nontrivial bug free code you've written.
That's as easy to prove as that there isn't an invisible, indetectable pink unicorn standing right behind you as you read this.
I'm as confident that there isn't an invisible, indetectable pink unicorn standing behind me as I am that someone has written multiple complex and bug-free applications working only from their memory of a language and codebase. Not even Don Knuth is that much of a savant.
At the very least, the quality of such code should be self-evident and instructive.
At the very least, the quality of such code should be self-evident and instructive.
As you gain more experience in software development, you'll look back at this post and laugh.
You must work on really simple projects
Charles wrote probably one of the best explain-the-computer-to-grandma books ever:
https://en.wikipedia.org/wiki/Code:_The_Hidden_Language_of_C...
https://en.wikipedia.org/wiki/Code:_The_Hidden_Language_of_C...
One reason it's so good is that while it would (I think) work for the stereotypical grandma or curious youngster, it's also really interesting for readers who aren't complete novices. It assumes no pre-existing knowledge, and it starts quite slowly, but by the end I reckon anyone who isn't a CS grad will have deepened or solidified their understanding.
[deleted]
Petzold's books on Windows GUI programming were pretty much the Bibles if you wanted to understand how stuff worked under the covers of Visual Studio's designers/codegen.
Great author from the perspective of someone how needs to know the innards, not just churn out code.
Great author from the perspective of someone how needs to know the innards, not just churn out code.
His book "Code" is an amazing exploration of how computers work. One of the best books I've ever read.
Seconded. He did an amazing job of combining accessibility and depth. The book opens with, iirc, the scenario of two neighbouring kids who want to communicate with each other from a distance -- how can they encode and transmit their messages? And it builds gradually and logically from there to an explanation of how the incredibly complex behaviour of computers can arise from truly simple building blocks.
(Another approach to the same topic, and also excellent, is Nisan and Shocken's The Elements of Computing Systems. That was the first one to properly demystify computers for me -- until then, they were basically magic. I imagine Code would have done the same if I'd read it first.)
(Another approach to the same topic, and also excellent, is Nisan and Shocken's The Elements of Computing Systems. That was the first one to properly demystify computers for me -- until then, they were basically magic. I imagine Code would have done the same if I'd read it first.)
> I don’t know what rule you go by, but for me it’s always been simple: “Three or more: Use a for.” This is why we have loops. This is why we are programmers
Walking away from stage, he probably thought “I should have said, ‘programmers count 1, 2, 3, for’”
Walking away from stage, he probably thought “I should have said, ‘programmers count 1, 2, 3, for’”
L'esprit d'escalier by proxy, 15 years after the fact... I like it :)
I think the thing with this article is that it was right, but also that Microsoft finally accepted it was right. There’s no fixing WinForms, but more modern Microsoft technologies no longer work “designer first”. My VS plus Resharper can happily be used to develop from top-down or middle-out.
Basically, VS didn’t make programmers dumber, but it definitely made their code worse. And Microsoft eventually started paying attention to the people who were telling them that (probably because some of them were also saying they were switching to Java).
And no, I’m not smarter in environments where I don’t have IntelliSense. I just have more tabs open.
Basically, VS didn’t make programmers dumber, but it definitely made their code worse. And Microsoft eventually started paying attention to the people who were telling them that (probably because some of them were also saying they were switching to Java).
And no, I’m not smarter in environments where I don’t have IntelliSense. I just have more tabs open.
This kind of mind rotting is everywhere - lists for a few shopping items, using GPS for a simple route you should be able to remember after looking at a map, reminders for important dates, using a calculator for a simple sum.
I'm sure humanities over reliance on mental aids will increase Alzheimers like mental deficiencies as we age.
I'm sure humanities over reliance on mental aids will increase Alzheimers like mental deficiencies as we age.
Or we could, you know, use those spare brain cells to do higher level things, as the high level beings we're supposed to be. I don't know how to knit my own clothes but I doubt that has a major impact on the onset of Alzheimer's :-)
Until the Butlerian Jihad my friend
Whats the Butlerian Jihad?
It was an event in the Dune timeline where humans overthrew their machine overlords and vowed to never build machines in the lines of the human mind and never become dependent on machines or mechanical thinking again.
On my side I refuse to work if auto complete doea not work in a SQL editor. Am I supposed to remember every column? Of course his focus was on languages like C++ but I still think Intellisense is indeed the best thing for coding productivity. However coding is different from programming so that's a different story.
> However coding is different from programming so that's a different story.
Exactly this, coding is just typing. I've already solved the problem and now I need to write the code to implement it. At that point I want all the help / typing assistance I can get.
Exactly this, coding is just typing. I've already solved the problem and now I need to write the code to implement it. At that point I want all the help / typing assistance I can get.
A thread from 2008: https://news.ycombinator.com/item?id=387495
This was prescient back then. Because the Visual Studio mindset was all about patterns and conforming to patterns, the IDE behaved as though you were only a patterns-based programmer. It wants to force you to follow _their_ patterns. And in that, the VS juggernaut of code-generation has enlarged so colossally that you need only start a new REST API project to see the mind-numbing amounts of DTO objects and code required for layer after layer of interfaces/controllers etc for a single dataset.
If a single dataset from a single table in your SQL Server database requires so much code, isn't it time we rethought the _concept_ behind the _need_ for code-generation - especially in the IDE?
If a single dataset from a single table in your SQL Server database requires so much code, isn't it time we rethought the _concept_ behind the _need_ for code-generation - especially in the IDE?
> But Avalon is currently missing some amenities we take for granted, such as standard File Open, File Close, and Font dialogs, a split panel, and it has nothing approaching the new and totally astonishing DataGridView control in Windows Forms 2.0.
15 years later we still don't have a decent directory chooser, no DataGridView and a nice default theme.
If you these things (and more), you have to buy a set of components from a third party that costs about $1000, which is not possible in my company.
15 years later we still don't have a decent directory chooser, no DataGridView and a nice default theme.
If you these things (and more), you have to buy a set of components from a third party that costs about $1000, which is not possible in my company.
I started on Vim, then moved to Spacemacs, then Emacs with Vim bindings, now on VScode with Vim bindings... honestly, a good IDE does a lot of things for developer productivity.
We have to remember that, while we are defined by our tools, we are all still building the same thing: code. What your employer/boss/client cares about is /what/ code you produce and what business value it generates. They don't really care about /how/ you do it.
We have to remember that, while we are defined by our tools, we are all still building the same thing: code. What your employer/boss/client cares about is /what/ code you produce and what business value it generates. They don't really care about /how/ you do it.
I eventually moved away from vscode vim to nvim + lsp because the bindings weren’t good enough.
Small things added up enough to just jar me enough that it wasn’t worth it. Maybe I’ll jump in there again when I need to refactor something in a big way but for me nvim+plugins are where it’s at.
Small things added up enough to just jar me enough that it wasn’t worth it. Maybe I’ll jump in there again when I need to refactor something in a big way but for me nvim+plugins are where it’s at.
Why not just use vim with a proper setup? If you are proficient with the bindings and modal workflow, I don't really see a reason to use those bloated alternatives that not even run in the terminal...
Everytime i try something else i wander eventually back to my little vim setup :-)q
I've also noticed how intellisense affects design. It dictates bottum-up design and shapes your thoughts. You don't memorize what's in your classes anymore but get lazy and press . and scroll through the properties.
New vs versions allow to disable the auto popup and allow to only display intellisense when called through C-Space. I've been using that and found that it improved my reasoning.
New vs versions allow to disable the auto popup and allow to only display intellisense when called through C-Space. I've been using that and found that it improved my reasoning.
Well it's been 15 years, so any instances of brain rot should have surfaced by now.
[deleted]
IDEs are not going away. The next generation programming languages will have to be IDE-first. The syntax would have to be designed specifically to be amenable to autocompletion by ML language models.
One day code will not even be authored in a text format. It will be a binary format that is manipulated by some kind of visual graph editor. Who knows what it will look like. With brain-computer interfaces you may not even be typing or using your hands anymore.
Don't get married to plain text.
One day code will not even be authored in a text format. It will be a binary format that is manipulated by some kind of visual graph editor. Who knows what it will look like. With brain-computer interfaces you may not even be typing or using your hands anymore.
Don't get married to plain text.
code is written once, modified 10 times, and read 100 times
coding productivity is absolutely not about how fast you type the text into the computer
it is very much about how readable the code is though, and ide fancy autocompletion aren't helping with that
text has proven for millenias to be an effective way to represent ideas, so do get married to it
coding productivity is absolutely not about how fast you type the text into the computer
it is very much about how readable the code is though, and ide fancy autocompletion aren't helping with that
text has proven for millenias to be an effective way to represent ideas, so do get married to it
Sounds like a guy who would really hate Smalltalk :D
A wonderful read. I love how he basically mocks the product everybody in the room is using. "While I’m on the subject of variable names, I should say something good about Visual Studio." - that's basically the only time where he says something good about it.
For the record, my mobile phone has made me significantly happier and more satisfied. Ironically, maybe the main factor is that I go outside more. (Because I can no longer get lost, and because I can listen to music when I get bored.)
Does the flying shuttle decrease your fitness?
Possibly, but look where it (and all the inventions that were triggered by its creation) got us...
Possibly, but look where it (and all the inventions that were triggered by its creation) got us...
Write lots of OOPs so editors can parse it and give it back to you so you can write more OOP.
Can someone explain the concept of mindrot?
it's like trying to navigate around town after you've turned the GPS off.
I like it, just wish it were faster.
> And I sincerely hope that in five or ten years from now, we’re not still watching reruns of Friends.
I have bad news for Charles.
I have bad news for Charles.
I think to me the allure of Friends is not only that it's good and that we didn't get anything better in the meantime. It's also almost like Star Trek. It's Sci-Fi now.
There is technology which is distinctly modern, yet a bit different to our own, people mostly get along, there's no 1984 world actually implemented (FB, Google, China), there's effectively no post 9/11 world and the shine and optimism of the 80s and the naivete of the 90s was still around. Everything was pretty neat. The 0.01% were still mostly in hiding.
It's also of course nostalgia but it's not just nostalgia .
There is technology which is distinctly modern, yet a bit different to our own, people mostly get along, there's no 1984 world actually implemented (FB, Google, China), there's effectively no post 9/11 world and the shine and optimism of the 80s and the naivete of the 90s was still around. Everything was pretty neat. The 0.01% were still mostly in hiding.
It's also of course nostalgia but it's not just nostalgia .
Your mamma told you there'd be days like these.
What does he have against Friends?
It's pretty cheap and simple entertainment, but I think it accidentally proved to be greater than we could know then. See my previous comment.
crelex(1)
Short answer: Yes
Long answer: No
Long answer: No
Intermediate answer: maybe, if you use Visual Studio to maintain a framework.
I guess the classic "Why I Hate Framewoks" rant was Benji Smith and not Joel Spolsky?
https://medium.com/@johnfliu/why-i-hate-frameworks-6af8cbadb...
I guess the classic "Why I Hate Framewoks" rant was Benji Smith and not Joel Spolsky?
https://medium.com/@johnfliu/why-i-hate-frameworks-6af8cbadb...
Maybe I'm spoiled by Resharper and similar, but I feel like this statement is wrong now, given the buttons for "generate property", "generate class", "generate method", etc. I often just start using a variable and then click generate to make it exist.
Especially in the C++ world where it means editing a header file, rewriting the type, duplicating the function prototype, etc this is a big time saver.