What do you really get from IDE-driven development? | Hacker News Reader

What do you really get from IDE-driven development?

briandfoy.github.io

104 pointstbonesteaks139 comments

This is an argument against programming by autocomplete, not an argument against programming with IDEs. IDEs make this method of programming possible, but they don't make it mandatory. The primary thing I use autocomplete for is to insert method calls that I already know that I want. Secondarily I use it like a documentation browser to read the documentation for every function that I could call if I'm trying to figure out a better way to do something. If you program by just selecting functions at random without taking the time to figure out the problem you're solving and the easiest way to solve it with the tools at your disposal, eschewing the IDE will not save you.

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.

autocomplete is a memory multiplier.... it allows developers to be able to use vast/larger array of languages without having to remember every detail of the syntax.

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.

> This is an argument against programming by autocomplete, not an argument against programming with IDEs.

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?

There is an arrgument that the details matter a lot in code.

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.

> There is an arrgument that the details matter a lot in code.

The details of resulting code. Not the details of how exactly you wrote it.

Agreed. I don’t think programming with autocomplete is even a problem so much as learning to program with autocomplete is a problem. I think everyone should start out with a barebones text editor to get used to thinking things through and not relying on advanced IDE features as crutches.

I mostly agree. It's a little hard for me to remember how I started because I'm almost fully self-taught and I never restricted myself like that. I think it's best to start people off with a friendly and helpful but minimal environment. Scratch is good for younger kids and is what I started with, and DrRacket is close to ideal for anyone older than maybe 10.

I use Ocaml and the type system and language server basically remove the need for things like a debugger, or even run-time testing while developing, that you might need in some other language. It tells you type of every function, variable, etc. While it's not needed, the language server works in tandem with the type system to basically tell you exactly what's happening in your code.

Type systems are half of the equation, but what do you do when the algorithm is wrong? Type systems don't constrain you from writing incorrect solutions to the echo cancelation problem...you need real world data and runtime tooling for that. This is where IDE type tooling shines, nobody cares about the editor or the code in the end...

Yeah. Autocomplete is about the least useful function of an IDE. The real killer features IMHO are the automatic refactoring tools (method renaming, addition of function arguments, etc) and, in languages that support it, the continuous build that points out errors and warnings as you type them. Code navigation features (go to definition, find every place where this function is called, open file by class name...) are also huge time savers. Autocomplete has its uses but ultimately it's not such a big deal. 99% of the time I use it, I already know what I want to write, and I just use it when I don't remember exactly the order of some function arguments or something like that.

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 ADHD and have terrible memory for names. I'm not even using autocomplete that much, but the navigation in IDE really helps.... or hinders me from learning class/method names.

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.

I'm currently mentoring someone from scratch and they're using autocompletion a lot. Have mixed feelings about it to be honest. I'm not a big fan of tools like Copilot and it'll be really hard for someone to convince me of its value.

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.

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

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")`

Nitpick! You should always use the constant for the first part of an equality check so you won't get NPE if myobj is null: "string".equals(myobj);

There's a common argument from craftsmen embedded in here. When something decreases accessibility of something difficult, the people who already know how to do the difficult thing criticize it, because from their eyes, it brings the average quality down. But ease and accessibility always win.

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.

A more eloquent way of putting this: lowering a barrier to do X will result in lower average quality of X, but more of it. Usually this is good, and lower barriers win. Unless it's like lowering the barrier to becoming a surgeon or something where the risk is high.

Rust's Send/Sync made multithreading easier, teaches people to write proper multithreaded code, and results in more reliable programs with less data races and race conditions. Rust's dependency managers makes dependencies easier, teaches people to add dependencies and transitive dependencies, and results in programmers not understanding their own programs.

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

One thing I've learned over 10 years of doing this is how much code is actually required to do anything, having more expressive language is one thing but tools that can help me cram out this stuff are also appreciated.

One thing I've learned over more than 10 years of doing this is how much code actually should be deleted instead of fixed. Thanks for giving me a reliable source of income ;)

The joke is that a new programmer is happiest when adding code and the senior programmer is happiest when removing code.

It seems like the author understands, or perhaps his criteria is based on, only a thin layer of what an IDE can provide. Here's the highlights:

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

