Related
I'm looking for an editor/IDE that can provide features that are nice to have while coding (example: being able to click-through to function definitions) for languages that it is not specifically built for. By these, I have in mind languages designed for a very specific purpose and often only used by a small community. In other words, ones that would not have native support in most software.
I realize this would require a fair bit of fairy dust but I don't think it's out of the scope of what's possible. Basically, the editor would have to be smart enough to recognize the commonly used syntax and semantics that many declarative languages have in common. It's quite possible this would require some amount of configuration.
Does something like this exist? If not, what challenges do you think there would be in creating it?
If you need only the feature to jump of to the definition of a specific function or class, then VIM (and many other editors, like Emacs, Epsilon and JOE) can read the jump location from the ctags file. You just have to write a ctags file generator for your custom language.
For programmable editors (like VIM, Emacs, Epsilon, Eclipse and gedit), you can write your own plugin for your custom language, but it may quickly become time-consuming and a maintenance nightmare, because new versions of editors tend to change the plugin interface.
Please note that adding support for syntax highlighting is usually much easier than adding ctags-like support for symbol lookups. More advanced features, like refactoring and context-sensitive symbol completion (like Ctrl-Space and Tab in modern IDEs) are even harder to implement.
GNU Emacs has a pretty good infrastructure for this sort of thing. Until recently Haskell was a relatively unknown language used primarily by researchers. Nevertheless, in a few thousand lines of Emacs Lisp, we have
Syntax highlighting with colors
Automatic indentation
Package support
Automatic highlighting of type and other information when placing the cursor over library functions
Meta-dot on an identifier to jump to its definition (through the standard emacs tags mechanism)
The nice thing about Emacs is that (a) there are many models to follow, and (b) you can build up the environment gradually, starting with those aspects that are most important to you.
I'm suprised no one has mentioned Notepad++ yet:
http://notepad-plus-plus.org/
It offers syntax support for a great many languages and offers the user to add new languages, and an active community that adds many languages that are not included out-of-the-box.
Most good IDE's are language agnostic and supports several if not many programming languages. If you are talking about DSL's, eclipse has a solution that seems pretty awsome - Xtext
EditPadPro comes with a set of tools that allow you to build your own syntax highlighting, code folding and file navigation schemes, based on a very powerful regex syntax. So if your language is not among the many that have already been provided out-of-the-box or can be downloaded off the website, you can roll your own quite easily (and share it with the community).
Visual Studio is designed to allow for this, but it requires the language to add explicit support. For example, Delphi Prism will install into Visual Studio, and provide full language support.
This is far above and beyond "configuration", however, and requires quite a bit of custom development to support.
SciTE and Scintilla offer a generic editor/platform for different languages. The library contains several parsers that work with many programming languages and you can reuse one of these for your own language to add formatting and syntax highlighting.
They don't offer advanced features like click-throughs, but you could build it on top of the library.
Visual Studio and Eclipse also support language plug-ins.
Zeus is a language neutral IDE for the Windows platform and it provides this go to definition/declaration functionality for any language supported by ctags.
To make it work you just create a Zeus project/workspace and then add the files to this workspace.
I am trying to identify the point in time where code completion (autocomplete/intellisense/whatever) was first introduced in IDEs and would appreciate any pointers.
By code completion here I mean a feature within the editor that suggests methods or functions based on the code that was already typed, and I am interested in programming language related completions (not word processor style completion).
I remember seeing it in Visual Studio and Microsoft Office in the early-nineties, and I don't remember at what point it was introduced, or whether it was actually available in DOS-based IDEs like Turbo Pascal or Turbo C++. On a hunch, I would guess that this was probably introduced in Smalltalk.
For those wondering, I need this information for a research paper and wasn't able to find a credible answer online.
The first IDE that comes on my mind is the IDE of Visual Basic
The Wikipedia article on IntelliSense has a history section and indicates that the first use was in 1996.
VB, Smalltalk, Emacs, Think Pascal, Sun's Forte.
Maybe it worked in some of the early Xerox stuff who knows.
I am quite sure Turbo Pascal had some of these features, and that was even before Windows existed.
Turbo Pascal had auto-indent (woo!) but nothing you'd call auto-complete I don't think.
The first time I ever witnessed auto-complete was circa 1985. It was another pascal development system, with a strange name—maybe it was Alice—at any rate I think it was a woman's name. The editor did auto-indent, auto-completion of control structures (no more typing BEGIN and END), and even some form of syntax coloring. It might have been the first time I saw colors in a code editor.
The screen was stunning! Bland code was suddenly vibrant.
Alas, the product disappeared pretty quick. It was real buggy and drove everybody nuts. It seemed like nothing like it showed up until many years after that.
Edit: It was indeed called Alice, by Looking Glass Software, and I found some info on it here.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 7 years ago.
Improve this question
Is there a good IDE to work with VHDL projects ?
Or are most of the professionals working with emacs/vim/notepad++ ?
I use Emacs+VHDL-mode which is great if you don't mind (or have already climbed) the learning curve of Emacs.
Alternatively, you could try Sigasi-HDT which is Eclipse-based and has more GUI. And some more powerful refactoring tools by the look of it.
I have been using Sigasi HDT since it was released in january (I think) and am very pleased with it so far. Previously I used Vim for all my editing (C or VHDL), but since I switched to Sigasi I have not looked back. The Eclipse based plugin is much more than just syntax highlighting. The auto-completion of components and entities is a real time-saver and you avoid a lot of errors. You can download a free trial from their website (http://www.sigasi.com) and I encourage you to give it a try with grlib (http://www.gaisler.com) to see the real power of the plugin.
Maybe Xilinx ISE or Altera Quartus.
I once tried - at least I wanted to try - Altera Quartus, but I soon switched to a normal editor and took GHDL for simulation.
But I am no professional, so I suppose they are using some of the former two products.
Engineers in large semiconductor companies are using emacs/vim for code editing.
Integrated Development Environment doesn't make much sense there, since a project is a few thousand HDL files taken from different places on a *NIX network, setup scripts for a dozen different tools, and cron jobs to do frequent builds.
For simpler FPGA projects developed on Windows I've seen people using Borland CodeWright, UltraEdit, and Crimson Editor.
I've been using Notepad++ along with the free vendor tools to edit my VHDL on Windows.
My best bet is to use VIM to do whatever i need to for VHDL formatting. VIM has an extremely powerful facility to develop custom plugins, and no amount of IDE hopping will give you all the customization you would ever need.
Things like signal names < 20 characters, procedure lengths < 100 lines, no use of linkage ports -- all of these can be coded in VIM with minimal effort. You could actually run vcom or ncvhdl from within VIM and then see where the errors are.
Having said all this, you might want to take a look at what Sigasi has to offer. If you need more help on this, let me know -- it'd be fun coding a VIM plugin.
Emacs + VHDL mode + a compiler / simulator + source control.
The VHDL mode is configured to use the compiler to compile the design and optionally run the simulation.
Emacs can link with the source control to correctly check in, diff and tag.
I personally like this set up because the editor is open source and I can use it anywhere (Mac, Linux, Windows). The compiler / simulator can be anything from a free download (FPGA vendor sponsored Modelsim or GHDL) to a grid engine. Once set up, it pretty much becomes invisible.
Simplifide also has an eclipse plugin which supports VHDL, Verilog and SystemVerilog which contains all of the standard IDE features and more.
It can be downloaded at http://simplifide.com
I'm just using Scite, like for most other coding.
Some things in Scite make my VHDL coding pleasant:
Coloring is easy to set up. Either download a ready .properties file or modify the Ada mode.
Scite has a snippets plugin that's very useful for VHDL. All those boring process and architecture definitions are generated automatically for me with a couple of key-presses.
Scite is easy to customize with external scripts: I have scripts for compiling the current file, for fixing indentation, for listing all processes and so on, the possibilities are limitless.
Besides the big ones Sigasi and Simplifide there is also ZamiaCad a free VHDL IDE: http://zamiacad.sourceforge.net/web/
It depends on the kind of project you are developing. Modelsim provides a good IDE but the code editor lacks the advanced features we are accustomed to use. I use VIM to write the code, and Modelsim to simulate, debug etc...
There's another VHDL-IDE, it's a plug-in for Visual Studio, but as far as I could see, it is also available as standalone version (ie, you don't need a Visual Studio license). It seems relatively new, but so far I really like it.
http://www.vide-software.at
I switched to use Vim because it has a very large list of plugins for almost any language (I believe Emacs do also). You might not get the best VHDL IDE ever with it, but you get a familiar interface for every code and non-code you must edit. Plus, as you move between companies, you can take your environment with you.
For the ones using Vim, check vim-hdl. It's a plugin I'm working on that provides syntax checking based on simulators/compilers. I'm using daily with ModelSim and so far works nice.
Emacs with the appropriate language mode is my vote. Basic editing is easy enough to learn and there are a lot of example config files out there.
Kevin.
I'm using Xilinx ISE for educational purposes, it works really well. And it has everything. After applying for a student license, the student version it free to use, but it takes up a lot of space. The installation file alone is more than 6 gb. The book we use for school is referring to xilinx special properties. (“FGPA Prototyping by VHDL Examples”). I'm also programming on a nexsys 3 spartan 6 testboard, and I'll be using xilinx for another year, but when I finish the course I’m gonna look for something smaller. Happy to read about the lightweight alternatives.
Does anyone know of an alternative IDE for Sybase Powerbuilder? It feels pretty clunky, after working with VS2008 and Eclipse.
If not, has anyone successfully worked with this language outside the IDE? I'm not against using a simple text editor, but I find edit-import-regenerate-test-export-edit is clunkier than simply using the Powerbuilder editor.
To date, the only tools I have had any success with are:
PowerGen, for builds (with NUnit and CruiseControl.NET)
ConTEXT, which has syntax highlighting for Powerbuilder
PBL Peeper, which has some interesting features not present in the IDE
EDIT: I added a bounty to draw some wider attention to the question. It would be a very nice thing to have, if it exists.
EDIT: Well that was disappointing. The bounty apparently did not cause even 1 new person to look at the question.
None that I'm aware of, although you could probably use a source control tool, edit in your source control repository, and Get Latest Version from the PB IDE to shorten your text editor cycle. Be warned that there are hacks required to edit anything over 128 ASCII. (My guess is that this is to allow everything Unicode to be source controlled in the most restrictive source control tools.)
As Paul said, PB12 is coming with based on the Visual Studio shell, and will include things like collapsible code blocks, Intellisense, etc.... However, for PB12, this will only be used for WPF targets and a few .NET-type targets (like assemblies), last I heard. Win32 targets will continue to use the "classic" IDE.
Good luck,
Terry.
P.S. Thanks for the PBL Peeper compliment.
The PowerBuilder IDE is clunky, but I don't think developing completely outside the PowerBuilder IDE is a good idea. I think there are just too many dependencies right now.
However, the IDE for PowerBuilder 12 will be built using Microsoft's Visual Studio Isolated Shell so it ought to be much better when that is released. Also, I believe they'll be doing away with the PBL format which ought to make source control much easier to work with.
Certainly something to watch.
What I do is right-click the object and edit source. Then I copy the text and paste it into Notepad++ to edit. I copy and paste back to PowerBuilder, then I can save and see any errors. I've got a fairly decent User Defined Language for PowerScript if anyone's interested.
Added:
Please be aware that I've seen the PB Source editor corrupt DataWindows. They were all large DataWindows. To be safe always export DataWindows to edit.
One tool that will most probably make your PB experience way better is Visual Expert, which provides a good source browser. Such a tool should have been integrated into the PB IDE a long time ago, IMHO. Only problem is that it's not free, as opposed to the other tools you mention.
Regarding using external source editors, you can probably take advantage of OrcaScript, which is a scripting language that lets you perform actions such as export and import of PB objects from outside of the IDE. It will require some effort, but you can setup a basic dev env using batch files with ORCA scripts and some additional external tools. However, this setup will lack any visual editing capabilities, which means no (feasible) GUI or DW work. If you're mostly into NVOs, it could work. But then if that's the case, why use PB in the first place?...
I too have heard PB12's use of VS will be limited to some .NET stuff, which will probably benefit only a very small portion of the PB programmers community. I'm afraid the rest of us are stuck with the awful IDE for years to come.
Other than exporting the source and editing it I don't know of another IDE for PB. One problem you may have is that the exported source contains a lot of syntax that is not documented in the manuals. The PB IDE generates this code but there is no support for creating it by hand. I think you are stuck with the PB IDE
In my modest five Years of experiences starting with Powerbuilder 5/6, now using PB 10, I tempt to :
build my own browser from the classdefinition object based on Powerbuilder
tried to use autohotkey in order to open datawindows comfortable (we have several thousands in the project and i am two-finger-driven)
truly investigated in the idea using an external editor/IDE suppoted by an autohotkey script which is undermined by sybase allowing only mouse-click-usage of PB
using Visual Expert which is neither a truly integration in the IDE, nor is really worth in analyzing datwindow/powerscript interaction
ending by build hopes on PB12 Visual Studio, which lacks - depending on compatibility issues - ...
... i came to the conclusion that there will be no chance in improving Powerbuilder to an state-of-the-art language
In my philosophy - I obtained during those years - I distinguish between two types of OOP-oriented languages:
the one that award using object-orientation like C#, Python, Ruby (C++) etc. and very much the Java-Eclipse/Netbeans-Universe does
the other one that punish using object-orientation like Powerbuilder and the old Visual Basic, for example (which is causative the OOP-Idea comes afterwards and is "plugged in").
Especially the demand that all object should always be compiled (regenerated) and that you could't work with ancestors and descandants concurrently makes it painful to use real OOP.
...In memory of the good old Unix(Solaris)/C++ days...
I was researching a replacement solution that would be similar to PowerBuilder and I came across two that caught my eye.
The first was 'React Studio' https://reactstudio.com/ which I found via Alternativeto.net .
And the second was from an ad at the top of some Google searches but it was similar enough and looked good enough at first glance for me to want to take a closer look at it, and it's called 'Servoy' https://servoy.com/ .
Still researching but I currently have React Studio at the top of our list.
The TextPad editor has a syntax definition file for PowerBuilder 6.x contributed by anr#aon.at that I downloaded for free and customized several years ago. It works fine for later versions (including 8), doing keyword color highlighting on PowerScript srx files. Editing large source files in PB could get it to crash so it's usually safer, faster and more convenient to export to srx file, edit outside the IDE then re-import.
I've seen several responses to questions asking for IDEs where text editors were suggested and vice-versa. That makes me think that people treat them as the same thing, where I draw clear distinctions.
How do you define "text editor" and "IDE"?
Do you see a difference between the two tools?
Note that I accepted an answer which I think best addressed the concepts of "text editor" and "IDE". However, it's just my personal opinion of what best addresses the question and I will continue to check in on this question from time to time to see if there's a better answer and I will accept that one.
The confusion arises from the fact that a text editor is a core component of every IDE. But, an IDE has much more than just a text editor; it also has interfaces to compilers, debuggers, profilers, reference material, and more.
Many text editors have plugins or other flexible extension mechanisms, often including the ability to "wrap" external tools like those I mentioned above. The key difference, IMHO, is the "I" in IDE - integrated. An IDE is (again, IMHO) something that's purposefully designed to support a specific set of tools, one of which is a text editor.
I use both and I suggest you do too. Sometimes an IDE can make development faster - like code completion and refactoring support. Fast find of files and symbols, functions, classes in project not to mention project management features. Sometimes they'll manage the build for you. Maybe it has a built in debugger (a good built in debugger is worth gold). How about code snippets and file templates. Sometimes an IDE will help you build GUI interfaces and data stores. I've seen ones that help you build regexps and run SQL queries.
These (IMO) are all sugar. I also use a plain text editor (although I really appreciate code syntax coloring nowadays) and roll most of that other stuff myself. Some of the newer text editors are creeping into IDE territory (e.g. TextMate) since they are extensible enough to allow for most of the above paragraphs niceties.
In 90% of the cases I use what I am given or what the majority of the teams uses (I am a contractor). This reduces the build conflicts that can arise if you decide to go it on your own. By learning to use IDE's, text editors and everything in between you will stay flexible and able to cope with whatever is thrown at you.
I do, but it's more in the way you use them than a difference in the software itself. Some software is used as an IDE by some, but a mere text editor by others. Some software can only be a text editor, some is difficult to use as only a text editor, and some can be easily used as both.
I would say that such stalwarts as Vi(m) and Emacs are used by some as text editors and some as IDEs. Things like eclipse, visual studio, etc only really make sense as IDEs and things like notepad can hardly be anything but a text editor.
I would say if you stay in your text editor to do other things - compile, debug, etc - then you're using it more like an IDE. Quite where I'd draw the line, I'm not sure.
The obvious difference is the "I" from the IDE. IDE's are an integrated platform that allows not only editing, but debugging, file management for your project, and usually cool features like syntax highlighting and code completion. oh yeah, and integration of tools and compilers, as well as source control.
To me, a text editor is light weight tool used to edit text based documents. There is no mark up or formatting of the text other than defining the "system" font for the editor. Useful tools can still be part of a text editor, like a folder tree, syntax highlighting, even cmd line execution of compilers. In the end though, all it does it allow you edit the text in a document. It will not display it to you in a different way. ie: it will not show you a grid when viewing an XML document
An IDE is much more robust and is generally specific to a language or framework.
you know, before i started writing this answer, i had a clear line between a text editor and an IDE. But now, i'm thinking they are one in the same. I mean really and IDE like VS is just a glorified text editor. And a text editor like Textpad is an IDE with a much smaller budget for development of features.
I guess the real answer is, an IDE is backed by a large company or group expanding it's features in many different directions. But a text editor is built by a small group of people, with just enough features to get by.
If you look at Kate, the text editor and Kdevelop, the IDE the main difference is that Kdevelop supports project management (CVS/Subversion) and build scripts, whereas Kate does not.
Personally where I think the 'line' is drawn between IDE's and Text Editors is knowledge of the end program, rather than just knowledge of it's source code.
As examples:
Can it compile your code into a binary? It's an IDE
Does it have an integrated debugger? It's an IDE
In order to have an integrated debugger it needs to know about either the binary compiled program, or in the case of scripting languages, the in-memory interpretation of the program as it runs.
Note: Things like intellisense don't rely on your code being compiled into anything, so I wouldn't say that intellisense implies IDE
Note 2: Many text editors like textmate have plugin systems which can be extended to build your project. This does not make them an IDE, as they are simply shelling out to a plugin, they don't have any knowledge about the building itself.