proj-oot-ootIdeNotes1

table 5 of On the Syllogistic Structure of Object-Oriented Programming has a list of queries on OOP stuff that an IDE maybe should be able to answer: http://www.softlab.ntua.gr/~kkontog/publications/conferences/C5-2001.pdf

---

C#'s #region defines places for the IDE to allow to expand or hide

--

voidr 19 hours ago

link

You won't have good IDE support.

You won't be able to directly debug your code.

Also it can be really fun to reason about nested macros.

reply

--

(re: macros:)

Dewie 1 day ago

link

I think things like syntactic sugar is perfectly fine, as long as I can desugar it in a straightforward way. I want to be able to programmatically desugar some piece of code, not have to Google it each time I am curious.

--

A great example is the IPython notebook. The notebook doesn’t make Python better than other languages—it makes all languages better.

http://nbviewer.ipython.org/url/beowulf.csail.mit.edu/18.337/fractals.ipynb

http://gibiansky.github.io/IHaskell/demo.html

http://nbviewer.ipython.org/github/minad/iruby/blob/master/IRuby-Example.ipynb

--

bch 3 days ago

link

What are the first-class IDE-style features you want?

reply

millstone 2 days ago

link

I am not the person to whom you replied, but the feature I use most often in Xcode is Go To Definition (with command-click). This integrates with clang, so it knows how to navigate templates, overloads, etc. It also integrates with the build system, so it knows the correct header search paths, preprocessor macros, etc.

I imagine there are some plugins available for vi and emacs that try to provide these features, but I would guess they require some configuration and won't work as reliably.

---

IDE: for any given symbol, where was that symbol defined? for dynamically defined, needs runtime support too

---

" other code that can be very difficult to find. What is the type of that function? Is it a method of a class? If so, where is that class defined, and where is the instance defined? You can't necessarily find that out very easily from just the imports in the current module, or possibly not even with the imports together with the build-depends: field in the cabal file.

Even parametric polymorphism has a cost to semantic clarity. What are the types of the arguments of this function? "

---

http://android-developers.blogspot.com/2014/12/android-studio-10.html

built on IntelliJ? IDEA (Community Edition) Java IDE

---

more details on grok:

renamed to Kythe

https://plus.google.com/115849739354666812574/posts/WUgoSr8VVsq summary: this is a rant against the cloud-based nature of at-that-time Grok. Mentioned some other related systems and features:

desired features:

links:

'similar projects' from wikipedia:

another blog post with lists of similar projects (todo take notes on this; i think i read it years ago already tho):

---

http://pchiusano.github.io/2015-03-17/unison-update5.html#technical-note-avoiding-the-need-for-impredicative-instantiation-when-searching-for-functions notes that we probably need API functions for things like "tell me all possible supertypes of type X that could go at position Y in the code" with modifiers "exactly", "without false positives, but with false negatives" and "without false negatives, but with false positives", and the modifier "out of the following universe of types: ..."

--

"

Execution tracing

The new execution tracer collects data to produce diagrams of process execution.

Front end is the Android/Chrome trace-viewer. (github.com/google/trace-viewer)

golang.org/s/go15trace

Analysis and Refactoring Tools

We have been working on tools for analyzing and manipulating Go source code.

Analysis tools:

    oracle: a tool for answering questions about Go source code (w/ plugins for Sublime Text and Emacs).
    callgraph: display the call graph of a Go program.
    godoc -analysis=pointer: see pointer analysis details in godoc.

Refactoring tools:

    eg: a template-based refactoring tool
    gorename: type-safe renaming of identifiers in Go source code.

" -- http://talks.golang.org/2015/state-of-go-may.slide#17

output a dependencies map for any program (in terms of packages, in terms of modules (if different), in terms of files, in terms of classes, in terms of fns)

"

tessierashpool 4 hours ago

dependency graphs and code analysis are huge topics. this is probably the hard part with libraries like npm or Bundler.

the graphs can have cycles, multiple references to the same dependency, multiple distinct versions of the same dependency, et cetera. it's also all very, very language-specific. in many languages, the order of the require or import statements matter; in others, they don't. you can also have something like Clojure, with several different ways of bringing in a dependency, which makes the whole issue much more fine-grained.

prior to writing these scripts, I tried to do something more ambitious with auto-refactoring tools. these exist in Eclipse and can even be graceful in Smalltalk but my own results were not so amazing. I got somewhere with regular expressions, code generation, and shell scripting. but I also built a thing in Ruby which could auto-refactor a tiny, TINY subset of the most obvious refactorings in JavaScript?. it took me months, maybe harmed my sanity, and was definitely not the best code I ever wrote.