I think a lot of people's views have been influenced by their use of languages where the type system or overall language framework is either too weak (eg: Python, Javascript) or in some cases too complex (eg: C++) for more than a thin layer IDE experience to be possible. If you use those kind of languages then it's true, IDEs buy you a limited set of functionality and you don't need much more than a basic language server because that's about the limit of what you can get anyway.

Actually, modern IDEs are super helpful with JS and Python, especially with type hints.

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.

Completely agree.

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.

Also recommend this to learn a new code base which will log every function call:

https://www.npmjs.com/package/@phenomnomnominal/debug

The repo has zero documentation. Do you use it on client, node, or both? Does it renders the calls in a tree?

Oh you're right, sorry. Here's the blog post the dev wrote:

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.

I use PhpStorm by JetBrains and am totally blown away by how powerful it is. It does all of the GP’s list and way more.

Powerfull, but sloooow. I really want a faster Jetbrains IDE.

Yes, if the next release didn't have a single new feature and was just a bunch of "x is faster, y is faster" - I'd call that a great release!

They're working on a new, faster underlying architecture with an IDE called Fleet. It looks like it may be a long-term foundational replacement for their other IDEs including PhpStorm.

https://www.jetbrains.com/fleet/

Usually when people have speed problems with Jetbrains IDEs it's one of two things:

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.

Huh. Nr 2 is applicable to me. Will give it a try. Can’t see how it’ll fix my permanent indexing, but maybe it’ll at least feel faster.

My heap size is already at 3GB, which I feel should be enough for opening a bunch of 5kb text files :/

If you're permanently indexing something is very wrong and that will indeed break your IDE. That's just a bug. Try wiping all your caches from the menus and see if that helps. Otherwise file a bug in YouTrack.

I cut my teeth with IDEs from the 90s that did a great job with C++. The article author is just ignorant.

I agree; before I starting writing Swift, my only IDE experience was using Eclipse in college, and I really looked down on IDEs. I thought of them as a crutch required by poorly-designed and overly-verbose languages like Java.

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.

Even if an IDE is only a crutch for poorly designed languages, people still use those languages and an IDE is a useful tool in that scenario.

Indeed. My attitude is that people should use tools that work for them but without compromising on code quality, productivity, or impacting other team members with their tool choices.

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.

As a 30-year vi user who recently switched his C# programming to Rider over the summer of 2020, I'm a bit of an IDE convert now, for all of these kinds of reasons.

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

This is normal crotchety "kids these days" silliness. Most IntelliJ autocomplete suggestions are things like: * syntactic constructs (e.g. 'v' -> 'void', 'p' -> 'public'). * variable names you've already defined, or likely will define (e.g. 'MyFoo m' -> 'myFoo'). * methods names you've already defined or method names in commonly-used modules. The idea that the average programmer writing in an IDE is using functions that the IDE suggested, (but they have no idea what those functions do), is nonsensical. In addition to giving you (extremely rudimentary) autocomplete, IntelliJ gives you the ability to browse the libraries you've imported and read their doc. It gives you the ability to quickly see where variables were defined. It gives you the ability to conduct mass renames, move methods into new classes, and to conduct complicated syntax-aware search-and-replaces. It gives you an effective debugging GUI for tests, and allows you to inspect variables at will. I do believe that, as an IntelliJ programmer, I have lost my memory for certain language-specific details, (e.g. the fact that in Java, it is Collection::isEmpty vs. Collection::empty), but it's arguable whether these sorts of details are actually useful information for a working programmer.

The benefit of an IDE is integrating compiler/editor/debugger/test runner/linter/profiler/source control/etc

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.

I'm not sure I buy his argument. I see many programmers who produce inferior code with an IDE and many programmers who produce excellent code with an IDE. I'm in the Java ecosystem, where IDEs are pretty much ubiquitous. But I've used plain editors in the past mostly for other languages.

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.

his argument is pretty specific:

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.

Is the 8x meant to be scissors?

8<———————

Looks nicer.

Never seen it before. Good idea. Gonna use it from now on instead of quotes or > on every line!

yeah, it's a habit I picked up on usenet! useful for sites that manage quoted text awkwardly.

I usually format it this way. I like the scissors, though. Interesting.

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

Wow you just made me realise why they picked that symbol for usage in git commit messages...

