What do you really get from IDE-driven development?(briandfoy.github.io) |
What do you really get from IDE-driven development?(briandfoy.github.io) |
What environment you want to work in is a personal almost intimate choice for a developer and requires trying and failing quit a few times. Through school and work most will be confronted with a variety of flavors.
But when is help/assistance too much help/assistance?
We could all be doing 100% of our programming in Notepad. That is pretty bare bones.
Someone developed vi and many found it made them a lot more productive thanks to the built-in features. (Of which people are still adding).
Emacs can do nearly anything (might be true of VIM, but I am more of an Emacs guy).
Sublime can be very helpful.
IntelliJ is huge and can be immensely helpful in its own way.
I started out before any of the big graphical IDEs we now think of were around. But Emacs was. (and VI). It was also before the net, so you needed books to learn and use as reference.
About 15 years ago I had an assignment at a facility were no internet was available for security reasons. (That is not 100% true but iterating over the finer details would take a lot of text).
It was weird to have stacks of books next to me again. I ended up enjoying it. I had a remember a lot more than
I had become accustomed to and my flow got better.
(Not having the opportunity to dash off to look up a detail really quick on the net).
I did not keep it up after I was assigned elsewhere. A really quick lookup on the net is an addictive thing.
This post reminded me of the story of Mel.
http://catb.org/jargon/html/story-of-mel.html
So Mel, not only did not use IDEs, he did not use compilers, or even an assembler because they got in his way of deep knowledge of the instruction set of the computer as well as the performance characteristics of the hardware he was programming.
Because of that, he was able to achieve program efficiency in both space and time that others could only dream of.
The "real programmers" don't do X, trope has been going of since before most of the people of this forum were even born.
This is just another manifestation of this trope.
Because there are so many tools it is not obvious which tools should I should use when and in which order. And it depends on the context. Should I search for a string globally or in the current file? Or current directory or project? Should I split the code-editor vertically or not, or should I split it horizontally.
What I'm fascinated by is how working with an IDE it feels like I'm constantly creating a program in my head for myself to execute, to use the tools and functions of the IDE in a given sequence. I am thinking ahead what tasks I need to do and then I do them, in other words I am writing a program in my head for myself to execute.
I wonder if people are doing this kind of thing generally, or think of it this way?
Speak for yourself.
When I program it's to get things done, I need to read a text file. Auto complete me a solution.
C# would be impossible without an IDE. Maybe you can write something in JavaScript, but any language with a large standard library is impossible sans IDE
I remember the 90s IDEs. They were not fun. But still better than nothing!
Thanks to Copilot, etc bad programmers can now get a lot further, and perhaps it would be good for them to struggle so that they can become better, but don't lay bad code at the feet of an IDE.
In the 90s IDEs were all the rage, from Turbo Pascal to Visual Basic - the pinnacle of usability IMO.
""" As a postscript, I’ve heard several stories about people who leave Google or Facebook and have a hard doing being productive at the next place. Both of those companies have planetary-scaled systems and the amazing tools to handle that. The next place doesn’t have those tools, and suddenly you have to know how to do things at much lower levels. If you never learned those levels, you are practically starting over and your previous experience isn’t that important. Their tools do their things, not general things, and certainly not someone else’s things. """
Python and languages that support lists, dictionaries, etc. natively have an advantage as far as expressivity. Generics and other support in Lazarus, the Delphi clone I use, lag far behind. However, for building GUI programs, it's still the best option for me.
Something even better for non-gui programs is IDLE, the python REPL... it lets you experiment with the data interactively, the make a program out of it, once you've figured out your algorithm, etc.
Better support of REPLs inside the IDE would be the way to go, I think.
I definitely think there's a sweet spot somewhere in the middle here, and industry trends are likely headed too far into IDE-plus-AI-all-the-things! territory. Over time, I think we'll come to understand the tradeoffs better.
Regarding copilot, I’d say it guesses the exact code I would write or code that is very similar to it over 50% of the time. My main complaint there is sometimes it oddly miss places a parentheses and sometimes it seems to block the code completion function of VS code. This is with typescript/jsx. Other than that which I assume is going to be fixed eventually copilots been a very pleasant experience for me.
The side effect is that there’s no IDE magic behind builds (it’s all plain makefiles and command line tools the students can run on their own). There’s no smart completion, so you have to go out and browse man pages or official documentation.
https://ckrybus.com/static/papers/Bainbridge_1983_Automatica...
Automation makes people dumber.
> This happens in just about anything you can imagine, but let’s consider IDEs. You start using an IDE and it makes one particular thing particularly easy, and it makes it so easy that you don’t go looking for something even easier. You can’t spend all of your time wondering if there’s a slightly better way of doing things.
This argument resonates fairly well with me. I generally view IDEs as low commitment, a rapid learning curve to completion, with very hard caps on what you are going to find. You'll understand what the tool gives you, and then you'll be done. There's some trading/collecting hooks to keep you feeling like you can improve, to collect all the best plugins to improve the base system, but you're still a consumer, hunting for solutions, and you never really gain intimacy, understanding, or general prowess, evaluating your gains from a position of general ignorance as to what you're really buying/using. Being an end-user is being stuck at some minimum, having milked the curve you're at, until someone else comes disrupts your world for you. You make no real gains on your own, develop no only superficial mastery, mastering of the pane-of-glass atop the environment you dwell in.
It's really really hard to make a stronger better pitch for the school of lifelong learning & struggle. Often IDEs are a great way to understand what is possible, what tools to expect, but once you have a baseline, getting back into the command line, the terminal, the console & re-learning the hard way how to re-enact many of the things your IDE does for you is really hard. The learning curve is super slow, it takes ages to get out of the bottom reaches & start to feel ok. But you're gaining mastery not just of the programming job, but of the operating system, of the shell, of the real genuine honest environment of computing. Your ability to understand & see what is happening is so much higher, has such a more real connection than the pane-of-glass interface. Your ability to evaluate & direct yourself grows & amplifies over time, only if you invest in yourself & think of yourself as someone seeking a truthful engagement.
In general, I feel like the world has a lot of "what is the use case"/"what is the business value" thinking, and there's kind of an aggressive anti-exploratory value system that hates geekiness, that hates learning, that despises the enrichment of humankind, that rejects possibility. To insist on fast immediate obvious worth is to miss the big picture, is toxic to healthy ecosystems & diversity's neandering, exploring many many many tentacles. I want to see a world culture that believes in honest, genuine interactions, not fancy indecypherable veneers of things. Papert's Constructivism/Constructionism is a spiritual boon, one essential to what humanity became, and we should cherish, protect, & grow this light. https://en.wikipedia.org/wiki/Constructionism_(learning_theo...
So, if the IDE gives us those tools, what is the exact benefit of "going back and learning the hard way"?
> To insist on fast immediate obvious worth is to miss the big picture, is toxic to healthy ecosystems & diversity's neandering
How much time do I have to spend in the good old hard learning command line to replicate, say, 5% of Intellij Idea's refactoring capabilities and code navigation?
Becoming a person of unlimited potential. Being capable of understanding & tackling anything, understanding the world you live in, not living like a marrionette shadow puppet your life.
> How much time do I have to spend in the good old hard learning command line to replicate, say, 5% of Intellij Idea's refactoring capabilities and code navigation?
Two afternoons learning CodeMod would provide a lifetime of infinite capabilities, versus some very limited preset scripts. You would be vastly vastly vastly greater, for a tiny amount of dickering around on your own.
It all depends on what you want out of the system that you're using, for me personally the programming language, the IDE, the library that I incorporate, are all a means to an end, the goal to bring a unique idea into reality. I value the creation of new ideas more than the implementation itself and thus your suggestion is unsuitable for those of my kind.
This idea of being good enough, embracing mediocre capabilities for life & only focusing on shirt term output forever is exactly the local minima this post is warning against. Selling yourself a compromised future, being a passive consumer of technology, is anathema to the greater objectives of life & computing, in my view.
Selling yourself on comprimise, swearing you have served yourself, also seems hollow when one is deliberately snubbing trying to raise themselves to a perch where they are capable of evaluating. The anti-elite pitch is easy because it doesnt even have to get good enough to assess the merits & values of the school of lifelong learning & struggles. As for your precious output, it might be totally different & better if you had opted to invest in yourself & see technology as less than a lever you know how to crank.
That's pure demagoguery. As is, really, the rest of your response.
> Two afternoons learning CodeMod would provide a lifetime of infinite capabilities
That's not the answer to the question. So, you've learned CodeMod scripts . How much timeyou will then have to spend to replicate 5% of IntelliJ's refactoring capabilities? And while you're struggling to replicate that, how many capabilities you're missing out on?
> So, you've learned CodeMod scripts . How much timeyou will then have to spend to replicate 5% of IntelliJ's refactoring capabilities?
I was assuming you'd get >50% of the IntelliJ's refactoring you might potentially use in those two afternoons.
And you can invent new ones whenever you feel like in a couple hours.
Your attitude is balls dude, personal & not informational. Chill out, step off, desist from being personally insulting in your rplies. You have no idea how easy it is to replace this precious valued thing you so adore. That's not a problem. But you're getting wrapped up about it & becoming uncivil. You simply don't know. Stop getting worse.
It's easy to just assume your tool works for you & it's the right pick, but precious few developers a) actually know computing well enough to assess the field of options, b) have any idea what they're buying.
It's heavyhanded bias that you've disregarded other options, and called whatever you think of as "best" and left everything else as "works ok all the time."
I see the small suite of built-ins as the "works ok", and not even "all of the time," just, for a couple small specific use cases. Learning about metaprogramming, ASTs, code-rewriting is a lifelong opportunity to get better, to understand what we really do when we write code at whole new levels, and those tools we truly, that truly fit the problems we actually have are the best tools.
There's no better way to see real truth in computing. The shell exposes the base truths of the OS abstraction directly: processes, environment variables, stdio, signals, pipes. This is the fundamental toolkit of computing, and what higher-level abstractions we see (from language's stdlibs, to things like Kafka or SQS queues) are better understood in terms of the base computing fundamentals. The base unix tools define a clear set of capabilities we should be familiar with, & to call them just another abstraction, to focus on our own local platforms, ignores the base root that all computing so far eminates from.
This abstraction-relativism you present is highly dangerous. Arguing we shouldn't care about anything because there are abstractions everywhere ignores a realer truth, that some abstractions have been around & underpin nearly all systems & likely will continue to do so. We're only barely starting to play around with alternative conceptions, in projects like Fuschia. But this is a rare, novel, & just-emerging break from our common frameworks of computing. One that would behoove people to gain some competency in.
I do plenty of programming without autocomplete as well and it doesn't bother me. But it's certainly nice to have, it reduces a lot of the friction of finding documentation and putting code on the page when you already know what you want.
EDIT: I'd like to add that the real speed comes when you have lots of keyboard commands ingrained in your muscle memory. There is a learning curve and it takes some time, but when you're comfortable with mapping certain very high level operations to a combination of 2 or 3 keys, the increase in speed is tremendous. The downside is that changing IDEs becomes a bit painful, so you built some kind of dependence. But this is not what the article is about.
I have a very wiered and convoluted style of search and navigation, all to avoid remembering names, people who see me coding are really stunded by the way I navigate code.
The upside is I do really well with new languages/projects, unless we are talking millions of lines of code and hundreds of modules, then I begin to struggle again.
As long as you know the concepts, autocomplete helps fills the details. This is especially useful if you are switching between multiple languages, from Java to Swift to Objective-C in one project. Autocomplete helps you keep productive and makes context switching much easier.
Exactly. IDEs fulfil an important function of removing repetitive and mundane tasks. The goal is to be you, the programmer, to know what you want to do and the tool, IDE, to make it happen as efficiently as possible.
That can happen through parsing code, showing documentation, showing references, alerting to obvious bugs, etc. But it can also be fulfilled by generating code (esp. in environments that like boilerplate) and possibly also by finding pieces of code to achieve the operation you need.
Sure, by using autocomplete constantly I may impair my memory same way that using Google Maps impairs my ability to drive without navigation. So what? I care that the task is completed and my mind is available to thinking about higher level problems rather than how to exactly search the code for references or locate the documentation.
Isn't the goal of software development actually building something rather than obsessing about the process?
i mostly am familiar with network side of things, but little stuff like how you handle connection timeouts or retries, for example, make a really big difference to the overall quality of the system. Not thinking about a network call each time is setting up a system that will randomly fail in avoidable ways (excessive retries keeping a system from recoverying; excessive buffering in the face of latency; unbounded memory queues causing failure propagatin; having best effort code handle connect failure quickly but not have good rear time outs, etc)
The higher level problems often emerge from the exact nature of the lower levels.
On one side, it's as you mentioned. If you randomly pick a "solution" and hope that it works, you won't understand why you use that specific solution. And sure enough, many times they'd use autocomplete and get a solution that doesn't really solve the problem.
One particular problem I remember was a type difference issue. They had a string and needed to compare it with a string in an object. Easy, just do something like myObj.myVar == "string" right? But autocomplete suggested myObj.equals("string") instead. This is java code. Then I had to explain why it didn't work as intended even though the code compiled.
But observing it more, I decided not to stop them from doing it for now. I think it can be useful for learning purposes especially at the start. It's not that great for understanding but it does help them familiarize with all the different syntax and possibilities.
At the end of the day, I don't think it's that much different from randomly copying solutions from stack overflow until one works.
Actually, you need to use `.equals()` for value equality on reference types in Java (like Strings). Using `==` will give you reference equality, which is almost never what you want. You probably wanted `myObj.myVar.equals("string")`
This goes for IDEs, programming languages, frameworks, etc. Think of a language like PHP, which made it so easy to code that countless shitty websites were made, ridden with spaghetti code and security issues. But, I was amongst probably tens of thousands of script kiddies who cut our teeth on PHP and eventually learned how to "properly" build web products. My first startup's MVP was a giant functions.php file and a bunch of templates, FTP'd onto a VPS. Probably wouldn't have gotten into it if instead I had needed to learn something like C++ or Java.
Yes, making something easier to do decreases the quality on average. But even skilled professionals can benefit from better accessibility. And it's hard to quantify the full benefit to those who wouldn't have been able to do the work without the lower barrier.
Personally, yes, I know if I blindly use Github Copilot I'll prob write some shitty code. But it just makes everything easier/faster to do. So I use it and put in a tiny bit of extra effort to make sure I'm not abusing it. And it's game-changing. I'm also sure tools like Copilot will improve at a pace that is much faster than people expect. It will recognize deprecated calls, misused calls, errors, security holes, etc.
- Data flow to/from here (where did the value of this variable come from/go to)
- Call hierarchy (up and down)
- Class hierarchy (up and down)
- Class structure (including all inherited fields, methods)
- Checking your code against an actual database schema, perhaps one automatically launched in a Docker container
- Automatic refactoring of various kinds (rename, extract variable, extract method, inline method, extract interface, add/remove parameters, etc.)
- Build tool dependency tree inspection with filtering etc.
- Inspect code for a huge variety of potential code quality issues, with highlighting and auto-resolutions available
- Locate duplicate code, and automatically refactor it out
- Detect likely problems with nullity
- Easily navigate to lines of code in an exception call stack
- Analyze dependencies across classes & packages, detect cyclical dependencies
- Debugging, including watch windows and conditional breakpoints of various kinds
- Helpful tools for a variety of programming frameworks such as Spring
- Integration with git so you can view history, diffs, etc.
- WYSIWYG style rendering for stuff like Markdown
- Easily navigate to any class, including classes that come from your dependencies (for example I've worked with plenty of people who had no idea how to figure out how Rails worked if it wasn't in the documentation, because they didn't use an IDE which allowed them to easily browse the code)
Personally, all of that is just a huge amount of value.
If these things somehow prevent you from writing code that is as good as it would be without these integrations then what on earth were you doing? Apart from the “copilot” like things (which almost no one uses and which is orthogonal to the concept of IDEs, any editor can have that) what is “IDE-driven development”? Taking the first autocomplete suggestion after typing a dot in Java? instead of what? Reading docs? It’s not like the IDE having autocompletion for valid method names is forcing your hand to blindly take the first one or the wrong one? This reads a bit like that rant against syntax highlighting making developers bad.
All in all, I don't see the link between using an IDE or not and the quality of the outcome. But I do see the link between using an IDE and development speed, where refactoring is just so much faster and less error prone if you have a decent IDE.
I haven't tried copilot yet, so can't say much about it.
In my experience CRs from non-IDE users were more likely to have issues like unused imports, weird formatting, unused variables, and so on, because their text editors won't yell at them over that (perhaps a linter should be set up to catch it but let's face it, few people have all the things they'd like to have in place).
I disagree, if he was forced to use IDE he would came up with the exact same solutions. People who disregard IDEs generally are good, and thy disregard helpful tools like IDE at least partially due to their arrogance. Also their supposed "simple editors" with various extensions are often very close to IDEs in term of functionality.
Author also seem to used perl for demonstration, which makes me not so certain he benefits from IDE all that much. The key benefits of IDE truly starts to open when you start using typed language. This shows especially clearly when you use python (in PyCharm for example) and start adding type annotation. Is a completly different experience.
You start getting:
- reliable autocomplete (as mentioned)
- reliable refactoring (this is big, because one of the major cry about python is that as it grows it gets hard to maintain)
- showing errors immediately without having to run the code
No matter how good you are all these things make you better.
Note: Above argument doesn't apply to github-copilot (which was used as a demo), it's probably no surprise that using that tool will get someone to arrive with same source code. Especially if it is a tutorial so many people before you typed similar thing as well.
I found, in Perl and JavaScript, these tools didn't work reliably enough so the IDE was just a slower tool.
Also reading the documentation is important regardless of the tool you're using. I don't think that's a true reflection of IDE development.
As for JS and IDEs, you should try an IDE again. Far better.
I will have to try on next time I'm in plain JS. It doesn't happen often. I have a preference for strongly typed languages. I suspect I have something similar to dyslexia. I mix the spelling of words and sometimes even the words. Strong typing is the tool that makes that problem go away.
On the other hand, I recently allowed Visual Studio to use whatever their version of AI autocomplete is called and holy smokes - it can read my mind!
Sure, you can complain about how things were better before the latest crop of tools allowed the unwashed masses to trample your domain but if you're smart you take advantage of the good parts while being aware of the bad ones.
I also find the workflow that author is describing where people blindly probe around until autocomplete suggests them a method that does what they want extremely unrealistic. Most developers will look up various libraries and options to accomplish a thing, indeed the only way you can get autocomplete to even work is if you kinda know what library/tooling you want to use.
For example if you want to use a b-tree for something the IDE can't read your mind, you're gonna have to go on the internet and see the options available in the language of your choice, weight them out, decide on one, add the library to dependency management file in your language and only then will the IDE be able to provide any help.
Do such people fundmentally believe software is incapable of helping people work with information oriented tasks better? In that case, how do they assess the actual value of their own work?
I'm also very effective, and very fast. I write fairly significant volumes of well-structured, well-documented code, in a pretty short period of time.
It seems work well, too.
I don't really give a hoot whether or not anyone else thinks I'm somehow "lesser," because I use an IDE.
DISCLAIMER: I started programming well into the last century, and have used CLIs that would have a lot of folks curled up, under their desks, whimpering. It's just that I’m not a touch typist, so couldn’t ever really get comfortable with CLIs.
The fact is that only few engineers can code in a single language to build the product they are working on.
Sure a kernel device driver dev can write 100k lines of C over a year and memorize every API.
But many product devs have to land code in 4-5 repos & languages. e.g. a bit of python, PHP, c++ & SQL just to complete one use-case.
For those in one language with narrow API dependencies, IDE may seem redundant. But if you are contributing code across multiple stacks & APIs, IDE is a life saver.
Lesson: Engineering is very diverse, and don't assume that tools that work great for you scale to other roles.
Others reasons matter: - It allows you to be lazier and never learn the actual method names instead remembering two or three characters - Switching editors could leave you lost. Sometimes you have to code in vim, notepad, gedit or a different ide. And without your ide could destory your mental workflow.
SublimeText fan.
I get the feeling that co-pilot wasn’t really designed with usability in mind, more like it was just a cool thing that could be done with a large code corpus and good machine learning techniques. If they could redo it as a mechanism for discovery somehow, it would be much more useful. But I’m not sure how to do that here, perhaps ranking completable methods based on a statistical likelihood that the user will want to use them (but then we start hitting Hick’s law where sorting by name is super important).
I think that was exactly the criticism in the article, though, that discovery via IDE is limiting, and for many developers this method of discovery supercedes actually reading documentation. I'm not sure he's wrong.
Of course, a stepping stone , at the end of the day you still need to understand the core model and operations — but then you’re just dealing with age-old problem of RTFM; a problem that has existed long before autocomplete’s general availability, and long after. The only real change autocomplete brings in that regard is that people might accidentally read something while scanning a manual for the API calls… but that’s really never been good enough anyways, so it’s not much of a loss
If myArray.l... doesn't autocomplete, I'll try with myArray.s... Compared to opening a browser and browsing through the language API docs it's exponentially faster.
In this case, mental exercise keeps the brain healthy.
I'd argue that there's plenty of brilliant things written in Java. And Perl people sneering at Java feels a bit like defensiveness.
If I were hiring an engineer who claimed not to use IDE on principle, I would be very careful and maybe even suspicious: a craftsman who doesn't care about using best tools for the job, may have problems.
Also, tools such as Tabnine take away the plumbing from coding - I am so much more focused on the high-level design and goal of what I am doing if I don't have to pass so much time trying to remember what I wanted to write...
I'm confused by this. I've used pretty much every major IDE and ignoring Github Copilot, I've never had one suggest code for me to write or suggest a method name. I've had them do things like find a typo in a method name , or alert me that I'm calculating a value twice when I could just re-use a variable. Stuff like that. But I don't understand how it could suggest a method name for me.
The only code completion IDEs give me are things that are rigidly fixed by the syntax of the language. If I start writing ' for (var i', it will automatically complete the for loop header and brackets. But it's never actually written code inside the loop.
I guess I've had Rider suggest ways to convert imperative code to LINQ, but that's only after writing the original code.
> "I've never had one suggest code for me to write or suggest a method name"
That's confusing to me. You mean if you were coding something in, say, JavaScript, and you typed `Math.` that never in your experience has any IDE popped up a list of methods, like `abs` or `random`, that you could down-arrow through and select by hitting enter?
Like, go here - https://www.typescriptlang.org/play - and type "Math" on line 1 and then type "."
That list of pop-ups is a completely novel experience for you?
My objection to the article is to the sentiment expressed:
> "But, a lot of code doesn’t matter because Sturgeon’s Law informs us that 90% of the code is crud. He was talking about science fiction, but it feels true of just about anything. All of that code learning is parroting the bad habits of the 90% crud."
I strive for empathy with my colleagues, and I have mostly* won the struggle against harshly judging the code that I read and maintain, and judging the people who wrote it. Judging code can be a terrible distraction that turns programming from a lovely, interesting and fun task into a grind.
Is it true that "90% of code is crud"? It is, if you want it to be. Or, perhaps we all as a community and a society are slowly learning how to program, and the best of the code written 5 years ago uses ways and means that we are abandoning. I think specifically of the movement away from Object Oriented programming toward immutability and Functional Programming, which is arguably an overall improvement. Also, the No Blame movement, which assumes that the engineer at the time is making a smart decision given all of the constraints. But we're not done, and the code of today will look quaint in 5, 10, 20 years.
It helps me to have "warrior mind", which I interpret to mean that completing a programming task is a mission, and I can feel upset about the circumstances, or I can put all of that aside and help complete the mission (or fail to complete the mission, which happens), without ego or drama.
So, I would say, "90% of code is crud" belies an attitude that would benefit from correction. All code contains a lesson.
You're being way too generous from a false sense of compassion. Most code is not written from a place of serene comprehension. It's written under the pressure of getting features out the door fast enough to justify a paycheck.
Add in that programming is a task that is rapidly changing over time -- so what's good today, is a naive implementation tomorrow...yeah, practically all code ever produced or ever to be produced will be crap from any reasonable perspective.
I think that building tools to teach better programming (eg. teaching memory-safe programming or safe languages, teaching patterns immune to SQL injection or parsing exploits) is a great thing. But given the choice between bad and no code, I feel that it's almost better for people to not complete projects, than to release code with serious functional errors (memory leaks and segfaults and dozens of runtime race conditions that each show up every month or so, requiring herculean effort to debug, or more often go unsolved and haunt users indefinitely) or security defects (eg. https://lukeplant.me.uk/blog/posts/wordpress-4.7.2-post-mort...).
It's obviously better to teach good coding than to discourage people doing bad coding, but it's a lot harder (Send/Sync was a non-obvious innovation, and Rust required immense effort to push to 1.0 and build an ecosystem) and I don't think I can do it. And I'm opposed to the principle of trading off your understanding of a program to get more functionality from leaky abstractions (complex languages, optimizing compilers, big library trees, and GPU drivers all leak, whereas out-of-order CPUs and cache hierarchies are a mostly non-leaky abstraction).
But the IDE experience with a language that has decent type system like Swift is really great. It truly just feels like a more efficient way to consume documentation and write code.
The analogy I would make is to texting on a numpad by repeatedly tapping a key vs. using T9 (assuming you’re in the right age range to have memories of texting on numpads). Sure, T9 might have guessed the wrong word a fraction of the time, but you never felt like it was dictating the direction of your thoughts or getting in your way.
This all depends on the programming language, the package/project scaffolding, and the IDE being tightly integrated and very thoughtfully designed, but when it works it’s a real pleasure. While I still believe that all languages should be ergonomical to write without IDEs, I definitely underrated the experience.
I can export a function or class in a big JS project, go to any file, start typing the method name, and Webstorm will suggest the import. With JavaScript!
Not as great as the Java integration but still pretty nice.
What really sold me on it is the ease of refactoring. Makes it easy to rearrange code and clarify names and things as you build the project up.
And then the code quality stuff taught me some things that I didn't know like the allocations that happen in C# with closures being passed to functions.
And then there's just the accuracy bits like greying out unreachable code which usually points out typos.
It also integrates well with the nullable checks in >C# 9.0
The IDE can teach you to be an expert and catch little gaps in your understanding of the language along making you a lot faster and doing a lot more in-editor, and letting you spend more mental effort on all the rest of software development.
Since C# is also object oriented, it also leads towards doing lots of boilerplate for interfaces and delegation which IDEs are pretty critical for (And I'd argue that Go's verbose error handling though also can benefit greatly from macros in an editor at least before anyone hops off this comment into an anti-OO rant).
The latter is a big caveat when working on Kotlin/Java code bases because standards are high regarding things like code formatting, style, etc. People will notice when you skip some of the things Intellij does. The few cases I've seen of people not using the right tools for the job, they thought they were doing a great job. And then I did a code review and showed them how bad it was because clearly they were blissfully unaware of warnings, had never run a static code analyzer, were clearly not refactoring their code base, and were generally doing a lot of things that were bordering on "probably wrong; definitely not optimal".
IDEs provide several big buckets of essential functionality:
- Code criticism: warnings, static analysis, deprecations, dead code, etc. You can use external tools to stay on top of this as well. But having mistakes pointed out to you as you are making them saves a lot of time. Also, since these are preventable problems, there is zero excuse for having any of them. So, whatever you use, make sure you stay on top of this. If this is tedious, consider using better tools or fixing the ones you have.
- Intelligence and situational awareness: Syntax coloring, code navigation & documentation, find uses of, etc. When stuff doesn't work, this is a real time saver. Bottom line here is that there are things that you need to know how to find out about your code. If you can script things together using grep and other command line tools; great. As long as you are productive. But you have no excuse for ignorance.
- Automatic program transformations: This goes way beyond refactoring (which is also useful of course and for which renames are merely the simplest example) and also includes things like using quick fixes for common problems, automatically applying replacements for deprecated functions, adding all the missing branches to a when statement, managing lists of imports, converting between different syntax alternatives for the same thing (e.g. convert between when and if, invert an if, ...), etc. For languages like Kotlin and Java, there are hundreds of these and they are super useful. I use them all the time. Use them or don't use them. But you should not allow your tool choices to impact your code quality. So, if it needs refactoring, do it. Do it manually if you must. But you don't get to skip it. Edit your imports like a caveman if you must, but make sure you do it properly (no wildcards, sorted correctly, remove unused imports, etc.).
- Tool integration: Build tools, debuggers, de-compilers, code formatters/linters, etc. Nice to have that at your finger tips. If you do this via the command line, be my guest. But make sure you know how to use your tools and that you do use the tools that are available to you.
On projects I manage, I'll judge people on their code quality, not on how they produce their code. But I'm a harsh judge when it comes to that. Do it whatever way pleases you but do it right. And with some editors, that just means performing a lot of manual labor.
The company had just released a new SDK to access a data repository. Since it was a brand new library, they only had Java/Scala versions, with plans to support other languages (JS, Python being the next two on their roadmap) in the few quarters. My team, primarily researchers who only knew Python, needed to use some of this data for a new project. I figured, what the hell, I've been looking for an excuse to learn some Scala, I'll see if I can throw together a utility for my team to use to get access to this data sooner. I fired up Sublime Text and opened up the docs for the SDK and got to work. The documentation was terrible and I really struggled to do basic tasks with this SDK. Simple things like what types were expected for function parameters was just non-existent. Since this SDK was planned to be released publicly to customers, I thought I'd do my co-workers a favour and sent them a message with some feedback about places where I particularly struggled with understanding how to use their SDK, thinking I could help improve the documentation before this went out to paying customers. Their response was that if I just used a proper IDE for my development, I wouldn't have these problems since the code completion/suggestions would let me know what the types of parameters were.
That experience completely soured me on the JVM ecosystem and I walked away from learning it. When I finally came back two years later, I discovered that I actually really like working in Scala (admittedly I do use Intellij for it now), but that many library's documentation is still quite poor compared to what I've come to expect for Python libraries.
But why is documenting the types helpful? The IDE, and for Java/JVM there's a choice of multiple, will tell you. Why waste precious hours of life rewriting what is already documented in the type system?
Sure I'd document the why of something but the idea types should have any form of documentation external to an IDE that can parse the language just seems... redundant.
Whenever I hop over the fence to dynamic languages sure I have to read documentation and large amounts of it is rubbish that could just be inferred from source but that's why I don't hop over there often.
8x--------------
He’s a really good programmer, but that’s not why his solutions were better. Since he didn’t have suggestions to guide him, he read the docs and by simply perusing them, was aware of methods and other features that the IDE did not suggest. There were better ways in the libraries they were using that weren’t apparent in the IDE. And that makes sense: in the interface for a suggestion in an editor, how much complexity can you really manage?
8x--------------
it makes sense to me - if the API is large and complex enough that you can discover good ways to do things via serendipity, IDE autosuggestions will stick you in a local maximum.
8<———————
Looks nicer.
Never seen it before. Good idea. Gonna use it from now on instead of quotes or > on every line!
All in all, I don't see the link between using an IDE or not and the quality of the outcome.
That seems to be a pretty good link to me already...
I worked (briefly, fortunately) with Java for a short while a long time ago. The fact that even "small" Java projects are often ridiculously overengineered and so complex that an IDE is almost obligatory to work with the code in any meaningful way should itself be a sign of what dependence on IDEs tends to cause. The article mentions that too, and my experience agrees.
But the author was basically saying that you can write better Java in an editor than if you were using an IDE. And this doesn't make sense to me. The code a skilled programmer will write with or without an IDE won't be that different.
But I fully agree wrt types. Even if I'm not using an IDE, types, or type hints a la Python, help me understand what's going on far better.
I once heavily refactored a hand-rolled build tool written entirely in Python that read and write JSON. Everyone was terrified of touching it.
Introducing Pydantic to replace dicts of dicts of dicts with dicts of App instances that had Environments immediately made the code far easier to understand.
Then introducing type annotations and mypy completed the transition of a business critical tool from one everyone previously approached in what I called a "special forces" manner (get in, achieve your very narrow goal, get out before anyone notices you) to something where code flow was easily understandable.
Immediately, the tool received a lot of attention and refactoring. Something like 20% of it was dead code, amd there was some functionality that, had it been used, would've corrupted the build state or just flat out died.
And it was simply adding types that made this obvious, and made the code accessible to people who wanted to refactor it fearlessly.
(Unit tests were entirely absent, but without the understanding of the code that types brought, how would you even start?)
It has been said that perl is the only language which looks the same both before and after RSA encryption.
I would absolutely fire someone who refused to use the mechanized tree harvester I provided and insisted on felling trees with an axe, and that's about where I stand with respect to insisting on using PDP-10 era text editors over an IDE.
The details of resulting code. Not the details of how exactly you wrote it.
Alot do the reason Java is the way it is is probably because auto completion gained in popularity at the same time it did.
Given that framing, what expectation can there be that an automated platform like CoPilot can acquire the wisdom to recognize gold from dirt? I believe it may be a question of does the overlapping, correlated portions of code from the corpus of repos signal the gold or signal the common dirt encasing the gold?
I largely expect it's the latter, and that the trends copilot is likely to recognize and use as foundations for its suggestions are motivated from dirt. To accept them and to learn from them is to internalize a horse without a cart philosophy.
> "He’s a really good programmer, but that’s not why his solutions were better. Since he didn’t have suggestions to guide him, he read the docs and by simply perusing them, was aware of methods and other features that the IDE did not suggest. There were better ways in the libraries they were using that weren’t apparent in the IDE. And that makes sense: in the interface for a suggestion in an editor, how much complexity can you really manage?"
I recently had to work on an unfamiliar JS codebase. After initially pulling my hair out trying to understand what objects were being passed where, I decided to define some types and parameters using JSDoc . VsCode picked them up instantly and it was like coding with a language server after that.
1. Heap size is too small and it's GCing a lot without the user realizing. Open IDE VM options and double the -Xmx setting.
2. Using a 4k display on macOS. Try the new JBR17+Metal builds. They aren't shipped yet but switch it to using Metal to render. Makes it a lot faster.
My heap size is already at 3GB, which I feel should be enough for opening a bunch of 5kb text files :/
https://dev.to/phenomnominal/lazy-debug-logging-for-node-js-...
The idea is it logs every function call. Nice for picking up a new code base.