Python in Visual Studio Code | Hacker News Reader

Python in Visual Studio Code

blogs.msdn.microsoft.com

340 pointsrbanffy195 comments

I've been using VI since the 90's and VIM since... well the 90's. VSCode is the first IDE I've been able to live, and happily. It blows my mind.

I have a tonne of tooling around automated python environments, vim plugins (now vscode plugins), tasks - and it's made the whole thing significantly more 'unixy' than it was before. And to think - MSFT!

I have git hooks for my homedir's dotfiles that automatically look to see if the plugin cache needs an update one way or the other - and runs my aliases (see below).

I have global tasks that now link into workspaces, pretty decent python, golang, and c++ support. I've mapped keys to the 'wierd' collection of things I do between terminator terminals, vim tabs, and whatnot... honestly, it's pretty good. It's not great, the things in 'vim' support are really 'vi'-light. I'd be much happier if vim support meant understanding my .vim hierarchy - but I'm happy.

# vscode bash bits alias vspluginsave="code --list-extensions | xargs -L 1 echo code --install-extension > .vscode.plugins" alias vspluginload="sh ~/.vscode.plugins" alias vspluginclean="rm -rf ~/.vscode/extensions"

Just out of curiosity, what are some of the tasks that you run in vscode ?

I've never found a real use for them, so I want to know what other people use them for.

I use them to convert markdown files to pdfs and open them. It can be as simple as the shell command `pandoc .md -o .pdf; open *.pdf`, and for more complicated documents, you can just write a makefile and have vscode use that.

Tmux + vim seems better suited for this task.

I have a bunch of docker wrappers for restarting various things. I have some GNU Make targets, flake8, ansible-playbook calls that I run, some django targets. Since I structure things similarly, I'm 100% okay with the idea that a specific command is useless in a specific project (i.e no make for X).

But the idea is that I can than wrap django's manage.py to collect just the commands we write, do something similar for make targets, and selected other things - so that I can just continue working and check on the task later.

In my mind, almost anything other than linting, debugging, profiling, and deploying shouldn't need to interrupt my flow.

What vim plugin(s) do you use? I remember installing one but the emulation did not quite work for jumping into code definitions and back (it'd jump, but going back wouldn't work correctly), so I moved back to pycharm for the time being (vim emulation worked better there for me).

I use this: https://marketplace.visualstudio.com/items?itemName=vscodevi...

You can also have it use neovim as the backend as well: https://marketplace.visualstudio.com/items?itemName=vscodevi...

Thanks!

A tonne of them, all managed by pathogen. I actually have a chunk of my bashrc that automatically reinfects my vimdir. Below are the ones I can easily grab. I also have a tonne of homebrew over the years, and a love/hate relationship with Jedi, YouCompleteMe and friends.

https://github.com/noahfrederick/vim-skeleton vim-skeleton

https://github.com/majutsushi/tagbar tagbar

https://github.com/tmhedberg/SimpylFold SimpylFold

https://github.com/nvie/vim-flake8 vim-flake8

https://github.com/kien/ctrlp.vim.git ctrlp.vim

https://github.com/hashivim/vim-terraform.git vim-terraform

https://github.com/hashivim/vim-packer.git vim-packer

https://github.com/hashivim/vim-vagrant.git vim-vagrant

git://github.com/rodjek/vim-puppet.git vim-puppet

https://github.com/fatih/vim-go.git vim-go

git://github.com/chase/vim-ansible-yaml.git

https://github.com/vim-airline/vim-airline vim-airline

https://github.com/vim-airline/vim-airline-themes vim-airline-themes

git://github.com/ekalinin/Dockerfile.vim.git Dockerfile.vim

Thanks, but, my bad (I also use some of those with native VIM). I was talking about VS code VIM plugins.

Ah... copypasta ho.

code --install-extension batisteo.vscode-django

code --install-extension bibhasdn.django-html

code --install-extension Compulim.compulim-vscode-closetag

code --install-extension donjayamanne.jupyter

code --install-extension donjayamanne.python-extension-pack

code --install-extension DotJoshJohnson.xml

code --install-extension ecmel.vscode-html-css

code --install-extension formulahendry.code-runner

code --install-extension formulahendry.terminal

code --install-extension ginfuru.ginfuru-better-solarized-dark-theme

code --install-extension Gruntfuggly.global-config

code --install-extension haaaad.ansible

code --install-extension himanoa.Python-autopep8

code --install-extension HookyQR.beautify

code --install-extension humao.rest-client

code --install-extension magicstack.MagicPython

code --install-extension mauve.terraform

code --install-extension ms-python.python

code --install-extension PeterJausovec.vscode-docker

code --install-extension tushortz.python-extended-snippets

code --install-extension VisualStudioExptTeam.vscodeintellicode

code --install-extension vscodevim.vim

code --install-extension vscoss.vscode-ansible

code --install-extension wholroyd.jinja

code --install-extension Zignd.html-css-class-completion

Over the past year I've cobbled together a few plug-ins for (neo)vim that mostly works for ruby+rails (thanks tpope!) - the one thing missing right now is tag support/"go to definition" for haml/scss on a legacy project.

My question: to you have go to definition/tags setup in va code w/vim - and if so, how have bound the keys to get there?

[ed: looks like a sibling comment answered this in part already]

Tpope has a magnificent tools that allow jumping into gems - and I'm curious if you have something similar for python - allowing you to jump from your code, to pip/egg/package code, to python stdlib code.. And maybe all the way to c source for extensions?

See: https://github.com/tpope/gem-ctags And much more

Hi, I'm the guy who coded that part of VSCodeVim, and I specifically made it work for that case. gd and ctrl minus should always work to go to definition and back. It's possible you tried it when it wasn't working as well as it does now.

Hey, thanks for your work and for chiming in here! I will give it another shot.

This has been my experience too. I've been an exclusive Vim user (except for Java and Scala, for which I used IntelliJ with the excellent IdeaVim plugin) for over a decade. VS Code is the first editor where the benefit added outweighs the small losses brought by leaving my carefully manicured .vimrc.

There's one thing I wish I could figure out (I haven't really put that much work into it, so I'm sure there's a fix): is there a way to bind "<<" to "move text left without losing the current selection"?

Same here ! Long time vim user, I switched to vscode 2 years ago an early adopter ! I absolutly love it! It still blows my mind that it's a JS app running in a browser !

Interesting how many people have switched from vi/vim to vscode. Does anyone have stories of making a similar switch from emacs?

I currently use intellij for java work (because my employer pays for the license) but for most any other type of editing I use emacs. I'd be interested to see what other emacs users think of vscode.

I am currently switching from emacs to VS Code. I am using an emacs keymap and I must say, it is wonderful. For Python, I can per project easily select the right virtual environment, the "intellisense" like system is working very well, it is pretty fast and you can customize a lot of it.

