Develop Reference

Is it possible to have real time collaboration in an online IDE?

I am actually trying to create a browser based IDE for educational purpose to code java language programs. I want it to be something like eclipse orion except that the IDE will be capable of compiling and debugging java language code (and it will be only a bare bones IDE). And also, I want to add real time collaboration to at least the editor part of the IDE.
Would it be possible to create an online IDE that would have real time collaboration like the google docs? Also, is MobWrite one of the ways of achieving it and is it good?
If it is possible, please inform me.
Thank you very much in advance.

I think there is an interesting option out there by IBM(Just rode in a blog),
called "Web Browser-Based Interaction with the Eclipse IDE".
Have a look at this link:
http://www.rodenas.org/blog/2007/10/16/eclifox-web-browser-based-interaction-with-the-eclipse-ide/
So the answer is yes, it is possible somehow.
I hope it helps.
Update:
There is a similar question already on that topic(but browser interaction with the IDE is not mentioned), have a look at it, maybe can be helpful:
Real-time collaboration in Eclipse

In theory, anything is possible.
In practice, I'm not sure that collaborative programming ... where lots of people are hacking on the same files in real time ... is going to be productive.
Programs are qualitatively different to text / markup documents. When you two people are simultaneously editing a program, semantically conflicting edits can break the "work" in a far more fundamental way than conflicting edits on a document. I don't see this being an effective way to write programs.

Sure, JavaWIDE is what you are looking for: http://www.javawide.org
It has concurrent editing, and you can compile and run directly in the browser.
JavaWIDE is free and sites are available to educational institutions.
Feel free to try it out (no account needed) at http://sandbox.javawide.org

Cloud9 IDE has multi-language support has recently released a new collaborative tools including a new real-time collaborative editing feature (with authorship info), Group Chat and File Revision History timeslider. Further explained in https://c9.io/site/blog/2013/10/new-collaboration/
Mostafa,
The Cloud9 IDE Developer behind that Collab

It depends on the purpose of the IDE. JavaWIDE provides a great IDE for introducing programming concepts for novice programmers at the beginning of their programming classes. JavaWIDE will probably never be used for professional programmers.

Koding has a real time collaboration tool (with a bunch of cool stuff) where you can import your projects really easy. It also has a free VM with root access. Definitely worth checking out. :)

I recently saw Compilr and It seems pretty decent. You can run it inside a browser, full collaboration work is supported and Its cross browser and you can run it on your devices as well.
Nice thing is that it also includes some basic courses for you to learn coding which is exactly what you are looking for :)