It’s not mutually exclusive though right? For instance, google search has auto complete/recommendation to nearly any query. I use that when helpful and know when to ignore it as well and type in my entire query. (Genuinely curious as I don’t use these IDE features.)

no, not mutually exclusive, but the author had at least one anecdotal datapoint to suggest that people who relied on the IDE did not discover "unusual" functions that were better for the specific task

I did find that argument compelling. I'm not sure if I will yet abandon my IDE, but it's a check in that column.

I'm using an IDE, but I read the docs anyway. I also just jump into the implementation and figure if the docs are correct. I don't know why the IDE should prevent anyone to do that. Again, it doesn't depend so much on the tool but more on the type of programmer you are.

I actually ran up against this exact problem of IDEs being ubiquitous in the JVM ecosystem at a previous job.

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.

So full disclosure, I don't tend to write or read documentation that is external to the in-IDE documentation.

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.

Docs are typically built from source on modern platforms. There's not reason to restrict type information to a particular set of tools when you are bothering to build documentation. Otherwise might as well save your time.

I think it just depends on how many users your library expects. When there's a huge user base, proper documentation pays off.

Rather, how many users not using Eclipse or Idea you expect. And in the context of java, the answer is "few outliers".

I mean, they have been 100% right. There is no point in writing down parameters types, because you see them in the IDE. That sort of docs is completely redundant.

I'm in the Java ecosystem, where IDEs are pretty much ubiquitous.

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.

Try working with Kotlin. Much saner language then Java, way less verbose, but with equally good IDE support.

So you're thinking less of Java in general. I won't argue on that, because neither of us will change their mind.

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.

> I'm in the Java ecosystem, where IDEs are pretty much ubiquitous.

Isn't that because dealing with the complexity of many modern Java frameworks and surrounding tooling is pretty much impossible without an IDE?

Not impossible, but very inefficient.

This seems rather silly, doesn't it? A modern IDE like IntelliJ is going to be full of "golf" suggestions anyway, so I find it hard to believe that IDE-composed code is actually going to be more verbose!

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

> He’s a really good programmer, but that’s not why his solutions were better.

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.

Having spent a few years in Perl I understand some of the frustration of an IDE. I find dynamic languages don't gain a lot from an IDE. But if you're in something with stronger types like Java, typescript or F# the IDE is a God send. The best tool ever is refactor rename. When the IDE can parse your entire code base and rename just the function or variable you want it's amazing. Go to definition is worlds better too.

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.

Well, what's the old saying - nothing can parse Perl, but Perl?

As for JS and IDEs, you should try an IDE again. Far better.

Haha I've not heard that one. Perl is very much an unreadable code soup.

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.

> Perl is very much an unreadable code soup.

It has been said that perl is the only language which looks the same both before and after RSA encryption.

I use Intellij and it really does its level best to bring code insight to dynamic languages.

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

I learned programming before IDEs existed so I think I can join the author's crotchety old elitist club. As such I'm also a sceptic of anything AI-driven or crowdsourced.

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've always thought Lars Andersen's archery did a pretty good job making this point. https://youtu.be/BEG-ly9tQGk What will the crossbow wielding programmers of the future look like and who will be selling the crossbows?

I can't speak for Github CoPilot as I don't use it nor intend to ever use it but I find this article extremely unconvincing. He is basically considering an IDE as an autocomplete suggestion automaton. For me the features of an IDE that I use and value (fast code browsing both across my code and the code of my dependencies, refactoring support and taking care of mundane stuff like code formatting and import statements) have very little to do with autocomplete method suggestions.

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.

There's a sort of meta irony in computer programmers rejecting software assistance in conducting their trade, when a large fraction are actually focused on building software to do exactly that in one form or another.

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 use an IDE (Xcode). Works a treat.

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.

I noticed a trend that engineers think all engineering is just like their own job.

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.

The speed of loading an ide first thing, the speed within the and the memory hogging is the biggest reason against an ide.

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.

A single context to do everything. I don’t need to alt-tab away to run a CI job, browse the filesystem, run a shell, run my tests, etc etc its the same keyboard shortcuts, it eliminates the overhead of multiple contexts. I try to exploit features like “run tool” in my Ide so i never need to switch away.

Auto completion has always worked well as a way to discover methods, not as a way of writing code. It’s like…”so where can I go when I’m here?” without having to pour over a bunch of API docs. No one ever presses the “I’m feeling lucky button” on the auto complete suggestions unless it’s an API they recognize.

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