TLDR: compilers, zomg.

edit: forgot to say you're welcome. :-)

reply "

"

kabdib 7 hours ago

I just crack open the source base with Emacs, and start writing stuff down.

I use a large format (8x11 inch) notebook and start going through the abstractions file by file, filling up pages with summaries of things. I'll often copy out the major classes with a summary of their methods, and arrows to reflect class relationships. If there's a database involved, understanding what's being stored is usually pretty crucial, so I'll copy out the record definitions and make notes about fields. Call graphs and event diagrams go here, too.

After identifying the important stuff, I read code, and make notes about what the core functions and methods are doing. Here, a very fast global search is your friend, and "where is this declared?" and "who calls this?" are best answered in seconds. A source-base-wide grep works okay, but tools like Visual Assist's global search work better; I want answers fast.

Why use pen and paper? I find that this manual process helps my memory, and I can rapidly flip around in summaries that I've written in my own hand and fill in my understanding quite quickly. Usually, after a week or so I never refer to the notes again, but the initial phase of boosting my short term memory with paper, global searches and "getting my hands to know the code" works pretty well.

Also, I try to get the code running and fix a bug (or add a small feature) and check the change in, day one. I get anxious if I've been in a new code base for more than a few days without doing this.

reply "

"

jajaBinks 1 hour ago

For a large c/C++ code base, I use an editor called SourceInsight?. This is the most invaluable tool for navigating code I've come across in my 3 year career as a software developer. I work in a very large software company, and there are several code bases running into millions of lines of C/C++ code. My previous team had 60,000+ files, with the largest file being about 12k loc.

If you have access to logs from a production service / component, I find TextAnalyzer?.net quite invaluable. I take an example 500 mb log dump - opened in TextAnalyzer?.net and just scroll through the logs (often jumping, following code paths etc), while keeping the source code side by side. This allows me to understand the execution flow, and is typically faster than attaching a debugger. If it's a multi-threaded program, the debugger is hard to work with - and logs are your best friend. You are lucky if the log has thread information (like threadId etc)

reply "

" wazari972 1 hour ago

I like to use interactive debuggers like gdb (for C) or pdb (for python) for that.

You first have to localize a region (function) you want to study, then you reach one of its execution with a breakpoint, or a conditional breakpoint.

Then, you inspect:

reply

spion 4 hours ago

Another thing that is helpful, especially if you don't even have knowledge of the problem domain of the codebase: Write a glossary.

As you read the code and encounter terms/words you don't know, write them down. Try to explain what they mean and how they relate to other terms. Make it a hyperlinked document (markdown #links plus headings on github works pretty well), that way you can constantly refresh your memory of previous items while writing

Items in the glossary can range from class names / function names to datatype names to common prefixes to parts of the file names (what is `core`? what belongs there?)

Bonus: parts of the end result can be contributed back to the project as documentation.

reply

vineet 6 hours ago

I studied a lot of people doing this as part of my PhD?. The thing is that there are not many answers that work well in a lot of situations. Given that though, my suggestions is to iterate on developing three views of the code:

1. The Mile High View: A layered architectural diagram can be really helpful to know how the main concepts in a project are related to one another. 2. The Core: Try to figure out how the code works with regards to these main concepts. Box and arrow diagrams on paper work really well. 3. Key Use Cases: I would suggest tracing atleast one key use case for your app.

reply "

"

perlgeek 57 minutes ago

git grep.

I search for strings that appear in the frontend (or generated HTML source, or whatever), and then I use a search tool (git grep) to find where it comes from. And then I the same search tool again to trace my way backwards from there to where it's called, until I find the code that interests me.

And then I form a hypothesis how it works, and test it by patching the code in a small way, and observe the result.

Oh, and don't forget 'git grep'. Or ack, or ag, or your IDE's search feature.

reply

mVChr 26 minutes ago

I find Sublime's Cmd-Alt-↓ (goto definition) to be very useful since you jump straight to the source code for that function/class/method. When you grep you may also get all the usage instances which can be quite a lot of noise.

reply "

"

aleem 5 hours ago

Some good pointers and links here, surprisingly they miss both my favourite approaches.

1. If it's on Github, find an issue that seems up your alley and check the commits against it. Or the commit log in general for some interesting commits. I often use this approach to guide other devs to implement a new feature using nothing more than a previous commit or issue as a reference and starting point.

2. Unit tests are a great way to get jump started. It functions as a comprehensive examples reference--having both simple and complex examples and workflows. Not only will it contain API examples but it will also let you use experiment with the library using the unit test code as a sandbox.

reply

Sakes 8 hours ago