I am expecting to slowly move out of emacs for my coding in the next few months.

Emacs will be kept because I have a lot of org-mode files to manage my company at a higher level (lot of tables with formulas to calculate several key indicators). On the longer term, they could be moved as Python notebooks with the rendering in VS Code.

So yes, I do think this is the editor which is going to move a lot of old coders out of emacs/vi/vim.

PS: The added bonus is that I easily get support of Go, Typescript, etc. without the need to "debug my editor". Just install the right extension, done.

I have some code that automatically builds virtualenvs for me - in directories (it overrides cd). With vscode, I can change the python interpreter, simply by giving it knowledge of where I store my venvs... with one variable!

I can't even tell you how hard that was with VIM.

> So yes, I do think this is the editor which is going to move a lot of old coders out of emacs/vi/vim.

That certainly seems a possibility, though I expect it may be somewhat dependent upon the language used, and whether the community around that language invests enough effort to develop vscode plugins for that language.

I am still faithful to my Emacs, but Visual Studio Code is this beautiful thing I can't take my eyes off.

As an editor, VSCode is still inferior (but improving at lightspeed). As an out-of-the-box experience, it blows almost everything else out of the water. Against my customized Spacemacs, it's still struggling.

But that renderer is gorgeous!

I had to start using vscode at a certain level because .net core doesn't have a free debugger (as it seems.) I would have to study vscode-omnisharp source to get a clue how the debugger actually works to use it in emacs - something I don't have time for.

But I started to use it more because the autocompletion is nice. It's not perfect, but out-of-the-box experience is nicer.

After a few months though working in it, I want to go back to Emacs, and as such, Emacs is usually running. Magit for example, or being able to split your screen up as needed, or quickly jumping between files, etc. is something that is burnt into my brain. VScode is terrible at these things.

I am watching the lsp-mode and lsp-ui projects. They seem promising because it answers a concern I have : I need to float between projects in different languages and want the typical set of IDE-like features in each one. It would be nice to have a single set of keybindings regardless of language, which vscode excels at now. VScode has a good debugging story out-of-the-box lsp-ui is promising because it is implementing vscode-like features (like peek mode).

Well, my story is that I switched to emacs mostly because org-mode and the decent Vim support that Spacemacs offered. While I tried doing my development in Emacs too, I ended up using VSCode for most of that.

One reason is that I kind of like the separation between Emacs for org-mode and another tool for development.

Another is that VSCode just kind of 'clicks' with my approach. As a freelancer, I often work on multiple projects at the same time. I can have various VSCode projects open, each with its own terminal processes.

I find myself still using Emacs for TRAMP stuff (remote SFTP editing of files) occasionally, but somehow using Emacs for properly working on projects never quite 'clicked' the way VSCode did. It's possible that I just haven't gotten comfortable enough with it yet, but so far I'm really loving the Emacs/VSCode setup. And I still occasionally use Sublime Text for one-off editing of bigger files.

My story was: vim (5 years) -> emacs (7 years) -> sublime (2 years) -> atom (1 year) -> vscode (2 years and counting).

Switch from vim to emacs is obvious. Switch from emacs to sublime was triggered by moving from Linux to MacOS (my Thinkpad was failing after diving in a tropical rain so I bought a brand new MacBook).

How does Sublime Text compare to VScode for you? I am curious about the choice between the two, and why one would be better.

I can't Sublime in any way - and I say that having tried TextMate on OSX a decade or so back. Sublime just isn't VIM in so many different ways, it hurts. Neither is VSCode - but the varying tradeoffs are solidly worth it (IMHO).

I've also JetBeans'd (2001-2003) with varying success, and have been trying PyCharm on and off since 2014, just due to the promise. They're not there - or at least not enough.

JetBeans constant need to move my profiles around (literally they change per version) has made my strategy of having revision control sync things throughout a nightmare. Also, due to some files being binary - I just couldn't.

VSCode - and especially now that I have the global tasks plugin has simply blown my mind. Every (python django) repository I have has a wrapper script, as part of my tooling - I simply have vscode call that. Now, I have several commands I used to jump to a terminal for, run within code, in a collapsed terminal. It's great. My #1 use for that is a profiler and runserver. In dev, I always, always want them running.

It's much the same for other languages - and my environment.

I loved Sublime Text for years, but it gave me every impression of being dead on the vine. Since it's proprietary, there's not the option of forking it to add my own features and fixes. I personally find VSCode to be at least as good as ST in every way, and much better in many.

out of curiosity. Have you added features or fixes to VSCode?

Same here for me, but with Emacs. I've used it for decades and love it. One day I heard that VSCode had an MIT license, so I figured I'd see what all the fuss was about.

Wow. Everything actually "just worked". Python had perfect syntax highlighting out of the box. It noticed that I had pylint installed and started using it. It was trivially easy to set up per-workspace virtualenvs. Its git plugin certainly isn't the awesomeness that is Emacs's magit, but it's totally sufficient for normal day-to-day workflows.

It's now been a couple of months since I fired up Emacs at all, and now most of my coworkers have also switched to VSCode (yay for making it easy to share settings among coworkers within a project!). I am far, far from an MS fanboy, but they hit this one out of the park. Well done, team.

Honestly, if you like VSCode you should have been using emacs rather than vim all along...

I've been thinking about installing VSCode for a year now, I've been happily using vi/vim since the '80s. Because of your message I finally installed it to try out. I've got a few projects I'm working on, can't wait to see how it works for Python. I'm an ops guy, so I don't write code often.

One thing I forsee being a problem is that one of my projects is a side project, that I usually work on from the couch at home, using my chromebook sshed into a box running vim. So, I can't run vscode in that environment. No biggie though, I can drop to vim for that.

Worth noting, it looks like there is an extension for opening an SSH FS remotely[0]. It's something I've been curious about and will probably explore further. Not sure about getting a more flushed out dev environment on your chromebook, I know it's an option and that VS Code works in Linux (use it under ubuntu/elementary).

[0] https://marketplace.visualstudio.com/items?itemName=Kelvin.v...

Honest question, how can I know if this type of comments are not something like paid advertising more than an honest review?

Most vim users chose it because they're borderline anti-IDEs, it's really strange to me that you chose to switch for features that a vim+tmux workflow already offers.

What's mind blowing is the community support behind VSCode. If you report a bug, you get a reply in less than 24h, your bug gets tagged, assigned to someone and fixed ASAP. Then you get a new release every month with ton of bug fixes, improvements and new features.

Compare that to any other IDE or even any other open source projects.

That... hasn't been my experience: https://github.com/Microsoft/vscode/issues/18549 https://github.com/Microsoft/vscode/issues/16858

Maybe I just care a little too much about code folding, but after origami.el in emacs and atom and vim's great selection of folding commands, it seems like an oversight.

VS Code has also painted itself into a corner making proper vim emulation impossible: https://github.com/Microsoft/vscode/issues/22276#issuecommen...