> Auto completion has always worked well as a way to discover methods

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.

Just from a visual efficiency measure, it’s a good steeping stone between discovery and actual docs, especially if the autocomplete also includes the first bit of description - most functions of an API are quite obvious, and ideally aren’t doing anything surprising in them anyways that the name + minidisc would actually lead you astray.

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

Auto completion also has the perverse effect of APIs developers relying on its existence to build large APIs that would be hard to use without autocomplete. I once counted 232 methods for a UI button in Java available through the auto complete menu. There is just no way to use that API by RTFMing, but with auto complete, you can just search for what you need as you need 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.

I use multiple languages every day. I can't be arsed to memorize whether the length of an array in this language was .length or .size or something else. And IDE helps me with that.

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.

Maybe it's limiting but in practice are you going to read up about the hundreds or thousands of symbols exported by every library you're using in a project? There's only so much time you can spend reading documentation (when it exists) or books.

All these anti-IDE rants strike me as coming from people who have never actually used an IDE beyond "oh it's an editor with an autocomplete".

They take pride in their masochism

It's called exercise. Plenty of people do a lot of physical exercise when they could be content to stay still, but it's good for health.

In this case, mental exercise keeps the brain healthy.

Time you spend fiddling with tools trying to replicate a tiny portion of what an IDE offers can be spent actually doing mental exercises to keep your brain healthy.

It's called working smart, not working hard.

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.

Definitely this. I was a long time Notepad++ fan but immediately changed tune soon as I tried VS Code.

To be fair, he's spent most of his time coding in Perl. Perl is notorious to parse.

> Mark Jason Dominus has an interesting perspective on Java, which he enjoyed: You will not produce anything really brilliant...

I'd argue that there's plenty of brilliant things written in Java. And Perl people sneering at Java feels a bit like defensiveness.

Why stop there, why not go back to punch cards. If there are tools that save time why not use them. We aren’t at University sitting exams anymore

When the main reason for you to use an IDE is to write code, you are missing out the most important part. An IDE helps you to reason about code, to navigate it, to read it, easily.

What you really get from IDE is higher productivity, based on a sample of few hundred people I've worked with. It won't make bad engineers good or vice versa, it would just make everyone more productive.

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.

Refactor functionalities in JetBrains tools probably saved tons of hours of incidents, typo bugs, copy and paste... only that makes IDE Driven Development as completely worthed it.

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

> He didn’t use a IDE, He didn’t get method name suggestions, code completion, and so on. His solutions were completely different, and they were smaller and faster.

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'm not sure why you're getting down-voted, but I want to ask about this.

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

I think the main point of the article, to question whether using an IDE actually improves our work, is valuable to at least ponder, if not just as a way to improve IDEs in future. As an aside, I don't think the author steal-manned his argument by using a few illustrative anecdotes, but he's not completely wrong, either.

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.

> Is it true that "90% of code is crud"? It is, if you want it to be.

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.

Kind of my main point, I just choose not to think of it as "crap", but as the best expression of the coder's intent given the all the constraints at the time it was written, including deadline pressure, context, experience. Try it out. Now instead of "wading through crap" you can think of it as "sifting for nuggets of wisdom". Or whatever you like.

Alright, I can accept that. We're mostly describing the same thing, and it's a question of focusing on the silver lining -- golden nuggets -- over the rest of the thing, which could be seen as crap or could be seen as the casing of a gold nugget.

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.

No. IDEs are a tool that makes programming more efficient. If you somehow fail at using that tool it's on you.

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

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.

And Mel is a great story, but it is also misses that engineering is about tradeoffs. And in many, many programs, space and time efficiency is actually way, way less important than maintainability, extensibility, etc. There will always be the cases where deep knowledge of the fundamentals of computers and computer science will make or break a program. But for a large part of most programs, premature optimization is still the root of all evil.

An IDE has lots of tools I need to use to get my work done efficiently.

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?

>We end up knowing less than we should and get less than we deserve.

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

Let's all just start writing code on a typewriter...

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.

> not fun

In the 90s IDEs were all the rage, from Turbo Pascal to Visual Basic - the pinnacle of usability IMO.

Peak IDE was Delphi 2 Professional, IMHO.