For an on-premise install (you don't depend on external servers/services ) you could try Eclipse + saros (http://www.saros-project.org/), saros depends only on XMPP but you could build your own server locally (http://www.igniterealtime.org/projects/openfire/)
For web based collaboration tool on-premise too I've been developing this: https://github.com/juanitomint/Space_Editor
It's based on nodejs,Extjs,ace editor and git, contributors are welcome

Swing Generator

I need to develop some java gui using swing.
A few years ago I did develop a bit with swing.
But it was pretty exhausting, you see, back than there weren't much tools to help you.
But I do believe today it should be easier, there must be tools.
I would like to use some kind of a generator or maybe a utility or even a framework.
I know Eclipse has a few plugins and Netbeans has a nice built in tool. I have also heard good things about Jide framework.
But still, I don't really know any of them.
Is there a tool/Utility/Generator/Framework that you have used and really helped you?
Obviously I would prefer something that is free, but if you know something that is really really good and cost money, that could work too.
Thank you.

Actually the faster way to write Swing frames that I've found so far is to use Groovy SwingBuilder but you have to include groovy's jar inside your project to use it. This is an example taken from their website, it's mainly synctactic sugar but it helps:
def frame = swing.frame(title:'Frame', defaultCloseOperation:JFrame.EXIT_ON_CLOSE, pack:true, show:true) {
vbox {
textlabel = label("Click the button!")
button(
text:'Click Me',
actionPerformed: {
count++
textlabel.text = "Clicked ${count} time(s)."
println "Clicked!"
}
)
widget(sharedPanel())
widget(sharedPanel())
}
}
Otherwise there are some "visual" approach to the problem but they don't let you integrate so quickly with the interface you wrote (for example jvider), NetBeans and Eclipse have some plugins to do the dirty work but as before: you can't integrate so seamlessy.

For quite a few years I've used NetBeans built in "Matisse" form editor. It's got the advantage of being built into the IDE, so that the form editing and code generation is rather seamless. If you're new to Swing it can be a big boost (as long as you continue to use NetBeans as your IDE).
There are some issues, however:
You can't easily move a form to another IDE. The generated code may work, but the form data itself is stored an XML file.
If two more people edit a form at the same time, conflicts can arise in SVN/CVS that are nearly impossible to reconcile. The XML is not really human readable.
In the past I found the form XML file to corrupt itself, which would lead to form generation errors.
The form editor can get a mind of its own sometimes, destroying your arrangement when you do something as simple as resize a control.
In spite of all the above, I've continued to use it as nothing else has seemed appealing to me.

My suggestion would be WindowBuilder Pro. It's a GUI designer that comes as a plugin for the Eclipse IDE.
You can use it to generate Swing, SWT or GWT GUIs and even generate some Eclipse RCP code if you need to. I must say that it works quite well for me. I haven't used it to generate any Swing code, though, as I prefer to work with SWT instead.

In terms of GUI Builders, NetBeans and IDEA (now going open source with the 9.0 Beta) both have free GUI Builders.
GUI Builders have all the kinds of downsides that Jason spoke to. If you want good control over what is going on, but still want something sane to write a complex GUI by hand, check out MigLayout.

Eclipse's Visual Swing is a promising upstart. It isn't the most stable thing in the world, but it does all the form stuff in code, so there are no separate files which are hard to read and merge in source control. When you first try it, it takes some getting used to. But once you learn to work around the bugs you pretty rapidly develop Swing GUIs.

I would go w/ matisse if you wnat to use a gui builder, and there are shortcomings as Jason mentioned, but you also need to include a jar file that is used by the matisse layouts, this may or may not be a problem.
But if you are going to be developming UI's in swing, you will soon come to find out most of the gui builders have many shortcomings, and when you have to change something the generated code is not always clear and is bloated. You will also find that once you become proficient you can write a ui much faster by hand than the gui builder, and you will really understand what is going on.
So I say stay away from gui builders, you will create better and more maintainable UI's, and w/ some time and experience will not want to use a gui builder. Just start w/ some of the basic Swing tutorials on layout.

May I humbly suggest Metawidget?
It takes a different approach to UI development - removing much of the error-prone, tedious work whilst still retaining the flexibility of traditional toolkits. It integrates with your existing front-end (Swing, in your case) and back-end (Java, I'm guessing), and works at runtime (no code generation).
There's a few short intro videos here:
http://metawidget.org/videos.html
If you get chance to take a look, I'd be most grateful for your feedback.
Regards,
Richard.

You can avoid GUI builders generated code by using ReflectionUI.
Advantages: you instantly generate your GUI and then you customize it visually (or with few code if you need something very specific).

Is XML or XUL the future of Java GUI building?

After spending a lot of time and code on programming in Swing, I thought this can't be state-of-the-art Java GUI building. After not finding a user-friendly visual gui bilder for eclipse I stumbled upon declarative GUI building with XML UI toolkits... and I thought: This must be it! I think it's the right way to go, easy and also close to web-programming.
But after looking around in the web and on SO, I got the impression that it is not very common! Although there are many implementations and APIs, it seems like most of them are kind of dead and had no updates in the last 5 years..
So I wonder: Is my feeling right, that XML is not very widespread for java GUIs? And if so - what are the reasons? Maybe it couldn't become accepted or it has some major drawbacks or people are doing everything in the web instead with fatclients or there are better alternatives, maybe javafx?
I just need to know if it is worth spending time in that area or better look for alternate ways. As I dont read developer magazines I just don't know what the trends in gui building are and which technologies are believed to have a future. But I can't imagine that people still spend so much time on writing nasty swing (or swt) apps.

There new fresh and interesting approach - it uses YAML. Check it out at http://code.google.com/p/javabuilders/

Sun's answer to that seems to be JavaFX.
It has a declarative language for specifying the GUI and there will be builder apps as well.

There is some prototype work going on for e4 (Eclipse 4), which would allow building a GUI by editing an Ecore model and customizing it via CSS.
See this blog post for some details and instructions to try it out yourself.

Five to ten years ago XML was very popular. Although fine to provide some kind of standardisation for transferring data between heterogeneous systems, it's not suitable for programming. It always starts with the easy stuff, and lets declare everything. But any real system requires code. XML then falls down. There is also the problem that XML is a bad syntax for humans, and even languages like Java are easier to read.
On the other hand, there is clearly a need for the rails of GUIs. Naked Objects is the closest reasonable attempt I have seen.

I came to the same conclusions as you about the declarative frameworks out there. It is not worth learning a new GUI syntax unless it's widely supported. XUL as an interface language is widespread, but there is no java rendering framework for it. I'd say HTML+CSS+Javascript and a Servlet container is the best Java platform for GUIs today, but sadly I haven't found a platform independent way to display web pages like a desktop application.

If you use Eclipse, you can now use WindowBuilder to help you in creating Swing apps in a user-friendly visual GUI builder. It's now available as a free download, and Google has donated the Swing GUI builder framework to the Eclipse Foundation.

I'd second Thilos suggestion with javaFX.
Additionally the trend is pointing to webapps, so I think that in the long run javaFX and web based UIs will catch up to swing+swt GUIs.

I do all my swing stuff by hand and none of my application is nasty. If you do not know how to create usable and good looking UI there is no technology to help you.

The answer is surely not going to be XML. What problem are you trying to solve? You want to have reusable building blocks, and a compact way of describing them. I don't see XML helping you there.
[edit] Creating a java code equivalent of XUL would be an immense improvement on XUL.
XML makes it really, really hard to do good separation of concerns and once and only once. It is however perfect for the mongolian horde approach. You need a layer on top of swing, it only provides the building blocks.

What Java IDEs work well with existing GUIs and may help with conversions?

I have an application of some 85 "frames" which was originally written with JBuilder 5 - an early IDE. The app is pure Java and I think it's all mostly Swing and AWT. So, the core question is: What IDEs can help me both maintain my existing application, possibly convert it from standalone to JSP, and hopefully also help with new development via a GUI interface?
Last summer ('08), I downloaded Eclipse and it sure beats JBuilder, except for the lack of a visual GUI WYSIWYG editor - the Visual Editor was dead even then. I like Ganymede (the current version) standard toolset, but lack of a visual editor concerns me. (And, I had a lot of trouble integrating it into an existing development environment.) While it lets you work with existing code, it didn't even have a (current) GUI editor, so working with my old code was the old-fashioned way ("blind").
In doing my homework, I found a company that makes/made a current-version Eclipse-based IDE that had a full-blown GUI environment that they claim make it easy to develop one GUI and then deploy it either as a stand-alone (pure Java) app, or deploy it as a web page (using JSP, etc). And, they suggested, it would let you work with existing applications, something none of the other systems do - that I've found so far. IIRC, it was about $250 for a license.
Unfortunately for me, life-events prevented action at that moment - long story short, I lost the link to their site. I thought it would be no problem to find them again, but the number of "plug-ins" and partners has EXPLODED! They now have nearly 1200 plug ins available and about 60 GUIs! YOWZER!
I came here to SO and got the idea from one of the several questions on "best IDE for Java" that NetBeans 6.5 is worth a look-see. I tried it. It's horrifically slow, even on a 3ghz box with 3G memory, etc. But, it integrated into the environment more quickly and I like its deployment details. I then found out that its GUI environment is only good for new code, and some here on SO suggest that it's a bit brittle and that if you have to hack it much (which I will need to do!) then it may break the ability of the GUI to continue to be editable in the IDE...
I've spent countless hours doing my homework on this, especially including looking here on SO and the web pages to which they often point. A lot of articles on Java IDE GUIs are old now, but I've read them anyway, and learned a lot...
Ideally, I'd like to find one tool that:
Competently, and without undue hassle works as a modern IDE for Java with a good GUI
Can help convert between types of applications - stand-alone vs JSP (mobile?)
Can work with existing applications (not written using that toolset).
Doesn't hook the code in to proprietary libraries.
If not in one tool, as multiple tools, it would still be nice to have all these abilities!
I do not require "free!"
Your input appreciated!

I suggest you look at Visual Editor again, as it should be able to work with existing code if this code is not too complex (in terms of business logic being mixed with the gui code).
Otherwise your time may be well spent in refactoring out the GUI code to a state where Visual Editor can handle it. I have not seen other free IDE's which can work with existing code.

NetBeans is powerful IDE for Java and have a good GUI builder.

If you already have Eclipse, I would recommend trying MyEclipse. This has a plug-in called Matisse4MyEclipse that is a nice GUI builder.

Best GWT widget library? [closed]

As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 10 years ago.
Question for all the GWT gurus out there - which is the best GWT widgets library out there? And why?
List based on the answers:
Default
Sencha GXT
Smart GWT
Vaadin
GWT-Bootstrap
GwtBootstrap3
Rocket GWT (inactive)
Tatami (inactive)
ErraiFramework
GWTMaterialDesign
И наконец- новое поколение основанное на JsInterop:
GWT + Polymer Elements
GWT + Polymer
Angular and GWT
GWTMaterialDesign

Do not bind yourself to ANY of these libraries. Use Vanilla GWT to create the structure of your project. In particular, use the MVP pattern and an Event Bus. Please, see google article to know how to best design your client application with GWT: Building MVP apps
After, you can use any widget of these libraries (say a table, or a combobox, a datepicker, etc) and incorporate it to your project. Try to use extended components ONLY if you don't see a way to do it with vanilla GWT. This way you don't tie yourself to these libraries which are ALWAYS a pain when you try to do something that doesn't appear in the demo application, contain many bugs and their support are poor at best.
How to look for widgets should follow this order:
First check GWT Incubator to see if
there's what I'm looking for.
http://code.google.com/p/google-web-toolkit-incubator/
Then, if you are looking for
something "cooler" check GWT Mosaic
http://code.google.com/p/gwt-mosaic/
Careful with other libraries, I've worked with them (and still have nightmares).

Depends on what you mean by "best". Best looking? Best API? Best for extending to your own custom needs?
E.g., I was just evaluating table classes to use in our application. We've been using GWT-Ext, but it has many performance problems for us, and is very hard to get the tables sized the way we need them. I came very close to going with GWT-Mosaic, but decided instead to build off the widgets in the GWT Incubator.
So, why did I make this choice? It seems that too many of the libraries out there come with their own, for lack of a better word, baggage. Either you have to dive whole-hog into some MVC framework (which may not be entirely compatible with the rest of your code base), or you have to adopt someone's new fangled layout system, or you have to live with the fact that you cannot really debug the code (because its just JSNI wrappers).
Don't get me wrong, the GWT Incubator isn't perfect...the widgets there are in some amount of flux. In my case, this was the best choice, though. It gives me good (but definitely not perfect):
API
Extensibility
Look and feel (well, this is kinda weak, but that's what CSS is for.)
So...the answer (for me) is a combination of:
Stock GWT widgets (with lots of custom styling)
GWT Incubator tables
A few home-grown widgets
(I should add: the "baggage" I'm referring to isn't necessarily a bad thing. But, if you just want a widget or two, it can raise the bar on what it takes to just get your work done and how good youe application looks.)

See this component library GWT Bootstrap this is a implementation in gwt of Twitter Bootstrap.

GWT alone is a pretty good library.
I didn't use all of the mentioned ones but can recommend Ext GWT.

I prefer vanilla GWT.
Some of the other APIs look pretty and their showcases really show off the widgets, but I always find that the performance isn't the best....when I say performance I mean more like response time. I hate when an application feels sluggish.

Most of the libraries mentioned are not open source and even worse: are just wrappers on top of a JavaScript library. The power of GWT lies in the fact that the application works on different browsers (because of the code generation for the "big" browsers specifically). These JavaScript underlying libraries can cause lots of problems.
I agree with jgindin GWT Incubator and GWT Mosaic are the best so far.

Not saying it's "the best", but I've been using GWT-Ext at work lately. It's got some pros and cons:
Pros:
Relatively easy to setup and use
Decent sized community behind it
LOTS of examples online, all of which have accompanying code
Good selection of widgets that cover a wide range of functionality
Cons:
Makes assumptions about your data's format and structure that you may not be able to accommodate
Library is just a JSNI wrapper, which makes it harder to debug and extend
Future support and development on the library is uncertain
Some annoying cross-browser issues still exist (especially with layouts)
Search function on their forums is essentially useless. (This is becoming a big pet peeve of mine >_<)

Do NOT use any of them! If you plan to develop a large scale application, you should consider using MVP pattern. The best implementation around is MVP4G framework, it supports GWT code splitting out of box. There are a lot of great examples, you can start with. The most valuable one is Mvp4GModules.

Add the new one: GWT-Bootstrap :)
There isnt a stable release right now, but will have soon.

My experience shows that there are always many problems with 3rd party libraries. The best way - is to use well-known and well-maked technology itself plus your own components. It may take a longer time to write and maintain them, but TCO is always at lower level.
3rd party libraries often can break your plans unexpectedly. And it's hard to find and fix the source of problem.
So I'd suggest to use plain GWT.

I think SmartGWT is fine if you just whant to use the Widgets as they are,
but if you would like to extend or modify the widgets as I do in
the Gxt Scheduler I think that Ext-GWT is a better choice.

for me EXT-GWT (aka GXT) is the best library currently available,I use it in 6 months project,and it helps a lot with many predefined components like grids,trees....
It's beautiful as well

SmartGWT is a good library and it has a lot of examples but the user interface is not that sleek. For user interface Ext GWT is good.

gwt-mosaic's user group doesn't seem very active and I couldn't find a user's manual besides the wiki snippets. gwt-mosaic introduced me to two interesting tools.
1) gwt-mosaic includes a wrapper for Tibco's PageBus which is a publish/subscribe tool for the JS parts of your app (RPC handlers, widget callbacks, widget setters). This is an alternative to gwt's event bus.
2) gwt-mosaic encourages the use of Beans Binding (http://code.google.com/p/gwt-beans-binding/) for binding data to widgets and validating widgets.
smartgwt isn't cheap for the full feature set and support. The jar is too large for appengine unless you remove the theme files you don't use. They invest engineering on the server side too.
I've heard ext-gwt is sluggish and the JS files are large.
The gwt widget incubator looks deprecated. I believe the deluxe grid will be released with the new gwt.
The lack of look-and-feel, binding, and validation standards is hampering the interoperability of widget libraries.

Definitely not SmartGWT. Their framework is bloated and has a very half-baked nature. They have a million widgets, but trying to get them to work for your project is not easy. Datasources complicate the process of managing your data in a very big way, for example, in order to get to data in your datasource, you must use fecth and inspect often. While you can cache the results, it is not always easy to interrogate them.
RPC is another weak and convoluted area. There is contradicting information in the documentation and in the forums. While the documentation will say that you should rarely use a custom operation as part of a ds, they forum will tell you that it's perfectly fine. Learning to use these tools effectively is an uphill climb on the best of days.
They will oversell the product. For example, the charting/analytics package contains graphs... But those graphs won't display negative values or let you manipulate axis labels in any meaningful way. And they openly respond to queries about this on the forum with a "yeah so what" attitude. "We don't plan on adding that to 3.0x even though that's one of our selling points, it's on our road map." When they sold me the package, they never mentioned that I couldn't display negative values. Really? What graph would not need to be able to show negative values? I can think of only one- the one depicting the number of unhappy Isomorphic customers.
Stay away from these guys, and head over to any competitor's site, for example ExtJS, JQuery, heck even quxdoo. There are a few projects out there that are really gaining ground and actually offer a good solution.
Take great caution if you ever evaluate this product. It looks nice, but about two weeks in to the project using it, you'll start seeing what I mean. Widgets are half baked, datasources are extremely over complicated, and just because you paid for forum support, doesn't mean you'll actually get anything other than snide, condescending answers that at first will make you think you missed something. You didn't they're generally very arrogant.
Best of luck, and stay away from this product if you value your development time and maintainability. Oh and one last thing. Look at the MVC example on their web site. It has literally nothing to do with MVC other than the label reads "MVC". They'll try to convince you that such frameworks are for inexperienced developers, and that such a concept has no place in real programming... Kinda like those try catch blocks.

Google's default library is the most powerful library.
Ext GWT adds bells and whistles but apart from that it's similar to Google's.

We're currently liking the GWT Mosaic widgets. We've worked with ext-JS and we've rolled our own widgets in the past. ext-JS licensing and bulk were a problem for us. Rolling our own isn't what we want to do. Mosaic gives us a happy middle ground which we like to think will be an even happier middle ground as the project matures.

I would say if you need only a few widgets then build your own. You might copy-paste some concepts from the libraries mentioned. But they all lack one or the other thing.
I have played with most of them and abandoned every one.

One thing to be aware of is that from the forums GWT-Ext looks like it will no longer be developed/maintained much (maybe not at all?). On their website they recommend migrating to SmartGWT.

Didn't see this one mentioned, Vaadin (previously known is IT Mill Toolkit), but maybe that's because it's not technically exactly GWT; as their FAQ says:
How does this differ from GWT?
GWT applications run in the browser,
while Vaadin applications run on the
server. We do actually use GWT as a
"rendering engine" on the browser
side, so you can combine Vaadin and
GWT.

smartGWT is slow and examples are lacking and it is very hard to find answers for even the basic questions, i.e. see all my non answered questions on this forum.
I'm dumping smartgwt.

Comparison of the two EXTs here with pros and cons.

We have built a large HR portal and a couple of smaller applications using GWT Portlets. The focus of the project is not so much on building a collection of widgets but on creating a simple programming model.
From the website:
GWT Portlets is a free open source web framework for building GWT (Google Web Toolkit) applications. It defines a very simple & productive, yet powerful programming model to build good looking, modular GWT applications.
The programming model is somewhat similar to writing JSR168 portlets for a portal server (Liferay, JBoss Portal etc.). The "portal" is your application built using the GWT Portlets framework as a library. Application functionality is developed as loosely coupled Portlets each with an optional server side DataProvider.

I am using GWT for a year. After lots of research, I have decided GWT Mosaic as a widget library.. Mosaic uses some of the GWT incubator components such as PagingScrollTable.. But the features of the combobox and table are not sufficient for us.. That is why, we have extended these components to add needed functionality.

Check out SpiffyUI: www.spiffyui.org
It is not just a widget library but complex UI/UX GWT framework.

Two important things -and what the most of libraries miss- are unit testing and debugging. It is where GWT shines. If you use a library which is based on vanilla js, you give away the ability to unit test and debug your project. As a GWT developer you should consider these points and use a library with no or minimal js dependency.

We've been doing gwt projects for more than 2 years, and we stick to the default widgets. We made our own open source library to autopopulate the default ones or our own widget extensions. Please check it, it's called gwt-jet. It's very well tested since we use it in large production environments, and we hope it will grow safely thru time.