The editor is awesome, and I'm really thankful for Microsoft's work in this space, especially on the LSP. But it's not everything for everyone.

That... hasn't been my experience

Your links are to feature requests, not bugs.

Since ggregoire‘s comment is about bugs, your experience is orthogonal.

I love using VSCode and find that I have less need for any other IDE with each new release. This one might finally eliminate one of my remaining needs for pycharm.

I can't help but feel sorry for Jetbrains though, who seem to be in a similar position to Opera back in the late 2000s, a small software company up against a behemoth that can afford to subsidize the development of an open-source alternative to their bread and butter.

Opera was a one trick pony, Jetbrains seems to be decently diversified in the products they offer that covers a large number of developer users and development stacks. That's not to say it doesn't hurt but their situation isn't as dire as Opera's was.

Visual Studio Code is a threat to Jetbrain's IDEs, but I don't see any serious competition to DataGrip yet. Their various .net tools are also very strong despite competing against the standard features of Visual Studio (the not-Core variant).

Back in the 90's Borland seemed to have no match for developer tools, then their management went astray.

And to be honest I never understood the complaint about lack of quality of their documentation vs what Microsoft, Zortech, Watcom, Nantucket and others used to have on those days.

Currently JetBrains is segmenting their products, for example native code languages are only supported in Clion/AppCode, even if you buy Ultimate, one needs to buy two IDEs from them to debug Kotlin/Native.

So lets see how long their management keeps on the right track.

Personally I don't care, because my experience with Borland has made me only use IDEs that are produced from the same companies as the OS SDKs that I use.

then their management went astray.

That, and Microsoft actively worked to kill them. I don't think JetBrains position is nearly as precarious.

HN loves to hate Microsoft, but they haven't anything to do with Imprise and CodeGear, nor with the internal management issues.

Yes, Anders and a few others eventually moved into Microsoft, but that was a side effect of how bad things were at Borland. Anders refused the offer multiple times from previous team mates that went to Microsoft before he did, until he though that was time to finally leave Borland.

Check this interview.

https://behindthetech.libsynpro.com/001-anders-hejlsberg-a-c...

HN loves to hate Microsoft

It'd be nice if you saved this stuff for when you're replying to HN, not to me.

Microsoft in the 80s and 90s were hyper-aggressive towards anyone they considered a key competitor and played dirty. The fact that some of these competitors didn't do themselves any favours doesn't change that (I think, quite uncontroversial) fact.

I don't think VS Code is this huge threat to Jetbrains and as a competitor, Microsoft is not quite the bugbear it once was. If anything, its Jetbrains that's outcompeted their direct competitors (Eclipse, Netbeans) to semi-irrelevance/coma.

Quick Pascal, Quick Basic, MASM, Microsoft C and the 16 bit versions of Visual C++ were hardly hyper-aggressive products, versus the competition.

They were aggressive with MS-DOS and Windows, their developer tools not really, even with VB and VC++ 32, they started to win when Watcom, Borland, CA, Zortech, Symantec Metrowerks stopped being worthwhile to spend money on.

We're getting a bit into the weeds here but I think it's a mistake to conflate the 'aggression' part of this with the quality of the products. In fact, the poor quality of the products was part of the aggression - Microsoft got to leverage its position as the platform vendor against its own ISVs. They even named them with Borland's own naming scheme!

You can probably make a decent argument that Borland's mismanagement was a misguided attempt to respond to Microsoft's pressure.

Jetbrains product segmenting is a bit strange yes. Right now as a full stack developer i have three options: 1. One instance of VSCode with a few plug ins for each language, 2. IntelliJ ultimate €499/year/seat, 3. Run four free IDEs from jetbrains simultaneously.

#2 is too expensive, #3 is too inconvenient and while #1 isn't as good as jetbrains it's too good enough to justify an upgrade to intellij ultimate. If you are saying native is not even supported in Ultimate this makes things even worse. Jetbrains should release something cheaper in between #2 and #3 that supports many languages but maybe hold back on certain premium features like profiling etc.

TeamCity in particular is loved by many enterprise shops, as well as IntelliJ and Resharper. None of those (even IntelliJ) are particularly threatened by VSCode.

For now vscode is certainly far behind in terms of java ecosystem support, but it feels like not long ago that pycharm was way ahead.

No, but Visual Studio (not Code) is rapidly integrating R# features into VS. Many people are disabling R# because it slows down VS so badly and Microsoft has been closing the gap (see recent 15.8 release with EditorConfig features).

Iunno. I'm finding that VSCode is rapidly approaching parity with IntelliJ in terms of features that I actually use, while at the same time being quite noticeably faster and less buggy.

JetBrains still has some areas where they excel compared to VSCode, specifically Ruby for me right now. Maybe that will change as Solargraph[1] improves?

[1] https://github.com/castwide/solargraph

I am somewhat embarrassed, but also relieved to admit that I switched from vim (nvim to be precise) to VSCode (OMG M$FT!) and am very happy about it. I still use vim bindings as much as I can, but I guess giving up a bit of ideology can benefit one a lot. Although, that is until I start running out of memory on my personal laptop, then it's back to the terminal!

The vscode vim bindings are atrocious. I use them because there's nothing better, but they're bad. Slow, super buggy, and did I mention slow? I hit tab and sometimes instead of inserting a \t, it inserts the letters "<tab>". And it re-runs mypy/flake8/etc whenever I enter or exit insert mode, which I do a ton... so my CPU is constantly pegged. And commands like "2d}" don't delete the correct amount of paragraphs. And one more I forgot: The undo stacks aren't synced between vscode and vscode-vim, so vscode's undo can undo an undo. <sighs>

I've reported all these bugs with not much in terms of answers. I've even tried contributing but it's a pretty messy codebase to get into. Ergh.

Which extension do you use? I don’t use vim mode myself but I vaguely remember seeing a conversation about how, for some reason, the better vim plugin with the most favorites doesn’t appear on the top of the search results, and an inferior one is there instead.

This one: https://marketplace.visualstudio.com/items?itemName=vscodevi...

I've tried just about every single one and the best one is still the main one. It gets better just about every release similar to VSCode. Not saying it's perfect, but with all of the other VSCode benefits I find it so much better for productivity than plain Vim.

i agree with these observations

There is an upvote button so you can convey that appropriately :)

The author of vscodevim is working on a new extension that uses NeoVim's remote UI client protocol. Accuracy and speed will hopefully go way up when that is finished. Unfortunately progress appears to have stalled somewhat.

https://github.com/Chillee/VSCodeNeovim

I went back to "vanilla" NeoVim solely due to the slowness of the VSCode Vim plugin. Been watching the repo you linked a couple of times a month and always disheartened that nothing seems to happen.

What's the bug that you have with `2d}`? It seems to work fine for me.

