I have downloaded multiple OCaml IDE's / plugins and NONE of them work. I have no clue if I have a directory problem or if something else is at fault. I can access the OCaml console through cygwin just fine but it is not very useful for dealing with larger files. I am a total OCaml noob and have no clue how to fix my problems. I have been reading every post on OCaml here and nothing is helping. I am hoping that somebody can help me because this is very frustrating! Thanks to all who reply.
OCaml modes for Emacs and Vim work perfectly (and they run on MacOS and Windows, of course). I heard Geany works well as well.
I'm not saying everyone must learn Emacs and Vim; I understand that it's a kind of interface that beginners maybe don't want to get into -- and supporting other editors well for OCaml is a problem that we need to fix. But if you want reasonable support for pretty much every kind of text format out there, they're still good choices.
Finally, if you have a decent terminal / command-line (if you are on Windows that might require running a GNU/Linux virtual machine), pretty much every editor will be fine if you compile stuff by hand from the terminal (which is not particularly hard). In-Editor support will still provide you with a better experience, in particular allowing to jump right to the place in your code where the compiler says there is an error, but as a beginner you can go a long way without even that.
PS: it would be extremely useful if you took the time to spell out precisely what your problem with each tool was, and send that information to the respective maintainers. I think the main problem with these tools is the lack of testers. Help the future people that will try these tools by helping the maintainers fix them!
I'v recently looked at OcaIDE for eclipse - and it seems to work.
You need perhaps set some configuration variables (paths to ocaml compiler,...), but I don't remember any quirks.
I would like to thank everybody for their help. I finally found some installation instructions for the tuareg mode in EMACS. In case anybody else is having the same problem that I was there are VERY clear instructions here
How to install tuareg
Hopefully I can now translate some stuff into OCaml that I have been working on in other languages and post some of my projects. Thanks again for all of the help.
You can use Notepad++ for Windows. It is more intuitive for than Vim or Emacs for the beginners. And it has a syntax highlighting for Caml and you can assign hotkeys for compiling executing the program.
I would suggest using OcaIDE. I've done some fairly large projects with it, and it's not bad. Emacs (with Tuareg mode) is also a good option. If you're having trouble with setup, I wrote a guide for OS X: http://www.princeton.edu/~crmarsh/ocaml_dev_environment/
What is the current state of the art development environment for the D language?
I know about DDT for eclipse, Visual D and Codeblocks. Each has its disadvantages - DDT doesn't have a debugger, Visual D is for windows (and Visual Studio) and CodeBlocks doesn't have emacs keys bindings and I have some bad memories about it from my CS intro days.
Using tools like emacs + gdb is good enough for simple programs but when the code gets bigger I find it really hard to get around the code just with emacs. Without smart code completion and code layout (meaning, list of all functions/classes in a file) it gets really tedious and I feel I spend way too much time struggling with the editor instead of just writing the code I want to write.
Additionally, with Java+eclipse for example I have this neat documentation popup window whenever I mouse over a method/class. I find this extremely helpful, and really miss it when working in emacs.
And debugging with gdb is really just... antiquated.
So, for the love of god, save me from the 1970s! :)
Although, any tips concerning emacs and gdb (if nothing else exists) would be appreciated.
Have you looked at Mono-D?
Further, Sublime Text 2 has pretty good D support. I also maintain an improved highlighter for it.
I switched from Code::Blocks to Mono-D half year ago. However, there is a new kid on the block NetbeansD. For simple stuff Geany and Kate have enough support. :)
All this said, Mono-D beats all competitors at the moment, so try that one first.
Doesn't Emacs have GDB integration that allow you to do stepthough and add brakepoints - all in emacs?
I would suggest you try to configure your Emacs.
I also suggest using a good build tool(I use Rake when I program in Vim, but Emacs might have an elisp build tool), and the ctags and cscope really help in mapping big projects.
In your IDE/editor of choice, do you use only the default shortcuts out of the box, or do you customize them? One answer per response, and why you do.
In my programming career, I have come full swing around on this. I started out in emacs/vim on a terminal window with a bare-bones install, no customizations, then over time swung fully into completely customizing them both, getting them just right, such to the point that other emacs/vim users could not even work at them (changing movement keys, etc). More recently, I have been working in Eclipse, the JetBrains IDEs, Visual Studio, and I have continued to make heavy modifications to each, so that they all pretty much behave the same way across all my machines. Obviously, this takes some effort to maintain, and every new IDE means a whole slew of command learning and changing, and then some (like Visual Studio) don't have certain commands out of the box, so they require plug-ins to achieve the same functionality (grow selection, delete words by camelCase, etc).
To be fair, I am an above-average speed typist, and I can work productively in any of these IDEs, but I have started to yearn for the simplicity of just going back to straight vim shortcuts, and using simple vim plugins to make it work in my IDEs. Then, at least, all I would need if I wanted to change anything would be a single custom .vimrc.
Suggestions, ideas?
In my IDE, I use a slightly-customized version of the default keymap. More of it is default than not. I prefer using the default whenever possible: you learn it once, and then it's the same no matter where you need to use that same IDE (it's reasonably safe to assume that most installations have the default keymap, if they even let you change it at all)
My situation might be different than yours. In my previous positions, I used to code exclusively in vim. In my current position, I don't change IDE's often because I don't have to: 100% of my development is in one language, and I've been working at that position for several years now.
That being said, I did just change IDE's (from Zend Studio to PhpStorm, by the way) recently, so the only changes I've made to PhpStorm's default keymap are to make it more like the several Zend Studio shortcuts I couldn't bear to part with.
Otherwise, when I'm working with vim, I think in vim; when I'm working with PhpStorm, I think in PhpStorm. At this time, I don't think it's worth my time/effort to completely customize my keymap, any more than I already have. If you're working with multiple IDE's, your situation is probably quite different from mine.
Ultimately, I don't think you're going to find a "right" answer to this question. Nobody else knows your preferences or situation better than you do. It's a trade-off either way, whether you go the default or the customized route. Use your best judgment and decide which way you're going to go, and be happy with that choice.
Best of luck in your development efforts!
I think Xcode is a good IDE, but having used Eclipse for Java development in the past I am quite underwhelmed by XCode's code completion and error/warning feedback. (Most of the time, XCode seems to simply try to match the beginning of a text fragment to "words" in the same document, without even using type information to try to determine the appropriateness of a suggested completion.)
Does anyone have ideas or tricks to make XCode approach Eclipse's cleverness, or to realistically develop Cocoa apps with other IDE:s than XCode?
EDIT: Worth keeping an eye on this: code.google.com/p/objectiveclipse/
The good news is, Apple’s working on the problem. One of the goals of the clang compiler project is to create a reusable parser which can be used for better code completion and refactoring support. Indications are that this has borne fruit in the latest Snow Leopard seeds.
Quite simply: no.
You can do almost everything by hand using your favorite text editor but it's not at all recommended. Try designing interfaces without Interface Builder for example.
My advice would be to just stick with Xcode and learn its way of doing things. Yes, it will be different and sometimes might not be "better" in your Eclipsed eyes. Console yourself in the fact that Apple's managed to release some great products using Xcode.
My personal experience is that, each time I use Xcode, I find a new trick which I can add to my bag. Xcode is far more full-featured than what you might think at first (or second) glance.
I've long voiced my rants about what's wrong with Xcode (and what's not wrong with Xcode). But you really don't want to use another tool. And without breaking NDA: Xcode 3.2 with SnowLeopard: Hooray. (Compared to what we have; not compared to what we might want.)
That said, to your original question about code completion, I personally turn off auto-completion in favor of on-demand completion. I find it far more useful and less distracting. In the Code Sense panel, set "Automatically Suggest" to "Never" and make sure the other two options are selected ("Show arguments in pop-up list" and "Insert argument placeholders...") This will do completion in a pop-up box when you hit Escape, making it easy to scroll through looking for what you want. I find that I have to type a lot less this way, especially for methods that are not unique for many characters. 80% of the time, it's highlighting the right thing already.
I have certainly felt your pain — as an experienced Java developer and frequent Eclipse user, I've wished for the same features myself. Unfortunately, I'm not aware of anything that fits the bill. I don't think there was any satisfactory resolution to this SO question, either.
However, I think you'll be quite happy with the improvements to Xcode code completion coming in Snow Leopard — it's vastly smarter about filtering the list of possible completions. Also, there are new conveniences for coding, such as inserting a starting bracket when you forgot one, etc. To my knowledge, there is still no predictive compiling like Eclipse, though.
Is anyone aware of an IDE other than Eclipse that supports predictive compiling and warning/error reporting? Does Eclipse itself support the feature for languages other than Java, such as C++? I'm led to wonder whether the fact that Java is built with independent .java files rather than .h and .c/.cpp/.m files makes it simpler to predictively compile. Also, anything compiled with gcc requires a little more care and attention than the comparatively simpler javac command. Any thoughts?
Check out JetBrains' new IDE called "App Code". It's still in the Early Access Program, but even with the Early Access bugs it is hands-down better than xcode 4.
http://www.jetbrains.com/objc/
emacs and/or vim
Xcode does have some context awareness, when you are sending a message to an object it will generally have the "ESC" list pull up meaningful arguments.
One thing I strongly recommend is looking into text macros. These are not really type aware, but they can save a ton of typing - for instance, after #implementation type "init" and then hit control-. (period) to activate the text macro. It will fill out a whole init method for you. You can create your own, or override the existing macros.
Hi I mostly do C++, Objective-C programming. And I found Xcode plus an auto completion/macro plugin (Completion Dictionary) quite adequate.
However, all people seem to praise over their pure text editors. I tried Textmate for a bit; liked its simplicity but dislike its files/framework handling.
Am I missing something here? Or, do Vim or Emacs have auto-completion as good as Xcode?
Pull up a chair son, let me speak on this.
Well before the days of Xcode, there was VIM and Emacs. I know it's hard to imagine, but it's true.
Many people got accustomed to VIM/Emacs, and thus continue to use it.
Emacs is extremely customizable, and offers pretty much everything you can imagine (including a built in shrink and the towers of hanoi). You can easily call compilers from Emacs, and create your own extensions as needed.
VIM has incredible regex engine (Emacs does as well) and is very handy because (VI) comes with pretty much every Unix OS, and works fantastically if you don't have arrow keys (yeah yeah, real old school). People are very good with using keys to move around documents, without having to use the mouse.
The same is true with Emacs as well, but for me, I find cursor motion much easier on VIM.
The text editor war is fueled with as much religious zealotry as the Mac vs PC war, and the answer is pick the best that works for you. If you like Xcode, great, continue to use it, however good luck if you're ever forced to work on a PC or Linux machine. Personally, I use Emacs to code, VIM to manipulate text and Firefox to look at lolcats.
I really don't understand why emacs props up when people talk about text editors. In my experience it's more like eclipse (or one of those other platforms/IDEs) than vi because it is an environment, which happens to be good at text editing.
As an IDE emacs features version control, live compilation, spell checking, auto completion, debugging, code browsing and lots more for a wide variety of SDKs. For the rest of your computing needs it's an email/news/web/irc/twitter/xmmp client, calendar, organizer, calculator, terminal emulator, remote editing, speadsheets, games etc. etc. etc.
After Dijkstra: "Emacs is no more about text editing than astronomy is about telescopes"
What you are missing is that Emacs and Vim are actually IDEs.
vi is ubiquitous on UNIX systems, and Emacs almost so. AFAIK, Xcode is on one platform.
Having a powerhouse IDE is a great thing, but everyone should have a smattering of skill to keep them functional on any platform they might be dropped into.
It's all up to your preference.
Some people like to work with lightweight texteditors like (g)vim, emacs, pico, etc.
Others like to work with IDEs like MS Visual Studio, Eclipse, Xcode.
As long as your environment is compatible with the text editing technology, it's all up to you.
By the way, I like working with Eclipse and vim because they are what I used to learn programming ;)
The main reason you seem to think people like Emacs/Vim is for code completion. People like Emacs/Vim cause they are both MADE for editing text. You have control and options available to you that other editors just don't have. Once you get REALLY good at using one of these programs you want these key bindings / commands available everywhere. Macros, regular expressions, moving around by search/word/paragraph/function, interfacing with version control, complicated undo/redo and copy/paste functions and extension options are just a FEW of the things that these editors do really really well.
Code completion is just one of MANY things that can make writing programming easier. Emacs/Vim can handle ALL of them (natively or by exntensions).
No, not really. It's a matter of preference really. I liked working in Visual Studio 6, but nowadays the newer versions are just too bloated. So if I can do something outside VS I usually do it without opening the whole IDE box.
On windows I like notepad2 and gvim. I've customized vim to the point where it suits my needs perfectly, so I don't have to think about what and where.
But, it's good to mention that (you could also figure that out by yourself by reading these kinda posts) a lot of users uses vim/emacs/... 'cause of the heard-its-the-best/cool-factor/actual-usability. So if it doesn't suit you, don't use it. Nobody's gonna look you the wrong way cause of that.
For me most the two most important features are:
Emacs key bindings, as that is what my fingers are compatible to.
Open-source, for the freedom it provides. Being tied to one platform is anathema.
These days I mostly use Eclipse for programming (set to Emacs keybindings) and FSF Emacs for reading mail and some occasional LaTeX.
I personally love emacs. I've used vim and a handful of IDEs. Vim and emacs both have great communities where people are willing to code up features for just about any language. I don't know of any IDEs that, say, support Haskell. It all depends on what's important to you. Both have extension languages, though IMO, emacs lisp is the better of the two. The ability to ignore the mouse is the main thing I like as well. So many IDEs also feature emacs and vim compatibilty modes or extensions. They both have a large time investment, but both are worth it. Sooner or later, you will choose which suits you, vim/emacs/IDE, and then stick to improving your skills with it.
When you are using Emacs, you can install Cedet or Autocomplete package to use name completion for some languages (C++ is pretty good, while Obj-C is still not supported), in addition to rich editor functionality
emacs is powerful. I use emacs with vimpluse.el so that I can use the vim key bindings with all the emacs features.
I use Vim mostly for the input model. Once you have become proficient in the input model, going back to an editor where you are forced to use a mouse feels clumsy and ultimately (at least to me) irritating. It is a lot more efficient to type "ci'" to alter all the text between two single quotes, then taking your hands off of the home row, finding and selecting the text with the mouse and finally hitting 'delete'.
I have only used Emacs briefly and while I prefer Vim, I am jealous of some of its features. But I ultimately went with Vim because I find the chord-input model that Emacs uses to put unnecessary strain on my fingers.
I have Xcode and TextMate and I don't use them although I know they can be very powerful. Instead I use Vim (or MacVim if you prefer). Why ?
Because it's light, fast, addictive, powerful, customizable...
I could go on like this for a long time but the most important thing is that I can do all I want with Vim.
Whatever the editor you use, the best editor is the one you master (almost) perfectly.
I don't use vi to do my coding; however, I do, when available, use vi emulation in my editors. When I am doing Java coding in IntelliJ I use the IdeaVIM plugin which gives me vi support in IntelliJ's editor. This means I almost never have to take my fingers off of home row. I navigate with the keyboard (h,j,k,l), cut/paste with yy, dd, etc. And of course when I do need the power of a full feature GUI editor vi emulation doesn't keep me from using those features.
It drives me nuts that XCode doesn't have vi emulation in its editor. Seems like functionality that any decent IDE should have.
TextMate just feels lighter to me. Off the top of my head:
It has great support for jumping between files and methods within files. Think Quicksilver for files/methods. With a file open for editing, hit command-shift-t to bring up a floating panel listing all the methods in the file. Start typing and the list filters itself down. Select the method you want and hit return to jump to it. Xcode has something like this but the sting matching is more literal.
Lots of built in text expansion. Type a trigger and hit tab to have it expanded. For example, on a new line typing m and then hitting tab creates a method for you. The tab key then intelligently jumps to the various parts of the inserted text so that you can edit them in place. These are such a huge timesaver it's ridiculous.
Nice plugin support for Subversion and Git. Probably other VCSs too.
Completions (like Xcode) and history. TextMate allows you to tab-complete basically any text that exists in the file. So once you type a variable name or method call once, you can use tab to auto-complete it anywhere in that same file.
Smart past board with history, nice built in diffs, theme support, good keyboard support, find in files and across projects (with RegEx) and probably more that I'm forgetting.
Anyway, that's enough from me.
Personally, I love TextMate, because it's actually a really lightweight solution. Granted, I have not used Vim or Emacs in depth (I like my GUIs)...although I do thoroughly enjoy the Control-based cursor navigation (Control-A is beginning of line, Control-E is end of line, Control-F and Control-B are forward and backward, etc). So between Xcode and TextMate, I use Xcode for most of my serious development, but if I just need to quickly edit a source file I can be up and coding before Xcode even finishes launching (it helps that TextMate can remember which files were previously opened and restore them). So for some lightweight text editing, TextMate is my choice.
Above that, TextMate's plug-in support is amazing; it provides full support (syntax coloring, building & running, etc.) for so many different things (shell scripts, CSS, SQL, LaTeX, and much more) that Xcode doesn't provide. When I need to brush up a quick program in Java or tweak a webpage, it's a lot easier then using Vim and then building from the Terminal.
My only complaint with TextMate is that the console is read-only, so I can't build anything interactive. That, and the fact that it doesn't seem to support C99 keywords (for loops and booleans) in a plain-C file.
I am a long time vim user, and find that I really like Komodo edit with the Vim emulation turned on. Thus, I get all of convenience of the vim key bindings (to which I have become so accustomed that a recent MS Word document that I recently produced had no less than three ":w"s in it) plus the well implemented code completion for C++, Python, javascript, etc.
I don't use XCode because I don't develop OS X specific applications very much and so the benefit of the OS X framework integration isn't large enough to outweigh the cost of not having vim key bindings and the "do it our way or not at all" approach that Apple takes toward development.
Xcode is more of an IDE, whereas emacs and vi are for pure text (though they have massive extensions to them). This is preferable if you're on an older system or over an SSH. In addition, they're pretty much on every UNIX based computer, whereas XCode is proprietary Apple software.
You might have a look at my essay on the subject Why Emacs?. While it's more or less Emacs-centric some of the points made in it would apply to vim and TextMate as well.
I tried vim a long time ago and for one reason or another "I didn't get it". Then after trying other editors over the years I reached a point where no editor seemed to do what I wanted it to do. After voicing my frustration to a friend he recommended that I try vim....and I am so glad that I took another look because it was the answer to a question that I didn't know how to ask! I have used Vim/MacVim ever since...
here my configuration:
https://github.com/RandyMcMillan/QuickVim
I use Xcode as well because it is nice to have code completion.
XVim is good for people that want a modal/vim feel in the Xcode editor:
https://github.com/JugglerShu/XVim
But when it comes to my day to day editing Vim wins every time. That is why I have the QuickVim repo is so that I can quickly reproduce my environment anytime/anywhere.
I have a list of licenses for editors like TextMate, etc..but it is likely that I won't ever use them since I can use vim for free and customize it to my exact specifications.
Heavy Vim user here. I generally find the text manipulation capability of Vi/Vim far superior than traditional editors which lack things like:
visual mode: e.g. prefixing 5 lines with comment //
macros: e.g. surround 3rd to 5th words in a line with quotation marks, repeat for 100 lines
multiple registers: think 36 registers to copy and paste
delete{motion}: e.g. delete from cursor up to the next occurrence of 'initWithFrame'
These are just a few examples that Vim has XCode text editing beat hands down
For Objective-C. I tend to install a Vim plugin on the IDE to get the best of both worlds - native build / UI components support.
Incidentally. Emac keyboard bindings (e.g. CTRL-A to go to top of line) are supported in a lot of native (Coacoa) text fields on Mac. Including the one you're using for typing answers on stackoverflow :D
XVim works with XCode. IdeaVim for AppCode