What Editors / IDE's are you using while programming with GoLang?

I'm new to GoLang and I'm curious to know what IDE's other people are using for syntax highlighting, compilation, code refactoring and general code readability in GoLang. FYI: This is not a discussion around vim vs. emacs or IntelliJ vs. Eclipse or random-tool-x vs. random-tool-y. <hr/>**评论：** kaipi: <pre>vim + vim-go</pre>fr4nk3n: <pre>Same here, vim-go is awesome. </pre>BrianWilliamDouglas: <pre>Same, Vim + vim-go. A terminal is really all you need for this beautiful language.</pre>beefsack: <pre>Neovim + vim-go here.</pre>borring: <pre>I saw a proof-of-concept demo video of neovim + asynchronous live-linting of go code. I can't wait until something like that gets integrated with vim-go</pre>Innominate8: <pre>This, plus YouCompleteMe.</pre>HaveSomeFreeKarma: <pre>Gocode is an amazing utility.</pre>qudat: <pre>It's hard to beat. I used to work exclusively in Sublime until I got the itch to try vim out, never looked back. Except now I try to use vim commands everywhere.</pre>binarypie: <pre>same here</pre>vic3lord: <pre>Same :)</pre>egonelbre: <pre>Sublime Text + GoSublime + "some-terminal".</pre>Incubuss: <pre>I'm always surprised when this or Atom + go-plus (or some other text editor) isn't the answer. I used to rely heavily on IDEs while working in other languages (Java in particular), however I've always found that Go and its tools are simple enough that I don't need the overhead of an IDE there.</pre>klaaax: <pre>Atom is fn slow on some machines , so no surprise.</pre>anacrolix: <pre>Writing an editor in JavaScript. What could go wrong.</pre>zerok: <pre>Emacs with go-mode. </pre>Phovox: <pre>Same here! A must to go! ;)</pre>hangoverpoop: <pre>Everyone knows that emacs is an OS, not an editor! I'll show myself out</pre>Luett_un_Luett: <pre>Atom + go-plus + project-manager</pre>jewishobo: <pre>I use atom + go-plus. But what is project-manager?</pre>asdf072: <pre>What it sounds like. Select a project, and that projects' files appear to the left. I'm sure there's more functionality, but that's all I use it for. (Oh, and project-wide searches! Forgot that.)</pre>Luett_un_Luett: <pre>Just another plugin that helps with managing projects. You can install it into atom via apm or via preferences. EDIT: See: <a href="https://atom.io/packages/project-manager" rel="nofollow">https://atom.io/packages/project-manager</a></pre>FIuffyRabbit: <pre>I really want to use atom but its text rendering is so awkward to look at.</pre>klaaax: <pre>LiteIDE, better than the rest, supports go-oracle , testg,debugging with breakpoints with GDB ...</pre>Yojihito: <pre>Eclipse + Go Plugin.</pre>peterbourgon: <pre>So you're the one!</pre>Yojihito: <pre>ᕕ( ͡° ͜ʖ ͡°)ᕗ Am I such a minority? The choosen one?</pre>gohacker: <pre>Follow the white Gopher.</pre>cryptrol: <pre>Another one here, I find Eclipse + Goclipse very convenient</pre>nokkare: <pre>Acme, Go tools and custom tools</pre>dlsniper: <pre>Intellij IDEA or Android Studio + the Go plugin (nightly, from the repo). </pre>schumacherfm: <pre>Same here. Love it!</pre>gschier2: <pre>Some favorite features that you get with intellij and not others is auto import, inline documentation lookup, and proper jump-to-source (even for external and core packages)</pre>partkyle: <pre>There's "goimports" as a replacement for gofmt in all major editors to get a really simple auto import on save. It's definitely not as nice as Intellij's, but in practice it works really well. There are also plugins for godef on all major editors as well, which provide proper jump -to-source as well. There's no inline docs lookup that I know of, but godef seems to do the trick for me and Gosublime includes the method definition in the gutter so I can tell what types are required for a given function. The IDE integrations are nice, but I prefer the lightweight editors with the simple tools to add all the IDE-like features I need. Quick startup is a feature that intellij just can't match right now. </pre>schoenobates: <pre>Looking at the repo it appears that this being supported by the IDEA devs - I wonder if we'll see a gostorm or something similar?</pre>mdwhatcott: <pre>The go plugin devs from Intellij presented a lightning talk at gophercon 2015. When asked if there was a roadmap to releasing an official IDE for go their answer was a simple "no".</pre>BoTuLoX: <pre>Didn't someone from the Go team say that Intellij was working on a Go IDE and even claimed he didn't know wether he was supposed to reveal that or not?</pre>schoenobates: <pre>Did they mention if this was going to be an official plugin?</pre>dlsniper: <pre>When it's good enough it will be in the official "stable" repository (not that alpha/nightly aren't official) but the plugin is open source and it definitely welcomes contributors (even if by contributing you open up a detailed issue). </pre>sandokan1572: <pre>lightning talk: <a href="http://youtu.be/3sy0hR0BIiM" rel="nofollow">http://youtu.be/3sy0hR0BIiM</a></pre>dlsniper: <pre>There's no need for a separate IDE, thr plugin runs an almost (if not all) IDEs from JetBrains,including the free version of IDEA. Is there a specific reason to want an IDE that ships with the plugin installed by default vs installing it on your own? </pre>mrkaspa: <pre>Atom + Go Plus</pre>izuriel: <pre>Seconded. I was using Sublime Text with GoSublime but found go-plus in Atom actually contained more relevant features for larger project management and getting work done in a timely manner.</pre>Bromlife: <pre>Like what exactly? I found Atom lacking when compared to ST3, especially the interface lagginess.</pre>izuriel: <pre>I was a huge Sublime Text fan prior to switching to Atom. I mean, I'm the only developer I've ever met that uses Sublime that owns a license to it (that's not an exaggeration, apparently it's not common practice). Things I found likable about Atom unrelated to Go (since Go is not the only development that I do) was their integration of their package manager. I do really enjoy Package Control, but it doesn't quite stand up to completely integrated (and native) package manager. The general capability of packages in Atom is much more rich than in Sublime. Maybe this is an illusion but I find that a lot of the Atom packages take full advantage of being able to create whatever elements for their UI they need and so you get some really useful UI augmentations. Specific to several packages it boils down to a couple. I found that Atom's git-plus package has a lot of great features (which, funny enough I don't use but was drawn to as my team would be more receptive of the editor integration than using a command line). I prefer Atom's Babel package for ES6 highlighting, as well as it's default JavaScript language package runs JSLint (when available) on save by default which was very nice to have. The go-plus package has (really) two features that were great to have (at the time I switched) which was running and rendering test coverage state on save with <code>go cover</code>. Areas of code not covered are highlighted red giving immediate insight into the coverage state for any given file. As well as a <code>go vet</code> on save in addition to the standard <code>gofmt</code> <code>golint</code>. Is Atom still sluggish? I would be a liar if I didn't say yes. Sometimes the UI just can't keep that responsive feel like a fully native app can so yes it's far more sluggish than Sublime. The question really isn't about it being sluggish, it's does that really effect my workflow? The answer to that is actually no. I have problems with Atom occasionally, requiring a refresh of the editor - but I've found that general workflow improvement is still higher with Atom than Sublime. Overall does that mean I advocate a switch from Sublime to Atom? Not quite. Again, as a fan of Sublime (and now Atom) my real response to Atom vs. Go questions is whichever one you like best is the one you should stick with. If you haven't used Atom since it's 1.0 release, I urge you to try again but I wouldn't recommended switching to it if you're already really happy with Sublime. The reason I switched was due to generating a "required and recommended" dev tool list for new developers at my company and had to evaluate the merits of Sublime vs. Atom and which had more general feature capability in regards to Go development - Atom was selected so I began using it to help iron out any general issues other dev members would encounter.</pre>Azzk1kr: <pre>What's your experience with the performance of Atom? It's something that really bugged me, because it tends to be slow. I really want to like it, but it just can't grab me. Edit: screw me, you already wrote something about the performance.</pre>nilium: <pre>vim with vim-go and Sublime Text with GoSublime. I end up using Sublime Text more when it's not a project I started, just because I don't have anything in my head about how to navigate a project yet and Sublime tends to be faster for getting that.</pre>varun06: <pre>in vim-go it is just using :GoDef(gd) and then ctrl+o to go back :)</pre>nilium: <pre>That's easy enough. The problem I have is more rapidly hopping around files and scrolling through them while I get acquainted — scroll wheel works in Vim but it feels wrong and slow to use it in that environment. Also, I use a variable width font for coding now, so I spend more time in Sublime when I feel like using it. Hard to escape the terminal once you spend the majority of your time in it, though, and I lose a lot of basic editing capabilities in Sublime.</pre>CapoFerro: <pre>emacs with go-mode, goimports, and gofmt hooked onto file save and some plugin I forget that lets me inspect or jump to symbol definitions. I also wrote a yasnippet template for if err != nil which I use endlessly.</pre>tongucyumruk: <pre>That tool is probably <a href="https://godoc.org/golang.org/x/tools/cmd/oracle" rel="nofollow">Go Oracle</a>. It has some real nice features like inspecting type of channels.</pre>rock_neurotiko: <pre>Emacs with go-mode and other things that execute go-fmt on save, and compile the project showing the errors on save or change.</pre>st3fan: <pre>Emacs. Gofmt on save. With gofmt set to goimports which does both formatting and imports cleanup. <pre><code>;; go get -u github.com/nsf/gocode ;; go get -u code.google.com/p/go.tools/cmd/goimports ;; go get -u code.google.com/p/rog-go/exp/cmd/godef (exec-path-from-shell-copy-env "GOPATH") (add-hook 'before-save-hook 'gofmt-before-save) (setq gofmt-command "goimports") (add-hook 'go-mode-hook (lambda () (setq truncate-lines t) (setq indent-tabs-mode t) (setq tab-width 4) (setq compile-command "go build") (local-set-key (kbd "C-c C-r") 'go-remove-unused-imports) (local-set-key (kbd "C-c k") 'recompile) (local-set-key (kbd "C-c C-f") 'gofmt) (local-set-key (kbd "C-c C-k") 'godoc) (go-eldoc-setup) (set-face-attribute 'eldoc-highlight-function-argument nil :foreground "green"))) </code></pre></pre>anticucho: <pre>Does it get any more beautiful than <a href="http://i.imgur.com/sR9UHGS.png">vim, go-vim and YouCompleteMe</a>?</pre>varun06: <pre>vim + vim-go + tmux one terminal to rule them all...</pre>ecmdome: <pre>This .... I was a sublime user and just got tired of heading into the terminal. I have an amazing VPS I use as my dev machine with a perfect tmux session for each project </pre>BoTuLoX: <pre>I've never found the appeal of running tmux, specially for vim. Then again, I am running a tiling window manager; but tmux being limited to one window and vim having buffers and tabs, what's the benefit?</pre>Remi1115: <pre>I prefer programming remotely in SSH most of the times (multiple computers, no need to commit/sync after every change). If you keep the Tmux session running on the remote machine, not much set-up is needed before you can start programming. Your windows and all are still in the same layout and are in the same state. Just connect, open Tmux and you're good to go. You could even borrow someone else's computer. But I'm not using a tiling window manager still. So maybe that's why I like Tmux so much. On-topic: I'm using Vim with Vim-go, without some extra features like auto completion and auto-importing of packages.</pre>anacrolix: <pre>Connect and attach in one go. ssh blah@blah -t tmux a</pre>kromem: <pre>The benefit for me is in having a preserved workspace across my project. I have a script which sets up my dev environment if not set up, or else reconnects to the session if detached. In the first window is a split of my Go backend running with autoreload with gin, my postgres docker log, and the frontend being served up via npm. Second window is a split between my Go project in vim, and goconvey's runner, with the vim window "maximized". Third is the same but with vim for frontend dev and karma test runner in second pane (with the bottom pane sized to only show the test pass/fail last line). Fourth is for my devops environment with vim for my ansible scripts on top and the runner for my ansible playbook calls on bottom. This would be a huge pain to setup "as needed" and manually, and having all of that available is a time saver. I may go a few days before needing window 4, but as soon as I do, it's ready for me, setup exactly as I'd like it.</pre>nowayno: <pre>I use Sublime. When I want to print source code, I'll open a file/package in WebStorm (w/ a Go plugin).</pre>IntellectualReserve: <pre><blockquote> print source code </blockquote> Why would you need to print your source code?</pre>nowayno: <pre>To read. Was that not obvious?</pre>ecmdome: <pre>o_0 but the trees!!! Seriously though you're the only person I know who does this... But whatever works.</pre>LimEJET: <pre>Really? Code is a lot easier to discuss and mark up if it's printed. It's useful in small teams when someone has an issue they can't find. </pre>ecmdome: <pre>I'll actually have to give it an honest try sometime.... But you don't ever feel like it's a huge waste? Showing a dev environment over a projector or TV sounds more productive. Especially since some of my code has so many lines.</pre>LimEJET: <pre>You never print all of the code, you narrow it down first. There's also the fact that text on paper is less straining to read. Edit: Not to mention that using marker pen on a TV is usually a big no-no.</pre>izuriel: <pre>Mobile apps for VCS systems or responsive Mobile VCS sites usually enable reading for me. I'd rather have to scroll left and right than manage pages of code and making sure they remain organized.</pre>taushif: <pre>Used: LiteIDE, IntelliJ IDEA Currently using: Atom, VIM</pre>1Gijs: <pre>Feature wise LiteIDE is by far the best. You name it, it supports it. For example it will show symbol info including the remarks (not only the function definition). Refactoring works well and very fast. However, I do not really like its layout and design. To much screenspace is wasted on bars that are to wide and its not as tweakable. And then there is also the question of continuity: there are some small bugs but there has not been an update for several months now. I now use Atom + Go-plus although its not very responsive and has almost no special features (compared to LiteIDE). I try not to use other packages because they will break of even slow it down more. But I like the design and layout :-) And I know it will improve and still exist in the next years.</pre>FUZxxl: <pre><code>ed(1)</code>.</pre>google_you: <pre>MS Word + MS Comic Sans</pre>davityle: <pre>This made me laugh. Unless you were serious....</pre>gaoxiang_ian: <pre>spacemacs</pre>lapingvino: <pre>me too!</pre>ironmig: <pre>Kate</pre>dermesser: <pre>Absolutely almost exclusively LiteIDE. Good stuff.</pre>whodkne: <pre>In the minority, Komodo</pre>4ad: <pre>Acme, sam, and Unix.</pre>THUNDERGROOVE: <pre>Pretty similar to everyone else. When I was newer and more worried about learning the language than an editor as well, Sublime with GoSublime worked wonders. I've since tried Emacs with go-mode, and Vim with vim-go. I've stuck with Vim. I would suggest to anyone planning to use Vim+vim-go to get YouCompleteMe as well. Not only do you not need to use omnicomplete, but YCM is much snappier and doesn't have that split second delay when trying to complete something. It also shows type information in the completion which is great.</pre>l_a_m: <pre>emacs with go-mode, go-fmt on save ... and some other tools</pre>lifter: <pre>For anyone that's unfamiliar with VIM, I normally recommend Atom with <a href="https://github.com/joefitzgerald/go-plus" rel="nofollow">Go-Plus</a>. It makes for a really pleasant coding experience, with little to no setup. For anyone who's at least a little familiar with VIM or is interesting in picking it up, VIM + <a href="https://github.com/fatih/vim-go" rel="nofollow">vim-go</a> + <a href="https://github.com/Valloric/YouCompleteMe" rel="nofollow">YouCompleteMe</a>. The learning curve for VIM is pretty steep (when compared to Atom), but if you're willing to put in the time and effort it can be incredibly rewarding. After close to a year of consistent use, I finally feel like my productivity using VIM has far exceeded my productivity using Atom.</pre>kawera: <pre>Textmate + Keyboard Maestro + TextExpander + Alfred + Dash</pre>foxh8er: <pre>Atom + Go-Plus OR LiteIDE. I do think that you need an IDE for Golang because of how strict it is. </pre>izuriel: <pre>You never need an IDE. Sometimes you think you do but if work without one you'll find how easy it really is. </pre>foxh8er: <pre>I tried to learn Go without "help", and I gave up within the first few minutes. I tried it with Lite and I'm attached. Having autocompletion and continuous linting is amazing for my sanity. </pre>izuriel: <pre>You can get around autocompletion by just using the language consistently and you'll begin to memorize things. I'm really looking forward to Go 1.5s introduction of <code>go doc</code> so that I can ditch dash/godoc.org. Ultimately I get around a need for autocomplete by referencing documentation constantly. When I do have autocomplete (such as when I work in C# or something like that) I find myself generally referencing docs even after find something in autocomplete menus as the only real benefit I've found from autocomplete (and seen from other developers) is to save those too lazy to type out code constantly. So, based on personal experience, the "requirement" for help is strictly artificial and something you forced upon yourself mentally. I'm sure you're capable of doing things without help.</pre>Bromlife: <pre><blockquote> I tried to learn Go without "help" </blockquote> Please explain "help"?</pre>izuriel: <pre><blockquote> Having autocompletion and continuous linting is amazing for my sanity. </blockquote> They do already answer you slightly.</pre>ergotayours: <pre><blockquote> I see the benefits of syntax highlighting, just as I see the benefits of diapers. </blockquote> ― Rob Pike</pre>roveboat: <pre>Since you seem to be from the 80s, welcome to the Internet! These days IDEs do much, much more than syntax highlighting, you should try one some day! Again, welcome to the future!</pre>ecmdome: <pre>I mean go-sublime, vim-go and the likes bring to you everything you'd need in an IDE to an editor. Edit: s/vim/editor</pre>roveboat: <pre>I'm honestly not sure what the difference is these days - it's just a bunch of text windows and keyboard shortcuts either way. </pre>ecmdome: <pre>IDEs tend to be more opinionated and force certain standards on you. Or just bloated with things you don't need. For me they're excellent when working with a language that has a strong UI library and a visual testing component in the IDE. But sublime by itself is just a text editor with open source plugin functionality. Vim is all of that and a ton more, not to mention it runs right in your terminal. Vim is free and sublime is cheap... The plugins are all free and if you spend time customizing your setup it can be a really great development experience. We use the command line a lot in go... And you most likely develop on a *nix system. That's why I love tmux + vim + vim-go + YCM for completion. Tmux allows you to have panes and windows within a single terminal session... You can suspend this session and attach to it again. I run mine on a digital ocean or AWS instance so I can ssh into it from anywhere and have my development environment. It seems complicated but once you learn the shortcuts and workflow this becomes a must.... Your workflow improves so much. Hope I was able to help.</pre>1Gijs: <pre>Maybe you should google that name first before commenting... ;-)</pre>izuriel: <pre>Just because Rob Pike has done great things doesn't mean everything he thinks is golden or correct. Syntax highlighting is unnecessary but very useful when you have it. Anyone who denies that is lying. </pre>roveboat: <pre>I'm not disagreeing with the uselessness of syntax highlighting ;-) Nor is appealing to authority that great of an argument ;-)</pre>dhdfdh: <pre>But appealing to knowledgeable authority is.</pre>BoTuLoX: <pre>That's still appeal to authority. Everyone makes mistakes. Or maybe things are just simpler: Rob Pike is used to working without syntax highlighting and his brain doesn't benefit from the visual information as much as other people's. Personally syntax highlighting helps me understand scope and flow in a program much faster.</pre>dhdfdh: <pre>I disagree with syntax highlighting and find it distracts from everything with candy and fireworks.</pre>BoTuLoX: <pre>Well, that would be you, which is exactly my point. Some people find it distracting, some of us find it very helpful.</pre>dhdfdh: <pre>Yes, you could call it personal preferences, but the science has shown differently. Different colors grab your attention in different ways. A multitude of colors is the bain of publishing and the web. Advertising uses color to distract you from things. And on and on and it's too much to go into.</pre>BoTuLoX: <pre><blockquote> but the science has shown differently. </blockquote> Do you have a link to the study/studies? If done on programmers I'm interested. I've personally tested this and clearly noticed syntax highlighting to have helped me. Hell, I tried to abandon molokai (a colorscheme with a high contrast) for a lower contrast colorscheme for aesthetic reasons, just to end up seeing it took me longer to "get" the code, so your claim piques my curiosity.</pre>ergotayours: <pre>IDEs are a bad design. Surely a Go programmer understands the value of simplicity and careful design over feature count.</pre>elazarl: <pre>Syntax highliting, <a href="http://www.ppig.org/sites/default/files/2015-PPIG-26th-Dimitri.pdf" rel="nofollow">scientifically and empirically</a>, have reduced error rates in software development. Uninformed opinions may have similar benefits, but this is not yet scientifically proven.</pre>champioj: <pre>Proved on 10 student (I wouldn't call that representative) on a dynamic language where these 3 representations mean different things: <pre><code>foo: bar foo : bar foo :bar </code></pre> The title of the paper is <blockquote> The impact of Syntax Highlighting in Sonic Pi </blockquote> And that's what it is, nothing more, nothing less.</pre>elazarl: <pre>This is just an example I was able to find with a few minutes of googling. But even taken as it is, don't you think this example should make one wonder whether syntax highlighting have benefit in general? What about the fact it is the industry standard in every software that displays source code is to use syntax highlighting? Do they do that out of spite? You know that VisualStudio makes research on real professional programmers. They invested the time to support semantic syntax highlighting. Surely they would be happy to cut VS latency if they found semantic syntax highlighting doesn't help people. Here is another teaser, <a href="http://www.cs.cmu.edu/%7Ewjh/Emily.html" rel="nofollow">from the sixties</a>, where it was found that syntax highlighting made coding take longer, but with fewer mistakes. One can find more empirical research supporting the fact that syntax highlighting have benefit, but I assume, you would probably claim it was never proven specifically to Go, and Go was so cleverly planned that for it specifically syntax highlighting would have no benefit. Every paper would deemed to be either too old to be relevant, on a different language, with problematic methodology, with non representative group, with bad methodology. Kind of like when arguing with anti-vaccs. So I'm not trying to convince you that syntax highlighting is good, just be skeptical, and don't say syntax highlighting has no positive effect. Especially if you can't support it with evidence. What makes you so sure syntax highlighting would have no benefit for other languages. At the very least, you should avoid making sweeping statements about the lack of value in syntax highlighting in Go, and be skeptical about it. (PS, in Go you also have <code>a* /</code> and <code>a*/</code> have two different meanings. Also combinations of backtick and single quote could be lethal. Not sure why was it chosen in the first place)</pre>champioj: <pre>I never said that syntax highlight doesn't have benefit and I don't really know where you found statement about the lack of value in syntax highlighting in Go. You ask me to be skeptical, I am. Just not in the same direction than you. Actually, my original complain was about presenting a paper as proof when it has so many difference with how professional develop in go.</pre>

用户登录

今日阅读排行

一周阅读排行

最新主题