There shouldn't be any reason that it reruns save upon entering/exiting insert mode; are you sure you don't have some kind of keybinding/other setting that's autosaving for you?

The `<tab>` issue is kind of a pesky race condition that's most likely exacerbated by VSCodeVim running slowly on your computer.

Speaking of it running slowly, I would argue against characterizing them as "slow". Some small subset of users seems to have consistently run into this issue, and a decently large subset of those users have realized that the issue is caused by some conflicting plugin, so I'd suggest trying that too.

As for the undo issue, I have mixed feelings about it. Perhaps it could be synced with VSCode, but it's definitely true that when it was first implemented, VSCode did not provide the flexibility to do so.

Overall, I do agree that there's stuff that can improved, but it kinda hurts to see people call them "atrocious". I suspect your main issue with VSCodeVim is really the "slowness" issue. I would try disabling other plugins and see whether it helps.

EDIT: Forgot to mention. Disclaimer: I'm one of the primary maintainers for VSCodeVim.

I use VSCodeVim every day and I just wanted to say thanks for your work. You made the switch to VSCode a lot easier for a lot of people.

Thanks for your work. I've been using vscodevim for a while and it works like a charm out of the box.

I'm sure the real Vim power-users might miss a whole bunch of stuff, but I consider myself an intermediate Vim user, and I think VSCodeVim is great. Almost all Vim commands I use seem to be supported. So thanks for your work :).

> Overall, I do agree that there's stuff that can improved, but it kinda hurts to see people call them "atrocious"

Sorry :( I hate to be harsh and I don't want this to get you down, because I have a lot of admiration for the work you do (and this goes to any open source work I've ever criticized, really). So, thank you for your work.

But... the usability is really bad. They would be completely fine in a vacuum if vim didn't exist, but the point of comparison exists and it's vim and vim is just crazy fast compared to vscode-vim, it's like comparing a racer... to a fighter jet.

> What's the bug that you have with `2d}`?

That only deletes one paragraph (like 1d}) instead of two. 3d} only deletes two, and so on. It's not consistent with vim.

> There shouldn't be any reason that it reruns save upon entering/exiting insert mode

shrug, I filed an issue about this a couple weeks ago after a decent bit of debugging.

> I suspect your main issue with VSCodeVim is really the "slowness" issue

ish, it's definitely the primary pain point but there's also lots of small bugs and inconsistencies with vim. And I understand that competing with vim itself is hard, but the other comparison point is for example pycharm's vim plugin and vscode's is far behind.

Edit: And just to echo tdfx's point, without your bindings I wouldn't even be on vscode, so there's that :)

I don't think the undo feature is built out well enough for it to be a great idea for you to switch to it. I tried to build an undo tree and saw that there is a granularity mismatch between the internal stack and yours. I think the API should be redesigned so that plugins can manage the undo stack but the team seems pressed on time so I gave up for the time being. The issue is still open so I'm hopeful they might come back to it.

Just want to say thank you for what you do. Contrary to this users experience I find the Vim bindings in VSCode to be probably the best I've ever used in any IDE. Keep up the good work.

I really appreciate your efforts in improving the Vim experience on VSCode, but the extension is slow enough that I find it unusable. I desperately check every changelog update to see if the performance issues have been mitigated, to no avail.

I had similar problems. Certain key combinations in vscode would cause the cursor to delete or corrupt large sections of my code and delete the undo history. After losing hours of work a few times, I went back to Vim. I really like the process of customizing my editors and having them work the same on all machines, even remote servers. (Vim for coding, and Emacs/Evil for Org Mode.)

I would really love to ditch more of my nvim setup for vscode, but this bug [1] from 3 months ago absolutely wrecks my productivity. I rely on splits as the primary means to navigate the codebase and having a single cursor position per file is maddening!

The vim bindings aren't perfect and are sometimes slow (you can see a macro insert things character by character) but about on-par with IdeaVim for the IntelliJ side feature wise.

Maybe oni [2] will catch up before vscode fixes their issues but I eagerly await a decent language server modal editing setup.

[1] https://github.com/VSCodeVim/Vim/issues/2688 [2] https://github.com/onivim/oni

Yeah VSCode for Vim feels like they are slowly trying to implement a subset for VSCode. This kind of iterative approach doesn't strike me as a way to build something that will finally "feel right", and overcome these limitations. Perhaps some remote vim running actual nvim code with a minimal API bridge into VSCode is more appropriate?

The maintainer of vscodevim has done a lot of work on a plugin that uses such a bridge. :-)

sounds like https://www.onivim.io/ to me

Ooohhh, this is something that I've been meaning to get back to...

There was an atrociously bad "undoing work" issue that I popped out of hiatus to fix, and that bug was the cost of the fix. I meant to add proper support for that, but me not using splits that much (especially for the same file) as well as other commitments have prevented that.

> can benefit one a lot.

What are those benefits?

I tried to switch from vim to VSCode, and it just felt like it confined me. To be fair, I don't "run vim", per say, I run a shell with tmux inside, split horizontally in two, with vim on top, and two shells (a vertical split) underneath. The left shell on the bottom being used for miscellaneous things, and the right one running some kind of live code checking (with visual results also inside vim).

This setup works great for both c, c++, python, haskell, rust, node and any other programming environment I use. I tried getting something along the lines with VSCode, but it confined me, and it felt like it wanted me to do things "its way", instead of letting me decide what I have found out works through years of experimentation. It's the same with jet brains and xcode and visual studie... It doesn't let me do things "my way" but instead forces me to do things its way, which, if I may say, is highly inferior. I have tried their ways and it's not good.

Sorry for the rant.

Could you expand on what "Your way" is? I really really like VSCode for Python and never had the nerve to learn VIM, so I'm wondering what you do that causes it to be a fight.

Well, the setup I mostly use looks like this: https://imgur.com/a/A9b3izE

I've tried getting something like that going in VSCode, but even just switching between terminals and compiling and so on is just too confining. Whenever I've tried, there's always some part of it that doesn't let me easily do something, because it expects one to use it some other way.

With a shell, tmux, vim and other CLI tools, it's all based on basic primitives that all function the same way and you can compose them as you like. It just works. You can't do that with VSCode or any other IDE. They all put limitations on you and if your preference doesn't fit its, you're out of luck.

This is pretty much why I haven't moved fully to VSCode as well. I gave it a try but I realized that my whole workspace is in terminal. Also, like you said the tools I have compliment to one another very well making it very flexible. The only thing I do miss when working in terminal is that whenever I'm working in markdown I wish it had dead simple preview like that in VSCode.

I do all my document-making in emacs with org-mode and evil (vim-mode). Seriously, it's amazing. When you are done, you are one command away from having it in markdown/pdf/latex/html/word or any other format you can imagine.