I wish I had a better answer, but I honestly just stumble around it. I typically start by trying to understand how they structured their files, then I'll start diving into the code. I wouldn't try to "understand" it completely. Just look over it until you feel comfortable enough to try to make some modifications.

Michael's code looks clean and well organized. Shouldn't be terribly difficult for someone proficient at JS.

reply 

 amorphid 7 hours ago

Glad I'm not the only one who stumbles around :)

Another thing I do is try and replicate one core feature of the thing I'm trying to understand. Like others have suggested, I like using debuggers. Recently, I wondered how debuggers work. So I built the following to find out.

https://github.com/amorphid/rails-debugger_example

reply

"

" I found that a tool called Chronon was somewhat useful (google "DVR for Java"). This tools just records a single run of a program. It is great for going forwards AND BACKWARDS and you step through the code, take a look at different threads, state of various objects, etc. "

---

lobster_johnson 1 day ago

I'd like for all apps to have a command lookup similar to Sublime Text: Type some text to match a command.

The list must be exhaustive -- if it's not there, the command cannot exist. (Unfortunately, Sublime commands are explicitly registered and the list isn't complete; it even lacks core Sublime commands.)

The list should also show keyboard shortcuts and allow a way to modify them in-place. (Sublime doesn't do that either. A real missed opportunity.)

reply

davidshepherd7 1 day ago

Emacs with ido or helm does this [1] but unfortunately it requires quite a bit of customisation, and even more customisation to get nice fuzzy matching.

It does include every possible command though, and it can show keyboard shortcuts.

[1]: http://sachachua.com/blog/2014/03/emacs-basics-call-commands...

reply

JupiterMoon? 1 day ago

Ubuntu's unity does the command lookup thing with its HUD.

XFCE allows one to change keyboard shortcut settings in a similar fashion (from within the menus as it doesn't have the HUD)?

reply

davidshepherd7 1 day ago

That's one of the things I really like about Unity. Can't remember which menu the mouse settings are buried in? No problem, just type "mouse" into the dash.

reply

pionar 1 day ago

To be fair, Windows 8+ does that too.

reply

Nullabillity 1 day ago

Unity's HUD does it automatically for any program you have open. Windows 7+'s desktop search includes programs and control panel applets, but not much else.

reply

m_mueller 1 day ago

One thing that almost always gets overlooked when critizing / trying to innovate on Xerox Parc-like interfaces, is discoverability. Look at departures from this interface (or predecessors of it) and you'll almost always find a system where it's hard for users to discover what they can do and how their actions will affect the state. Most prominently:

The only interface that has improved on discoverability so far, is OSX, especially with its integrated spotlight search in each application's help menu.

What I'd like to see is a CLI that (a) understands objects by default (i.e. PowerShell?) and (b) is discoverable, for example by using mouse interactions when you're trying to learn.

(a) would mean that the command line applications become much easier to compose. Imagine something like list / dict comprehensions in the command line:

ls

[entry.created for entry in $@ if entry.filename[0] == 'a']sort

(b) would mean that you could hover each of the commands above, inspect the possible parameters, default values, examples without having to execute anything. The whole interface could get much richer as well, for example if the output of your commands is a list of objects that have the same attributes (e.g. `ls`), it would display it in a table where each column is sortable using gasp the mouse.

reply

---

 nadams 16 minutes ago

> Dropping a newbie into Eclipse or MonoDevelop? makes them feel like they are walking around in a byzantine museum

I tried really hard to use and like free/open source IDEs like Eclipse, Aptana, and Netbeans. They all felt clunky, didn't work, or worse took away features in later versions. I finally forked out the money for PHPStorm, PyCharm?, and IntelliJ? and it's been the best money I've ever spent. Trying to learn the internals of indefero using vi was a challenge (with file_put_contents as a debugging mechanism...) - but once I figured out how to use xdebug in PHPStorm it's just been amazing. It has the feel of Visual Studio without the extra bloat.

reply

paulmd 2 hours ago

SmallBasic? is probably a good idea for young students working through these problems.

I'm a big fan of VS for C# and IntelliJ? for Java. Neither of these are Babby's First IDE, but once you have mastered the basic ideas of working in an IDE they pretty much work the way you would expect.

JetBrains?' other IDEs and plugins have also been uniformly excellent, in my experience. The VC++ parts of VS are a lot rougher, but I suppose that's to be expected.

reply

paulmd 2 hours ago

My experience TA'ing a classroom full of CS110 (introduction to programming for CS majors, taught in Java) was that the cognitive load of Eclipse was indeed very high. Most people preferred Netbeans. The people who did prefer Eclipse were the high-flyers who had done programming or worked in it previously.

Unfortunately I have found that NetBeans? is often missing some functionality around the edges. For example, it doesn't support parameterized JUnit tests (they run, they count towards success/failure, but don't display in the GUI). That's not exactly new functionality either, they've been around since what, 2010? It's a shame because Netbeans is definitely a more polished environment.

I would suggest that you check out PyCharm? and see if it suits your needs. Everything I've tried by JetBrains? has been absolutely fantastic.

reply

---

so we might need a simple environment for newcomers, like PICO-8 has (ppl are inspired by the Commodore 64 too, and BASIC, and HyperCard?)

and spreadsheets should be thought about too. mb the IDE/devenviron should have a 'spreadsheet mode' where ur vars go into a spreadsheet. In this case, we need to keep track of the spatial layout of vars into spreadsheet cells, so metadata annotations into the source code. Also, as Lion Kimbro pointed out, visualizing source code is a very open problem but the first thing we need to do is obvious; have a std way to add metadata annotations to sourcecode that can tell the visualizer to represent it in some way or another (i cant immediately find the hyperlink to that)

probably should have some sort of GUI builder view too

and for web applications, a way to interact with the application and then for it to tell you which sequence of API commands would have accomplished the same thing

---

here are the list of IDE keyboard shortcuts that are so crucial that Quantopian, which built a minimalistic Python Web IDE as a part of a larger project, offer:

    Build Algorithm: Ctrl + B
    Indent: Ctrl + ]
    Outdent: Ctrl + [
    Toggle Comment: Ctrl + /
    Search Code: Ctrl + F-- https://www.quantopian.com/posts/ide-extras

Action Windows Keystroke Apple Keystroke Build Algorithm Ctrl + B Cmd + B Indent Ctrl + ] Cmd + ] Outdent Ctrl + [ Cmd + [ Create/Remove Comment Ctrl + / Cmd + / Search Code Ctrl + F Cmd + F Undo Ctrl + Z Cmd + Z Redo Ctrl + Y Cmd + Y

-- https://www.quantopian.com/help#api-ide-tips

ipython can autocomplete when you press tab at the end of:

image=imread('sdk2_cor_11-57_16x_77332746_

---

oot repl should have a mode where each new line automatically starts out with the contents of the previous line, as if you had pressed 'up-arrow'. This would be very helpful in eg an alda music composition session, or anytime you are trying to get a command right, get a regexp right, etc.

---

in ipython repl you can tab-complete a string literal that looks like a filename -- that's great!

---

in ipython repl it appears you cannot move left/right one word -- we need that! in fact we should have all the main movement stuff that i use in viperre

---

tab-completion in the REPL in the IDE

---

http://mo.github.io/2015/10/19/chrome-devtools.html

---

https://github.com/ethereum/mist/blob/master/MISTAPI.md

---

system for dynamically doing parens for indentation:

http://shaunlebron.github.io/parinfer/index.html

https://news.ycombinator.com/item?id=10547912

da4c30ff 9 hours ago

For emacs, there's the electric-indentation-mode and the fantastic aggressive-indent-mode.

https://github.com/Malabarba/aggressive-indent-mode

reply

msbarnett 8 hours ago

This reminds me more of Paredit, in that it handles s-expression aware source transformations, and not just indentation:

http://emacsrocks.com/e14.html

I would deeply love to see this kind of inference engine ported to emacs as an alternative to Paredit's chords

reply

ruricolist 5 hours ago

A more direct comparison for Emacs would be `adjust-parens`:

https://elpa.gnu.org/packages/adjust-parens.html

reply 

 alphapapa 8 hours ago

Wow! This is fantastic! This seems to do just what Parinfer does. Why isn't this mode more well-known?

This makes it even better:

    (defun my/lisp-dedent-adjust-parens ()
      (interactive)
      (save-excursion
        (x4-smarter-beginning-of-line)
        (call-interactively 'lisp-dedent-adjust-parens)))
    (defun my/lisp-indent-adjust-parens ()
      (interactive)
      (save-excursion
        (x4-smarter-beginning-of-line)
        (call-interactively 'lisp-indent-adjust-parens)))
    (local-set-key (kbd "<M-left>") 'my/lisp-dedent-adjust-parens)
    (local-set-key (kbd "<M-right>") 'my/lisp-indent-adjust-parens)

Now you can just M-left and M-right to adjust the indentation of any line, regardless of where the point is, and adjust-parens fixes the parens for you.

reply

nnq 20 hours ago

Am I the only one who is incredibly annoyed by how Jetbrains IDEs indent code?! Really, the fact that they totally fail to indent even mildly broken code is infuriating. At least ten times a day I feel like yelling at webstorm "YES, I know that that code is broken, that there are two unpaired {s and one unpaired ', but I'll fix that F LATER! NOW I just want to type this code here and have it properly indented even if there's broken code 10 lines above it and 20 lines below it. I KNOW, and I DON'T care NOW!".

I just want to download stuff from my head to the editor before I forget it, then later fix the mess, and have the IDE/Editor still help me in the meantime. If it needs to temporarily revert to a caveman-style indent-like-the-previous-line or event to temporarily disable auto-indent, I'm ok with that, but don't horribly mess up what I type in failed attempts to semantically auto-indent broken code that I don't wanna fix right now...

reply

taternuts 19 hours ago

No - you aren't the only one, this infuriates me sometimes. The worst is when you have a file that someone accidentally mixed indentations or something, or use 2 spaces instead of 4 (even 4 spaces seems to break for me) for continuation/promise stuff. I'll enter insert mode and it'll be in-explicably tabbed out 5-6 times further than it should and I have to exit insert mode and manually move over to the correct spot or finish typing the function in shit-mode then manually fix the indenting. There's been several times where I've given up in frustration and opened up VIM or sublime text because I don't want to deal with it anymore.

reply

andrewchambers 17 hours ago

Parsing correct code is easy. Parsing broken code is really hard because they have no way to predict the mistakes people will make.

reply

---

https://bugs.ruby-lang.org/issues/11252

suggest mispellings when an attribute etc name isnt found

---

repl should accept both 'exit' and 'quit' (like irb)

---

repl should allow remote connections (via a socket?)

repl should work with jupyter

---

compiler should incrementally tell text editor how to indent the recommended way (eg the code in this article should be unnecessary for an ide: http://davidvgalbraith.com/how-i-fixed-atom/ )

---

samatman 288 days ago

parent on: Spacemacs – Emacs advanced kit focused on Evil

I like this development. I feel that we have three editors (really types thereof) for a reason.

The Sublime/TM/Notepad++ crowd cares about OS-native integration. I use Sublime frequently because after a solid decade+ living in OSX land, my fingers know how what to do, and neither vim nor emacs respect that without considerable massaging.

Vim fans want to use an elegant command syntax. I watch vim users code and always make a point to learn how to vim, eventually. The only reason I don't, is because I haven't.

Emacs users want/need the programmable, extensible runtime. Emacs is a programming language; particularly in Lisp development, Emacs often contains programs that are basic/standard parts of the toolchain and not found in other editors. I use Emacs because I like it, but more importantly, because I have to.

Combining the elegant syntax of Vim with the extensibility of Emacs, as well as some out-of-the-box support for the basic OS-native commands, is a very good start.

---

should modify this to work with Oot too:

https://github.com/pgbovine/OnlinePythonTutor/

http://pythontutor.com/

 StevePerkins 4 hours ago

> The mental image of a huge ram sucking IDE with code completion for frameworks is simply incompatible with

> what I would consider the ideal creative process for me as programmer.

Java has long been my primary professional language, and over the past few years Go has taken on a strong secondary niche at my job. I'm big fan of both, and tend to play Switzerland in arguments between them.

That being said, the best Go IDE out there right now is the official Go plugin for IntelliJ?... which again, happens to be the best Java IDE out there. If you are doing modern software development in ANY language, then you are probably traveling one of three paths:

(1) Using an IDE based on JetBrains? or Eclipse.

(2) Using a variant of Microsoft Visual Studio, which is about an order of magnitude more bloated than #1.

(3) Using a plain text editor, which for a typesafe language is a bit daft.

reply

logicchains 4 hours ago

What does the Go plugin for IntelliJ? offer that Go plugins for Emacs don't? My setup right now has live error checking (highlights errors as they occur), gofmt on save, safe refactoring via gorename, jump-to-definition, proper autocomplete, and Go Oracle integration, for e.g. finding all callers of a method. Due to being Emacs it also has much better support for Vim keybindings via Evil mode.

reply

dlsniper 3 hours ago

Debugging, cross-platform, integration with a lot of other languages, and databases, local history, out of the box configuration for everything you've just mention (including the Vim key working mode, via a plugin) so that people don't spend time in doing all of that and so much more :)

reply

geoka9 19 minutes ago

Are using go-projectile for all of that? If not, what did you use for gorename integration?

reply

iainmerrick 4 hours ago

(4) Xcode? There are lots of iOS programmers out there.

reply

---

some important IDE shortcut keys:

"

Shortcut Keys

Here are some keyboard short-cuts built into the IDE to make coding easier.

Short Cut Description Ctrl + Space Initiate full auto-complete Ctrl + / Toggle comments on selected code Ctrl + Up/Down Increase/decrease font size Ctrl + S Save document and compile project Ctrl + D Remove line Alt + Up/Down Move line up/down Alt + Shift + Up/Down Copy lines up/down Alt + 0 (zero) Collapse all code blocks Alt + Shift + 0 (zero) Expand all code blocks

The full list of short cuts can be found on at the ACE Editor open source project.

"

ace editor:

https://ace.c9.io/#nav=about

---

ok, so i've personally been avoiding IDEs b/c i am very attached to my remapped vi-emulation mode in Emacs, which i think lets me edit text real fast because all the main movement keys are in the home row.

however, i mentioned this to a friend (DR) and he immediately remarked that his favorite IDE could probably do that with a plugin. So i checked, and indeed, PyCharm?, NetBeans?, Visual Studio, Eclipse, all have plugins available that claim to be vi emulators. Dunno if they allow key remapping in these plugins, but surely i could edit their source code, assuming they're open source (which i didn't check, but at least some of them were).

So, i can maybe use IDEs!

---

Here's a list of the top IDEs (both for Oot to try to support, and for me to learn):

http://pypl.github.io/IDE.html

the ones to note for me are probably the first 14:

1 Eclipse 23.82 % -4.5 % 2 Visual Studio 23.78 % +1.4 % 3 Android Studio 9.55 % +2.7 % 4 Vim 7.92 % -0.1 % 5 NetBeans? 5.79 % -0.7 % 6 Xcode 5.68 % +0.1 % 7 Sublime Text 4.48 % -0.0 % 8 IntelliJ? 3.78 % +0.7 % 9 Komodo 3.58 % -0.4 % 10 Xamarin 2.21 % +0.3 % 11 Emacs 1.83 % -0.2 % 12 PhpStorm? 1.52 % +0.3 % 13 pyCharm 1.41 % +0.5 % 14 Light Table 1.25 % +0.2 %

Android Studio and Xcode and Visual Studio (and Xamarin?) are platform-specific, and PhpStorm? and PyCharm? and IntelliJ? are language-specific. However, MS has a big cross-platform push and now has/is making 'Visual Studio Code' which is cross-platform (dunno if it is being combined with Visual Studio on this list); and PyCharm? is language-specific to a language i like. So that leaves:

(what about Atom, brackets.io? Ace, jEdit? http://spacemacs.org/?)

https://blog.codeanywhere.com/most-popular-ides-code-editors/

Notepad++, SublimeText?, Eclipse, NetBeans?, intellij, vim, visual studio, phpstorm, atom, emacs

https://www.g2crowd.com/categories/integrated-development-environment-ide Visual Studio 90 IntelliJ? IDEA 77 Xcode 76 NetBeans? 71 PHPStorm 67 Eclipse 67

http://www.cyberprogrammers.net/2015/11/top-9-best-cc-ides-for-windowsmac-os.html

Jetbrains CLion visual studio xcode eclipse netbeans Code::Blocks ...

https://www.quora.com/What-is-the-best-C-C++-IDE Visual Studio Code::Blocks CLion Eclipse with CDT vim netbeans Code::Blocks

http://codecondo.com/10-best-ides-linux/ also mentions bluefish, i saw that one somewhere else too

http://programmers.stackexchange.com/questions/5972/what-are-the-most-popular-ides-per-language mostly stuff already listed

https://www.quora.com/Which-free-IDE-is-the-most-popular-in-general-Why links to a lot of other top lists, including some above, and: Developper Productivity Report: intellij netbeans

http://stackoverflow.com/research/developer-survey-2015#tech-editor

NotePad?++ 34.7% Sublime Text 25.2% Vim 15.2% Emacs 3.8% Atom.io 2.8%

http://stackoverflow.com/research/developer-survey-2016#technology-development-environments Notepad++ 35.6% Visual Studio 35.6% Sublime Text 31.0% Vim 26.1% Eclipse 22.7% IntelliJ? 17.0% Android Studio 13.0% Other 12.9% Atom 12.5% Xcode 10.3% NetBeans? 8.1% PhpStorm? 7.4% Visual Studio Code 7.2% PyCharm? 6.8% Emacs 5.2%

https://discuss.codecademy.com/t/poll-which-code-editor-do-you-use-the-most/11255 notepad++ sublime text other web-based atom brackets eclipse terminal-based visual studio netbeans

note: CLion and Code::Blocks are mentioned a lot, but they are C/C++/Fortran-specific. I'll leave IntelliJ? in even though it's Java-specific b/c it (and Java) is so popular.

searches:

https://www.google.com/search?q=eclipse+vim+netbeans+sublime+intellij https://www.google.com/search?q=eclipse+vim+netbeans+sublime+intellij+brackets+atom https://www.google.com/search?q=most+popular+ides https://www.google.com/search?q=best+ides&oq=best+ides https://www.google.com/search?q=top+ides

---

so the contenders appear to be:

---

narrowing this down a bit? (not really):

non-open source:

people say Atom is a bit slow unless ur machine is real fast.

---

toread:

https://johnpapa.net/web-dev-with-editors-and-ides/ https://www.sitepoint.com/sitepoint-smackdown-atom-vs-brackets-vs-light-table-vs-sublime-text/

---

ok, what am i most worried about missing if i move from Emacs to another text editor or IDE?

nice-to-haves:

---

in vim:

note: try Neovim, the Vim rewrite with Lua and msgpack API and async plugins (so IDE stuff doesnt lock up the UI while it's compiling). Also in Vim ppl use Syntastic, but the neovim alternative is neomake.

other alternatives? vis? xi?

note also https://github.com/rhysd/NyaoVim which i guess embedds NeoVim? in a website?

---

todo try http://company-mode.github.io/ in emacs

mb also projectile, helm, magit

and emacs-ipython-notebook

https://news.ycombinator.com/item?id=8677399

---

git overlays:

http://gitless.com/ http://www.git-legit.org/ not maintained as well as gitless, according to https://www.reddit.com/r/git/comments/2xu8k1/gitless_a_version_control_system/ ---

http://stateofjs.com/2016/profiles/

top entries in Favorite Text Editor: SublimeText? Atom Webstorm Vim VSCode

---

https://github.com/oakes/Nightlight/blob/master/README.md

---

"Why can't make/cmake/ninja/etc. support this in a language independent way? Just basic queries/commands like:

   1. run any build steps that directly depend on file X
   2. run any build steps that directly or indirectly depend on file X
   3. get whether the build of X succeeded or failed, and console output"

---

" Rust should provide a solid, but basic IDE experience ... The problem statement here says "solid, but basic" rather than "world-class" IDE support to set realistic expectations for what we can get done this year. Of course, the precise contours will need to be driven by implementation work, but we can enumerate some basic constraints for such an IDE here:

    It should be reliable: it shouldn't crash, destroy work, or give inaccurate results in situations that demand precision (like refactorings).
    It should be responsive: the interface should never hang waiting on the compiler or other computation. In places where waiting is required, the interface should update as smoothly as possible, while providing responsiveness throughout.
    It should provide basic functionality. At a minimum, that's: syntax highlighting, basic code navigation (e.g. go-to-definition), code completion, build support (with Cargo integration), error integration, and code formatting."

---

this looks really cool!!

https://github.com/hchasestevens/astpath/blob/master/README.md

---

"Style considerations aside, macros have tool problems. Macros are notoriously hard to debug, and honestly it needn't be that way. If your editor knows all about macros, then you should be able to click to see the expansion, and click again to see its sub-expansions, all the way down to the primitive functions. Some editors can do this, but none of them (that I'm aware of) handle macros as cleanly or seamlessly as they do normal functions."

---

"My main problems with IDEs...the zippiness on reaction to my typing is another huge deal. If it's anything other than instantaneous, then I notice my editor in a negative light. "

---

sreque 8 hours ago [-]

I developed at a Windows-centric shop for several years using C# and Visual Studio, and I can personally attest, at least in 2013, that stock Visual Studio is pretty far behind Java IDEs in its capabilities. At the time everyone I talked to recommended I get my manager to get me a copy of ReSharper?, but it wasn't in our team's budget. At least in 2013, here's where I remember C# IDE support was lacking:

As a side note, I think the plugins ecosystem is another area where Eclipse has an edge over Intellij. For instance, when I tried Intellij's code coverage tool I eventually gave up on it because it had a critical bug I couldn't diagnose that resulted in incorrect code coverage being displayed.

reply

breischl 1 hour ago [-]

A lot of this has been at least partially addressed since VS2015. There is built-in code search (ie, "find me any language construct with these letters in it"), there's support for basic refactorings (rename, extract method, extract interface, etc). I got used to all the built-in stuff before someone talked my into Resharper, and found most of the built-in stuff is actually better these days. Faster, anyway.

There's always been codegen support with snippets, although I never found too much need for it, personally.

The tools ecosystem is pretty weak though. I always found TestDriven?.NET to be the best test runner, although Resharper's is OK if slow. I actually like NUnit a lot better than JUnit, but YMMV.

reply

---

" “Refactoring” Erlang usually consists of breaking large functions down into smaller functions. There is not much mental effort involved; however, due to Erlang's syntactic peculiarities, it can be tedious converting anonymous functions to named functions. Perhaps a clever IDE will eliminate this tedium one day. "

---

enobrev 86 days ago [-]

This looks like an exceptionally useful tool! Thanks for making and sharing it. The video is excellent.

It reminds me of a feature I've always wanted, which would be a code unravel-er. Basically I'd like to be able to select a line anywhere in a codebase, and have said codebase expand to show me the entire execution path as if it were in one single scope, with the ability to re-collapse sections back into loops and functions while reading.

I think it would help to better understand the codepaths that can start to get fuzzy when jumping between abstractions. It would be great - not only for understanding unfamiliar code - but also for double-checking logic across longer code paths.

At any rate - great idea, great implementation, and beautiful website.

fazzone 86 days ago [-]

I am playing around with an idea like this for editing Clojure in Emacs with cider-mode. You have to manually build the 'thread' that such a code unravel-er would return, but then you can read and edit functions from many files in one buffer. You start with the highest-level function you are interested in, and then pull the definitions of functions it calls into view as needed.

https://github.com/fazzone/multifiles.el/tree/cider-hacks

CPAhem 86 days ago [-]

If you're looking for a similar tool which does have a code unravel-er look at SciTools? Understand[1] for C/C++/Java

My previous company used Understand on a large unfamiliar codebase, it helped greatly, but was pricey.

[1] https://scitools.com/

popeko 86 days ago [-]

There's also Source Insight [1] which supports C/C++/Java/Obj-C - quite a fantastic tool, but unfortunately it's Windows only (Wine works with a few hiccups)

[1] https://www.sourceinsight.com/

Operyl 86 days ago [-]

Wait a second, a tool that supports going through Obj-C is Windows only? That’s .. a shame.

---

need:

---

" all the cool features: auto-complete, error highlighting, symbol tooltips, bracket-matching, code formatting, function insights and star expansion ... i took Roslyn and used it to add C# support, intellisense and all. LINQ queries on Excel tables, for God’s sake, you can’t tell me that doesn’t make your heart beat just a little bit faster. "

---

some neat features here in 'Editable Compiler Artifacts' and 'Binary Explorer', 'Firefox x86 Disassembly', 'Call Graph', 'Binary File View':

https://hacks.mozilla.org/2018/04/sneak-peek-at-webassembly-studio/

---

I've since jumped ship again to vscode (along with typescript), and in my humble experience / opinion, vscode & it's language server protocol (LSP), alleviates quite a bit of this. It abstracts away a lot of common operations from a language to the languages compiler, while providing a consistent front-end. I think if scala eagerly adopts supporting this it would be a good thing. Having a language server protocol applies back-pressure in a certain sense on language features, if you are going to add them, then the tooling (and LSP) needs to support them.

---

logpoints -- like breakpoints, but logging data is printed to debug console -- can be added during execution without recompiling

---

carljv 6 hours ago [-]

The Jupyter team deserves every accolade they get and more. The console, notebook, and now JupyterLab? are some of the key reasons why Python's data ecosystem thrives.

I think Jupyter notebooks are quite useful as "rich display" shells. I often use them to set up simple interactive demos or tutorials to show folks or keep notes or scratch for myself.

That being said, I do think the "reproducibility" aspect of the notebook is overblown for the reasons other comments cite. Notebooks are hard to version control and diff, and are easy to "corrupt." I often see Jupyter notebooks described as "literate programs," and I really don't think that's an apt description. The notebook is basically the IPython shell exposed to the browser where you can display rich output.

This is where I think the R ecosystem's approach to the problem is better (a bit like org-mode & org-babel). For them, there is a literate program in plain text. Code blocks can be executed interactively and results displayed inline by a "viewer" on the document (like that provided by RStudio), but executing code doesn't change the source code of the program, and diffs/versions are only created by editing the source. At any point, the file can be "compiled" or processed into a static output document like HTML or PDF.

This is essentially literate programming but with an intermediate "interactive" feature facilitated by an external program. RMarkdown source doesn't know its being interacted with or executed, and you can edit it like any other literate program.

Interaction, reproducibility, and publication have fundamental tensions with each other. Jupyter notebooks are trying to do all three in the same software/format, and my sense is that they're starting to strain against those tensions.

reply

your-nanny 2 hours ago [-]

I agree, 120%.

I like the r approach so much more.

reply

---

BayleShanks RecentChanges Bayle Shanks's website
Comments on proj-oot-ootIdeNotes1 This page is read-only View other revisions Administration
Last edited 2018-05-06 00:59 UTC by BayleShanks (diff)