Does Visual Studio Rot the Mind? (2005)
charlespetzold.com
charlespetzold.com
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.
if (object.nonexistant != null) ....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.
I just bind 'gd' and 'gr' to go to definitions and references, respectively, and I'm good to go in vim.
`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.
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.
(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.)
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 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.)
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.
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.
And they've only got one kitchen sink, not the triple commercial sink of features VS lugs along.
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.
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.
I don’t need an IDE to add another invocation of the method. I need an IDE when the signature has to change.
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.
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...
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.
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.
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!
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.
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.
Machine learning is older than you think.
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.
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.
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.
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.
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.
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'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 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.
Project size metrics needed.
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
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.
At the very least, the quality of such code should be self-evident and instructive.
> [...] You need Typescript, otherwise you might make a mistake with types?
You can use your 'codebase memory' instead.
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 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.
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
https://en.wikipedia.org/wiki/Code:_The_Hidden_Language_of_C...
Great author from the perspective of someone how needs to know the innards, not just churn out code.
(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.)
Walking away from stage, he probably thought “I should have said, ‘programmers count 1, 2, 3, for’”
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.
I'm sure humanities over reliance on mental aids will increase Alzheimers like mental deficiencies as we age.
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.
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?
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.
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.
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.
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.
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.
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
Possibly, but look where it (and all the inventions that were triggered by its creation) got us...
I have bad news for Charles.
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 .
Long answer: No
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...