I'd love if I could have the same power for managing my todos, tasks, projects, taking notes, README writing, overall agenda with vim, but I can't, so I find it's easily worth it just to use emacs and org.

Here is an example of what you are able to do with emacs and org: https://imgur.com/a/3rTNVYE

And if you need it in markdown, you just manually export it, or set up a hook that does it for you every time the document changes.

And no, the result of the code-blocks in the screenshot is not something I manually inserted into the notes. Org runs the code and inserts the result for me automatically.

Okay you convinced me with that org-mode. I've already invested huge time learning vim and hopefully it translates well in evil.

Edit: Ah, I see emacs has it's own terminal which is why it was able to support charts and graphs.

I mean, it sounds like to me vscode has nothing to offer you, if your desktop (i.e. what we see when we look at your monitor) remains so static (in a positive sense).

I find vscode more useful than vim because I can quickly and easily swap out the pieces of environment I need. Need a terminal real quick? Ctrl`, command, ctrl` again and poof it's gone, with nothing in front of me but my code. Need git real quick? Ctrl shift g. Need one more tab? Another? Ctrl \, and so on.

I usually work with three or for different files opened, some tucked away in a tab that I can quickly shift to when I need it. And when I need to get to my "wall o' terminals", I just switch to that workspace (gnome).

Whenever I watch the local vim lady do her thing, it's an entirely different workflow. Grepping across files, then opening one in vim so it just kinda pops up in a new terminal window. Doing a thing there, then closing it to go work in a different vim window... Admirable memory map of the code base and confidence to just close the file and move on, but not for me.

> I find vscode more useful than vim because I can quickly and easily swap out the pieces of environment I need. Need a terminal real quick? Ctrl`, command, ctrl` again and poof it's gone, with nothing in front of me but my code. Need git real quick? Ctrl shift g. Need one more tab? Another? Ctrl \, and so on.

I'm able to do all of these things too with my setup, although it's not vim driving my setup, it's tmux. Using just plain vim doesn't work for me.

> I usually work with three or for different files opened, some tucked away in a tab that I can quickly shift to when I need it. And when I need to get to my "wall o' terminals", I just switch to that workspace (gnome).

Most of the time, I have two files open too, sometimes three. I never use tabs for files though. If I need to work on multiple files, I have them all open in splits. Seems to work fine all the time. I use ctrlp to easily switch between buffers and files.

> Whenever I watch the local vim lady do her thing, it's an entirely different workflow. Grepping across files, then opening one in vim so it just kinda pops up in a new terminal window. Doing a thing there, then closing it to go work in a different vim window... Admirable memory map of the code base and confidence to just close the file and move on, but not for me.

Yeah, doesn't work for me either... My setup looks like this[1] most of the time, and I'm easily to add any and everything as I need it.

[1]: https://imgur.com/a/A9b3izE

> I'm able to do all of these things too with my setup, although it's not vim driving my setup, it's tmux. Using just plain vim doesn't work for me.

For a while I was running (g)vim8 with the built in :terminal - but I had some character issues with meta mapping (so typing tings like ~ on my Norwegian keyboard layout was a chore). Qt neovim didn't have these issues, whatever caused them - but I also switched back to a tiling wm (i3) - and I'm not sure if screen in neovim term really is better than a neovim on one side and a terminal w tabs on the other.

What I will say is that vim8 has a "better" terminal out of the box than neovim (that realized the idea first) ;in vim switching out of insert mode is easy and allows real nice copy to buffer - say to copy from a repl, and switch windows to paste into a file.

The limit of one (two) x11 clipboards is a bit of a pain, but with setting the x clipboard to default copy/pasting between vim and the rest of the world becomes pretty painless.

Anyway - point being, vim/neovim has great support for managing terminals - but I'm not convinced it's a great idea.

> it felt like it wanted me to do things "its way", instead of letting me decide what I have found out works through years of experimentation.

Arguably that's not "your way" either but "vim's way", which you've adopted over those years of experimentation by force. Only now that there are alternative options which are equally as powerful is it apparent that there are other ways of doing those things.

I'd rather say it's the unix way. Check out this[1] screenshot. tmux, and inside is vim, git, and cargo visible. My work environment is based on simple primitives that are all able to be composed and set up to ones preferences.

[1]: https://imgur.com/a/A9b3izE

I could never get used to NERDTree for navigating through my project. What plugin do you use for project navigation?

I use fzf[1] for all my project navigation needs. It integrates very well with vim. You can get a quick recursive look at everything in the CWD with a stroke of a key and the fuzzy matching is instantaneous.

[1] https://github.com/junegunn/fzf

not op, but i use ctrlp.vim for everything. feels a lot better than most things.

Yeah, exactly. I use NERDTree for discovering new projects, but other than that, I use a fuzzy matcher for files and buffers. I used ctrlp for years, but recently switched to fzf because it's just faster.

Fzf and ripgrep <3

Yup, this is also my setup and workflow, and I also agree with what you say about VSCode feeling 'confining'.

This is probably just a matter of opinion/preference, but I feel like an editor should simply be an editor -and IMO there is no better editor for turning thoughts into code with minimal friction than VIM/Neovim. The OS functions perfectly fine as an IDE for everything else.

I have been following this extension ever since Don Jayamanne joined Microsoft. This has grown by leaps and bounds since then and is a fantastic extension.

I was a little leary when I learned they were tossing out jedi in favor of the VS Python language server. However, after playing with it for a month or so now I can tell that it's a drastic improvement over what's currently in place.

If anybody from the MS team is watching this thread, care to share why you chose to invest in the VS Language Server instead of investing in Jedi further?

The server is more tech agnostic : you can use it even if you IDE is not written in python. But the killer feature is that the protocol is the same for all languages so once you support it for one language, you gain support for all of them.

The key thing to know is that the Microsoft Python Language Server -- long, official name I know, hence why we just call it MPLS internally ;) -- comes from our Python workload for Visual Studio. It was an extremely tough call to make because David Halter has done a great job with Jedi and running that project. But in the end we decided that if we were going to need to keep the IntelliSense engine in Visual Studio going then we should get more out of that investment by turning it into a language server and making it available in VS Code.

But I will say (and continue to say) that we are extremely grateful to David Halter and everyone who has worked on Jedi. It gave the extension the initial IntelliSense support it needed in order to be successful. And we currently have no plans on removing Jedi support for those that prefer it (from the extension's perspective we're actually trying to treat the language server as yet another project we have integrated support for, but where we have a direct line to when a bug or feature crops up that we would like to see addressed ;) .

