What are your IDE superpowers? Tips that make you a better developer?

I use Pycharm/Jetbrains IDE's.

The most valuable tip for any IDE is to thoroughly learn source code navigation. For example putting the cursor on a function and hitting control B (I think, it's programming into my finger memory so I don't know that actual keys) jumps to function declaration - much easier than searching for function definitions. https://www.jetbrains.com/help/pycharm/navigating-through-th...

There's alot of value in learning how to move functions and methods via the refactoring tools. Someone else in this thread mentioned the value of learning the refactoring tools.

In Pycharm, go to the trouble to make sure the IDE has the correct Python interpreter and environment configured. Pycharm has good tools for managing venv's too - worth learning.

In Pycharm/Jetbrains IDE's the database tools are extremely good - worth learning.

In general it's worth spending several hours watching YouTube videos on whatever your favorite IDE is.

Another super valuable tip is this - if you send alot of time programming, it's easily worth it to spend hard cash on a top class IDE. Of course there's lots of great free IDE's - depends on your preferences - but for me spending a few hundred $ on Jetbrains is nothing compared to the productivity value I get out of it.

Once I realized that vim can be used to process data from stdin and output it to stdout for another program...it changed the way I use unix environments forever.

Every time I am too lazy to cut or awk for a one-time bash script, I just use vim's visual mode.

Need a quick list of things to do or write a bash script to get shit done? "ls -l | vim -" is your friend.

Need to be more efficient in processing git bisects, patches or merges? Use a git alias for vimdiff.

The IntelliJ / RubyMine / PyCharm Local History feature is amazing!

You can time-travel any folder or file in a project to the way it looked each time it was saved/changed and pick changes or whole files out from the historical entries.

Right-click on a file or folder in the project explorer and choose Local History->Show History. I have been shocked when other devs didn't know about it, so maybe this will help someone.

Learn refactoring tools for IDEs for your language. I can't believe how many things developers on my team still do by hand that are totally automated with 1 button press... Renaming things, extracting code into functions, organising stuff ...

Another great one: Fuzzy finders for files and even code symbols.

1. Paying for jet brains everything pack. It's really nice to keep the ide mostly consistent across languages

2. Double shift for Search all (actions, classes, functions, etc)

3. Learn a bit of regex for more complex file searches

4. Actually learn the debugger features beyond just breakpoint

Also +1 for refactoring tools, that's one of my next ide learning adventures

Many things in Vim can be a super power if you build the muscle memory.

I find di/yi (delete/yank inside) to be one of the most powerful.

  ls | entr make

Or any variation thereof. I.e. auto compile and run on file changes

A variation (swapping make for ninja/samu)

  find . -maxdepth 1 | entr sh -c "samu || lldb -c /tmp/core -b -o bt -o q"

VS Code: alt+arrow to move a line up/down

alt+shift+arrow to duplicate a line or block of text above or below

alt+ctrl+arrow for multi-cursor

ctrl+d for select next instance of a word

I have these baked into my muscle memory such that I had to physically type them it to remember what key combos they were! I feel completely naked without these combos in other editors.

I find that using very elaborate multi-word camel-case variable names is a huge help in avoiding errors in reasoning and in debugging. The compiler doesn't care. It doesn't effect the compiled code. It's painless and useful.

shameless plug for the church of emacs, but my productivity as a programmer has increased vastly from two things: org mode, which to those unaware, is kind of like a super powered literate programming system, and magit, an unrivaled git client. there are other things, eg consult, marginalia, vertico, orderless, etc. the ecosystem is rich, and dev is very active. also, if you are a common lisp programmer, there is no ide-like setup that comes close to slime/sly, in my opinion, for any language/ide pair

get really fast at using tmux

use a ton of tmux splits

zoom or break-pane to manage info overload

ripgrep/fd to find info fast

vim splits

vim macros can be useful but sometimes I get them wrong on my first try so it’s a tossup as to whether they’re always the choice over . (repeat)

vim bindings in everything that supports it

the key thing for writing software fast is getting guidance and feedback from your tooling without it distracting you or you having to choose to make it apparent; so a good type checker, good linter, good randomized unit tests, and a good Jupyter + Vim window split are killer

Inside a pair of argument parentheses and want to quickly select a specific argument or the whole lot between the parentheses? Try Jetbrains IDEs' Extend/Shrink Selection (Ctrl + W / Ctrl + Shift + W) feature.

You can also use it in other places and the IDE can evolve the selections smartly based on ASTs.

vscode is great for working on remote machines. i work across a few and theres almost no difference between working on a local vscode workspace and a remote one, as long as the connection is good. easy to set up, and theres no syncing or anything either like pycharm seemed to do. you work directly on the remote machine, same as ssh+vim through a terminal