I feel like this is more of a commentary on dynamic vs statically typed languages under the guise of being about (a poor caricature of) IDEs. Autocomplete for dynamic typed languages has always been a really hard problem, but that’s less than 10% of what an IDE does for you.

I found the following interesting

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

I've been using IDEs since Turbo Pascal came out. Delphi 5 was the most productive thing I've ever used for building GUI programs.

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.

There's a lot here I resonate with. Ironically, I'm sort of headed in the opposite direction—I've been spending more effort experimenting with and working with tooling in VSCode to add autocomplete/docs/type hints/etc. for Ruby projects. My background is essentially IDE-free…for years I programmed Ruby and JavaScript using nothing but BBCode!

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.

On the theory level the article talks about I don’t really have a problem with IDEs Not always suggesting the sort of optimal solution so long as it reduces my cognitive load and gets the job done.

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.

Title is totally misleading. I use Rstudio, which is an IDE, and there's none of those "terrible" features in Copilet. Does it make my code terrible?

All these suggestions and options are total distractions to me trying to get work done. It impacts the ability to get work done. I go with the mantra if you’re trying to code your way to a solution then you’re going about it wrong. Write down what you’re trying to do in a few sentences first. If you can’t then how can you code something? This is why code structure suggestions make no sense to me.

Some schools out there encourage students to do as much as they can with the terminal (at least, for the first semester) and a simple text editor.

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.

This seems to be about autocomplete /github co-pilot rather than IDE's which is more of a plugin which I'm sure nearly every editor will get. I actually really like copilot, I've been using it for a while and it often ends up generating a lot of the code I need. It's not perfect, but definitely speeds things up a lot.

Just because you’re using an IDE doesn’t mean your should read the documentation, and know what’s available, what’s in the latest versions and what’s coming up. The IDE is just a tool to make typing faster wherever that’s through code completion or refactoring tools.

Reminds me somewhat of this old paper on the ironies of automation in factories:

https://ckrybus.com/static/papers/Bainbridge_1983_Automatica...

Automation makes people dumber.

I get a little bit of sanity when I sit down and realize that my colleagues have written this new system in raw fucking JavaScript. The IDE saves me a few hours each day by renaming and highlighting variables for me. Still lots of cussing and needless flow interruptions but it helps.

Out of all the world's grievances, people who choose something like hating IDEs to pedestal about will always amaze. Humanity is hilarious sometimes.

I’ve worked in this industry for 10 years . Without ides it would have taken another 10 years to do the things I’ve done with the help of IDEs

An understandable view of git branches and actions applicable to each

Shared understanding in sharing tools as well as language.

Accessibility. I type by voice and set up my editor to send autocomplete lists to my dictation software. Makes it sooo much easier than speaking the formatting and spelling random nonsense out loud.

> How much effort, in the non-mathematical sense, are you willing to expend to discover if there is a lower minimum? Go over the hill to your left and you discover a minimum that is greater than the one you were just in. Go over the hill to the right and you find a lower minimum.

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

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

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?

> So, if the IDE gives us those tools, what is the exact benefit of "going back and learning the hard way"?

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.

"Becoming a person of unlimited potential." that's a very prosaic way of essentially saying nothing.

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.

I want to improve & grow, get better at computing.

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.

We build on the shoulders of giants and there's nothing wrong with that. The terminal is just one abstraction down of an abstraction of an abstraction of an abstraction of an abstraction of an abstraction. Not very impressive.

Linux disagrees with you. A process is a core thing to the OS, not just "another abstraction". The terminal is an extremely shallow/direct interface to the OS, in a way distinctly more clear & certain than most other abstractions.

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.

Meh. If you want "infinite capabilities and unlimited potential" you should learn the best tool for each job. Not the one that works ok all the time.

I agree, but one has to know the fundamentals to begin to evaluate their tools.

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.

> Becoming a person of unlimited potential.

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?

> As is, really, the rest of your response.

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

I have studied computers from the ground up. At one point I could draw out most of the structure of a MIPS CPU. I have worked in Linux for years and think I know the shell very well. But none of that helps me deliver value to my employer. If an IDE or other high level tool can get the low level out of my way and get me more productive I'm much happier for it.

An IDE is a tool developed by developers ot make developing easier. (They may or may not succeed)

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.

Reply on news.ycombinator.com