Jedi provides completions. LS has much wider capabilities - formatting, code rename/refactoring, detecting unused or missing imports, discovering unit tests, linting as you type (so you don't have to run PyLint manually) and more.

Vscode has been the first editor that I switched to from vim in 20 years (and yes I went through sublime, atom,etc). A Microsoft editor on Linux... imagine that.

Lots of people in my workplace have switched to using vscode from pycharm. They still use pycharm once a month to do a global lint analysis or some tricky refactor...but for daily use, it's much more pleasant to use vscode .

In fact, we use vscode with our Dev setup which is all docker+python. Works beautifully (debugger and all)

Likewise, I've been an avid user of vim for my programming for quite a while now. I've tried various IDEs but never really liked them.

I've settled in to using vim for the one-shot scripts, and vscode for things that are more complicated. If I have to do big refactoring, then pycharm makes an appearance because this seems to be something vscode really doesn't do well. As much as it's a drastic improvement over Eclipse, pycharm still "feels" bloated, where Microsoft's obsessive approach to UI latency pays dividends in vscode.

Any tips to share on debugging python in a docker container using vscode?

I've tried their instructions for ptvsd before and after this update but still haven't been able to use the debugger with docker.

you're in luck. I posted this just 2 days back

https://github.com/Microsoft/vscode-python/issues/79#issueco...

Tried to use python within vscode last month, it works fine, but I still have to hack around for my own workflow.

I eventually switched to pycharm for its autocompletion, class help, even pipenv support natively built-in.

for html/css/js I keep using vscode though.

there is no such thing called universal editor, I still have to use various(vim,geany,vscode,pycharm...) for different scenarios, which is fine but just very time consuming

You also have that in VSCode you just need to install the Python plugin. You can do automated visual flake8 linting as well.

yes tried all that already for a few days and I eventually gave up.

plus very hard to get django support in vscode which I also need.

The Python extension supports debugging Django [1] and there are several plugins for the Django templates such as autocomplete etc [2].

[1] https://code.visualstudio.com/docs/python/debugging [2] https://marketplace.visualstudio.com/search?term=django&targ...

I've been trying to get into VSCode for Python development, especially Django since the first official release of VSCode, every time I returned to PyCharm.

I just decided to accept PyCharm the only IDE that can make me productive and go fast!

I had a similar experience. What are you missing?

* Auto complete * Integration with Python and Django, Flask. * Test runner (running the failed tests etc). * Amazing type hinting support. * Python console. * Support for pipenv, pip, virtualenv, etc. * Remote Python interpreter (working on Windows, but Python is inside a VM.) * Crazy Git support in one place (going through all the file history or selected lines history.) * Fast indexing. * ...

Some of the above or maybe all of them can be achieved in VSCode, but they never feel native and well integrated in there.

To me PyCharm seems to be built for these, they create, design and develop an IDE exactly for a specific audience. That's why PyCharm for Python, WebStorm for web and PHPStorm for php development.

We are working to improve on pretty much all of these areas, so I'd be interested to learn from you what we can do to make them feel more native and well integrated for you.

Reach out to me at dantaylo [at] microsoft [dot] com if you'd be willing to hop on a call to chat more!

What specifically are you looking for in terms of pipenv? We actually supported pipenv environments before PyCharm, so if you have specific needs please open an issue at https://github.com/microsoft/vscode-python/issues .

Never thought that code editor from the MSFT would become my daily driver IDE.

The only feature I need most from the VSCode (which is not implemented yet) is Python Remote interpreter[1]. While `ptvsd` is more or less convenient for remote debugging, it doesn't help when you need IntelliSense/linting while developing code being interpreted in container/virtual machine/remote host. IntelliJ PyCharm is clearly ahead here for now.

[1] Issue #79: https://github.com/Microsoft/vscode-python/issues/79

Need WSL support for the Python extension! Right now it's impossible to use the Python extensions from within the WSL environment.

I'm on the same boat, since I only use pyenv inside WSL. It's something that is being discussed (and worked on for other languages). The relevant issue is at:

- https://github.com/Microsoft/vscode-python/issues/67

And the VS Code team was asking for folk to interview regarding WSL integration:

https://forms.office.com/Pages/ResponsePage.aspx?id=v4j5cvGG...

(Full disclosure: I work at Microsoft, but in other teams, and am eagerly waiting for the day I can use WSL pyenvs)

Cool thanks, I filled out the form!

My uses are a bit mundane but I'm willing to talk about them!

Can you get away with just having the terminal open the path in WSL? I'm not sure what your workflow is though. I change mine to use msys bash (installed via git for windows) instead of powershell in windows. Not sure if it'd be too much more difficult to do similar with WSL.

Also, no idea on integrating tasks... Would be nice to see more in the box. Only windows machine I have now is my work laptop, and we're only targeting windows deploys, so cannot answer more specifically.

I wonder how intellij will survive if vscode becomes a standard for pretty much every language.

Which makes me wonder if kotlin will also survive if intellij goes bankrupt.

I have thought the same thing. I have been a customer for years but I might let my ‘everything licence’ lapse at the end of my current subscription. VSCode is amazing for mainstream languages as well as Haskell etc.

At least with regards to Java, IntelliJ is still miles ahead.

And maybe not the most popular opinion but I still prefer PyCharm over VSCode

Something to consider, VS Code being free means it will eat into IntelliJ's marketshare, even without all the features of IntelliJ. They'll be the people who need the advanced features who will continue buying it, but many people may not need the full suite, and will use VS Code to save money.

IntelliJ has a free version which is good enough in many cases: https://www.jetbrains.com/idea/features/editions_comparison_...

The IntelliJ community edition is free as well, and has features galore. (I'm an Emacs guy through and through, but some Java stuff makes me break out IntelliJ)

Yup, I use both VSCode (for JS) and Intellij (for Java). VSCode is no where close to having the functionality of Intellij Ultimate and I really don't see that gap closing much without some major new extensions being written.

I've used Intellij for the Java, Python, Ruby, PHP, JavaScript, TypeScript.

I can say that in no way I found VSCode be able to to take on it, even the JavaScript support and they way they have integration with many JavaScript frameworks and other languages frameworks is something I cannot find in VSCode.

Intellij IDEs are really fast, very well integrated and made to get me productive, I couldn't find that in VSCode.

Worth noting, I still use VSCode for JavaScript & HTML & CSS development, but only when it's not heavy development, otherwise Intellij IDEs.

> Intellij IDEs are really fast

I would strongly dispute this. I love the JetBrains IDEs and have been using IntelliJ IDEA for many years, but performance in general is definitely not one of its strong suits (though it has improved significantly over the years).

IntelliJ just feels very sluggish to me, and regularly lags and hangs on our (rather large) work codebase. Anything that causes the IDE to start indexing takes about a full minute before it is usable again. Then there's the occasional crash due to a bad plugin. And it definitely (at least for me) uses more battery on my MacBook than any other editor I've tried.

Having said all that, I try VSCode and other editors every couple months, but I always find myself coming back to IntelliJ IDEA for the reasons you mentioned. Currently, it's just a superior and "smarter" IDE, though I expect Microsoft to narrow the gap over time.

Are you sure you're not just running out of heap space? That problem appeared really quickly when we migrated our devs to IntelliJ, and slowed it down to a crawl. The default 750MB are just not enough for projects with 5000+ Classes.

IMO it shouldn't fall on the shoulder of users to manage the application's memory allocation on its behalf.

It's possible. I did increase mine a while back but I don't remember by how much—I'll try increasing it further and seeing if that helps. Either way, I agree with the sibling comment: As a user, I shouldn't have to worry about memory allocation at all, so even if that is the issue, that's one point against IntelliJ vs other editors.

> Intellij IDEs are really fast

Not on my Core Duo without turning lots of plugins off.

Eclipse and VS 2017 still manage to outperform it, without disabling anything.

And that continuous indexing that we cannot disable. :(

> And that continuous indexing that we cannot disable. :(

You can turn off the continuous indexing by "File > Power Save Mode"

I have used the full-blown Visual Studio.NET for over 15 years now, and JetBrains has got my $150 for the latest ReSharper update every one of those years.

VS Code is still years of dev work behind the baseline VS.NET, and likely will remain that way indefinitely (so that people like me can continue paying for the Real Thing). JetBrains will be happy to fill in the gap to bring one up to speed with the other.

They'll do just fine.

Kotlin is free and used for Android. It will survive if JetBrains goes bankrupt. As for JetBrains and IntelliJ, I wouldn’t be concerned. Code has a long way to go to support Java development, and as evidenced by many, devs usually use multiple ides and editors.

IntelliJ (Ultimate at least) is miles ahead in comparison to VSCode. Adding, configuring and managing frameworks is a lot easier right now.

Also, don't forget Android studio is built on IntelliJ.

I am scared that it will end in an endless discussion á la "vim vs Emacs" somewhen.

I think jetbrains will do just fine.

I've been pretty happy with PyCharm, having come from a java+Intellij background, but I'm open to other options.

So I'd be curious if someone can comment how VSCode compares to PyCharm wrt language aware features, such as: contextual selection, refactoring, finding usages, method/function extraction, auto-fixing, etc...?

I prefer Pycharm because of multiple reasons.

1. Same key bindings and similar functionality out of the box across a lot of languages.

2. Language injection, i.e, have a string in your python function containing sql or html or js or anything.

3. Generally better than the competitors. For python that may not be true, as python is highly dynamic and not possible to do too much static analysis, but Pycharm does a good job.

4. All jetbrains products are very well integrated with the ecosystem. e.g, virtualenv, jinja2 out of the box.

VSCode is a programmable editor with IDE-ish features (lots of them, and getting more). Intellij IDEA is an IDE behemoth. They'll overlap quite a bit, I doubt VSCode is going to be the IDE IDEA is anytime soon, if ever just as IDEA is probably never going to be something you fire up to edit a small python script or lets you hack in support for some obscure build system or error format parsing in 20 minutes.

That's mostly it. PyCharm is easily going to squish VSCode at the features you listed.

I was born and raised in Emacs, but over the years switched to Vim (on Amiga) and used it ever since. Occasional stints came and went (UE32, Sublime...), but vim remained. It still does, but used to too. VS Code, on the other hand, is excellent for Javascript. Whenever I need to do JS, VS Code is the tool to do it. Along with Brackets for quick proto/live preview (something VS Code doesn't do as well).

Vim is still my goto (heh, heh!) 'IDE' for C. I still haven't explored, in-depth, going towards Spacemacs for C... but my vim setup is now so well-honed for everything C that I'm not sure what would be the benefit of jumping on top of anything else. Doesn't seem worth it, except for debugging, which I do per-platform anyways.

In any case, VSCode for JS is THE tool, along with Brackets for live preview when making a proto.

Is there any way to import or convert a Sublime Text 3 colour scheme?

It's stupid, but I'm so used to my customised colour scheme it really makes it hard to use anything else... and I'm comfortable enough with ST3 I can't be bothered spending time recreating the scheme from scratch

Can Sublime export a textmate theme? If so, yes, you can import a .tmTheme file into VS Code. https://code.visualstudio.com/docs/extensions/themes-snippet...

Great!

in fact my theme is already in tmTheme format because it came from ST2, which could always load Textmate themes

MS totally dominates tooling. I am so happy with vs code, use it for my angular development as well.

Use it for Rails and Flutter too here, and really happy with it!

What I'm hoping for, for all langauges and runtimes, is some global opt-in to WSL. If I have node or python installed on WSL, I would love it if the Windows version of VSCode could act as if it were the Linux version.

Not a Windows users but curious about WSL - could you run Linux VSCode under WSL?

No idea. I've only ever tried running cli tools and programming run-times.

It's not really supported, but you can run GUI programs with some amount of success by setting up X forwarding. Some programs work better than others, but I probably wouldn't want to run my code editor in it.

Yes, you can!

Setting up UI under WSL is a bit of a pain, because there's nothing out of the box - so you need to set up X on Windows, or use VNC or RDP. RDP is the easiest by far right now - just install xrdp in WSL, edit the config so that it uses a different port, and connect to localhost from Windows. The result looks like this:

https://i.imgur.com/DSmLjUM.png

with X server

Wish MS would also offer an own Ruby extension. Solargraph and the vscode-ruby extensions are pretty good though

The Python VSCode extension started out as an independent open source project. It independently reached a pretty high level of maturity - and helped VSCode get popular among Python developers - before, a bit under a year ago, Microsoft hired the maintainer.

Since then it's acquired a few new goodies, but most of what makes the extension great happened before Microsoft adopted it, so I shouldn't think there's anything stopping Ruby from doing the same.

Following up on that -

Shooting from the hip, though, if the desire is for funding, I'm guessing Microsoft wouldn't see much strategic value in putting money into a Ruby extension. The Ruby ecosystem has largely congealed around an ASP.NET competitor, some devops tools that don't really work on Windows, and not much else. Python, on the other hand, is widely used in Microsoft shops. Windows shops need data scientists, too, and it's typically the primary language for cross-platform devops infrastructure.

Maybe that might change now that they bought github (heavy users of ruby) but I doubt it ;)

Maybe the GitHub people would do it independently?

There's also just a question of which way the winds are blowing. I know the TIOBE index needs to be taken with a dose of salt, but it is interesting to see that Python is entering the top 3 at the same time that Ruby is falling behind Object Pascal.

Ruby also isn't one of their major languages they document things in Azure for. There is a Ruby gem, but no support for Ruby Azure functions or anything like that either. I wonder what the language mix is like for Azure deployments.

Solargraph is pretty good, but RubyMine is still much better at least in my experience. Hopefully Solargraph gets there eventually and I can go back to using VSCode for everything.

Yay, finally proper remote debugging support - had heck of a time figuring it out with previous version (http://artem.savelev.com/2017/08/comfortable-vscode-rpi-debu... )

Hopefully this one just works as v4 actually has an idea of standard protocol that doesn't break.

I wish they would add support for running Python or any runtime inside of Docker.

There's been a Python specific ticket open since November to add in remote interpreter support at https://github.com/Microsoft/vscode-python/issues/79. Current status is "no ETA".

This is very high priority feature on our backlog, and we are currently looking into it. It's a complicated feature to implement so any ETA we give right now would be making things up, sorry!

Updated to the August release of VSCode this morning and discovered that debugging python in the editor is broken. The editor refuses to recognize PYTHONPATH specified in the environment or a .env file. (This refers to VSCode on Windows 10). The hack to work around this is to specify it in the launch.json file. Otherwise I absolutely love VSCode and particularly the Python extension.

Please file a bug at https://github.com/microsoft/vscode-python/issues

Crazy question: Since Microsoft bought GitHub, would it make sense to merge VSCode and Atom at some point, keeping the best of each one?

What's the best of Atom?

I find a lot of the keybindings and default settings to be more intuitive in Atom over VSCode. It's also extremely easy to extend via JavaScript.

As the other comment mentioned, extensibility. Their API is much easier to navigate. Their commands line up exactly with the name that shows up in the fuzzy finder, so dispatching a command or adding a key binding is a breeze. The settings menu supports things like drop down lists and color pickers. The UI is both beautiful and consistent. And Vim Mode Plus feels far ahead of Vscodevim.

You do lose the dedicated python developer, first class LSP support, and integrated debugger though.

I never even thought about that. I had such high hopes for Atom and the speed hit was real at first just as I thought and figured nothing would beat my Vim setup. Then someone on HN stated that VS Code was really good and I just went back to my i3 and rsvt setup and laughed. Now I use VS Code non-stop in Linux. I went back to Atom and was underwhelmed compared to VS Code's community.

GitHub is planning to keep Atom going: https://www.reddit.com/r/AMA/comments/8pc8mf/im_nat_friedman...

Is there a Python IDE that will show all the stuff that's actually in a class? E.g. if I have a class that inherits from several parent classes, some of which have identically named methods, is there a good way to see how the methods are defined in the class I'm looking at?

You're looking for PyCharm.

VS Code has an Outline view that does this: https://code.visualstudio.com/updates/v1_25#_outline-view

Eclipse with PyDev is amazing with that, definitely. It lacks a crucial goodie that PyCharm has, which is an icon to indicate a method is overriding a parent implementation. Other than that, it's amazing and very mature when it comes to python development.

I'm using VSCode for my FE work and love the tooling, integrations and marketplace. Happy with the vim plugin, formatting support and terminal support within the IDE. Not a surprise here coming from Visual Studio. In the past I've considered splurging on JetBrains' Webstorm IDE. Glad I didn't.

Will give it a whirl for the BigData/ML related scripts. Nice to see one IDE being the GoTo for different lines of work.

Having said that, with the latest update (1.26.1), I'm seeing a significant lag in keystrokes. Not sure whether a plugin is the culprit.

Since the 80s and BRIEF (anyone remember that?) I have relied on record/play keyboard macro with every programmer's editor I've used. This fundamental feature is missing in VSCode, sadly it's a complete showstopper for me. I get the impression that VSCode's architecture makes this difficult or impossible to implement as an extension.

What a joy Brief was back in the day. Could open huge files, lightening quick, macros, column select and replace, programmable and all on a single floppy.

I'm pretty close to switching to this as my daily driver, but there's some small things, like Django Template formatting (https://github.com/Microsoft/vscode/issues/46468) that have yet to be fixed/working.

I prefer Atom, but I’ve started having a weird memory leak issue in version 1.29 that prevented me from using it further (note: I’ve disabled all extensions and the problem persists). I use Ubuntu.

I’m using VSCode now and it’s good, but I do intend to return to Atom when I get some time to properly create an issue for this problem in GitHub and help the team to fix it.

Since Atom is now owned by Microsoft I am wondering what is going to happen with Atom. Does it get better or does it get cut lose into a "community" project?

Atom and VSCode share lots of common infrastructure and Microsoft is investing heavily in that.

With that, even with no specific efforts toward Atom, it should still see improvements over time.

Is great to see this kind of debugging, with a easy setup, in a open source IDE. Awesome job with the open source community.

I tried it first very early on, but was hesitant after trying Brackets and Atom. I was happily surprised and once they added the integrated terminal, I was hooked. I don't use the tasks feature (usually just a terminal or two open). In general it's been incredibly nice though.

I'm using VSCode for developing in Elixir and (because I had the license anyway I guess) my Python code in PyCharm. But perhaps I should re-evaluate VSCode for Python as well as it works fantastic (including quite advanced code warnings and errors) for Elixir.

Which Elixir extension are you using for VS Code? Are you on Windows, Linux or Mac?

I've had the best luck with the ElixirLS extension on Linux but there are still a few weird things here or there.

Have you tried the elixir plugin for pycharm?

Awesome.

It's by far my favorite dev environment. Tried Eclipse first & was constantly fighting against the IDE. Might make sense for a full time dev but I just want a light editor with some basics like autocomplete & context etc

I would really like to see MSFT implement a builtin way to visually profile applications. They have a great ecosystem for editing and debugging, but profiling extensions are non-existent because of the strict API.

If you specifically want Python support for e.g. coverage.py, then please open an issue at https://github.com/microsoft/vscode-python/issues .

As a relatively new programmer, no matter the IDE, I still run my code from the command line in a venv is there another way that something like this makes an option?

Not only for VSCode but I'm very happy that Microsoft is pushing for Python.

Great work by Microsoft and all the contributors.

It was already one of the best out-of-the-box experiences of any Python IDE I've used.

As if python weren't already incredibly easy to debug?

A tool demo would help..

Tangent thread:

Any alt recommendation for Flask+Connexion?

I've been using emacs for more than ten years and I've loved how I've been able to invest heavily in one text editor to cover all my needs. Back then everyone else seemed to be using special purpose IDEs so it's interesting to see that only now lots of people are seeing the advantages of more general purpose editors.

VSCode is not emacs, but it's not bad at all.

We want Perl support!

As much as I love Perl, it has a reputation of being exceedingly difficult to parse accurately, hence IDE support will never be great. There's also probably more demand to support hipster languages than last generation's work horses.

I don't use it since 2000's, but ActiveState's Komodo used to be ok.

There are several perl extensions from language support, general debugging etc. Though this can probably be improved, I think it has a lot of the same challenges that Ruby support has. A limited user base, and a comparatively flexible language.

Perl is very tricky. Its syntax is undecidable, so unless you run the program it's not possible to construct a syntax tree given input (in the general case, it's possible to make heuristics that will cover 99%) so it requires more brain power compared to easy-to-parse languages like python.

https://marketplace.visualstudio.com/items?itemName=henriiik...

Reply on news.ycombinator.com