and as a more general tip, that came as a result of coordinating between multiple dev/test/prod machines: use different workspace colour themes to quickly know where you are, and maybe change the default to something terrible.

my main dev machines stay nice and comfy to look at, test isnt too bad either but a very different colour. but prod uses my new default, a horrible bright red, making it impossible to forget im not in a designated safe space

`:x` to quit vim

`:q!` to quit without saving

I used Visual Studio for 20 years or so and came to rely on the wizards / automatic things that it provides for .NET development i.e. the right-click deploy container to AWS function that comes with the Visual Studio AWS toolkit is pretty good, but frustrating because you are limited in how the deployment occurs.

Turns out I was much more productive when I switched to mixing in a lot of CLI after I trialled VSCode.

Now, I think I would rather have a mix of a less capable IDE (i.e. a glorified editor) and rely more on CLI where it's appropriate. It's a more flexible approach and you get to understand what is going on under the hood, which means you have a better shot at scripting the more complicated bits of your build process.

vim’s text manipulation capabilities are overpowered. I can dump unstructured or poorly structured logs into a text file and format the key fields into a CSV in under a minute using no code. It’s like excel, grep, and sed rolled into one tool

I don't leave the shell, and set an alarm* for my next meeting and try to ignore everything else

I use `vert term` in vim to have side by side shell and editor within vim

I stay out of GUI windows when coding because I find them distracting, and its just too easy to switch to Slack which is just about the most focus destroying app in existence

* alarm code

    #!/bin/bash
    #./alarm.sh  

    to_seconds=$(( $1\*60 ))
    message=$2
    sleep $to_seconds

    while : 
    do
      afplay /System/Library/Sounds/Funk.aiff; say "MEETING"; echo $2
    done

Jetbrains IDES with sublime text keybindings.

Second small keyboard to single press buttons for macros instead of killing my hands with weird key combos.

Multiple cursors, fuzzy search, local (not git) history, find next occurrence keybind, go to start/end of method, go to next/prev compilation error keybind, scratch files, not having the IDE lock up for no reason, JS + type hints is extremely productive and flexible in webstorm, built in web server for test HTML files...

I also like to bind the prev/next error navigation to the up/down buttons on my mouse. This makes code navigation and refactoring a breeze.

Jetbrains IDES with sublime text keybindings.

Second small keyboard to single press buttons for macros instead of killing my hands with weird key combos.

Multiple cursors, fuzzy search, local (not git) history, find next occurrence keybind, go to start/end of method, go to next/prev compilation error keybind, scratch files, not having the IDE lock up for no reason, JS + type hints is extremely productive and flexible in webstorm, built in web server for test HTML files...

I pretty much use my IDE as a text editor with really fast search with default to case-sensitive regex on non-test source files. Navigating into definitions, back-forward through file visits. Cmd-E (JetBrains) to choose from recently opened files. That's about all. Oh and the IDE's resolve git conflicts.

Just started to use the Deployment feature to do 'local' dev on a VM with rsync-copy-on-file-change.

Switching the Keymap from JetBrains default to Eclipse is way more productive and intuitive to me.

And shortcuts like:

- shift shift - search everywhere

- alt + left / right - go back / forward

- alt + shift + r - refactor / rename

- alt + y / alt + shift y - (un)mark next occurrence (multicursor editing)

- alt + up / down - move current line

- alt + shift + x - run / run test

- alt + shift + d - debug / debug test

- ctrl/cmd + shift + up / down - extend current marked text

In day-to-day, ctrl-k, ctrl-shift-v, F1 and sessions in QtCreator. Also multi-line editing, apparently not everyone knows that ?

In PyCharm, as I flit from test to test, Ctrl-Shift-D runs whichever test or __main__ method I have my cursor in. Then Ctrl+D reruns the last one I ran. This is my core loop -- change, debug, test.

As I switch from running backend to frontend to npm start, I use Ctrl+Opt+D and R to pick which run configuration to launch.

Quickly write program, apply to current file / set of files. Optionally save the program for later if it might be useful again.

If your IDE can't do that or gets in the way of the quickly part, replace said IDE. Ideally the program is written in elisp but substitutes are available.

If you're doing TypeScript development, a good IDE lets you hover over code to see what their type is, or what the expected type is in case of an error - this is a huge superpower.

It took me longer than I care to admit to put 2+2 together to realize that VSCode probably had a strong set of extension based tooling usable in place of the az cli.

I hate myself.

Super basic, but I most often use Ctrl+Alt+G on highlighted text for global text search and Ctrl+Shft+R for filename search in Eclipse.

VS Code

auto hide terminal,cmd + J to open it

auto hide side bar (which is on the right), cmd + B to open it

turn off tabs, cmd + P to find files