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 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.
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.
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.)
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 .
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.
> 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.
> In order to get IntelliSense to work correctly, bottom-up programming is best. IntelliSense wants every class, every method, every property, every field, every method parameter, every local variable properly defined before you refer to it. If that’s not the case, then IntelliSense will try to correct what you’re typing by using something that has been defined, and which is probably just plain wrong.
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.
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
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.
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.
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.
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.
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.
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.)
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.
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.)
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.
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.
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.
> 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.
> 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’”
"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.
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!
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.
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.
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.
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.)
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.
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...
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
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?
> 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.
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.
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.
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
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.
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.
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 :-)
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.
121 comments
[ 2.9 ms ] story [ 177 ms ] threadLong 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...
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.)
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 .
https://en.wikipedia.org/wiki/Code:_The_Hidden_Language_of_C...
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.
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.
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.
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.
https://github.com/jacktasia/dumb-jump
(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
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.
Walking away from stage, he probably thought “I should have said, ‘programmers count 1, 2, 3, for’”
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.
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.
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.
I'm sure humanities over reliance on mental aids will increase Alzheimers like mental deficiencies as we age.
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.