With the Theia Framework providing the possibility of building up a JavaScript-based IDE being able to run in any modern browser, I wonder if there are alternative products / frameworks available.
Are there existing frameworks providing the same or similar functionality as Theia? Or is this currently the only one?
Related
I was evaluating the development of a cross browser extension (supported browsers IE, Chrome, Safari and Firefox): I was looking for a cross-browser development framework, in order to avoid the code duplication and to fasten the building process.
I had a look at this question, and I visited the suggested websites: every company seems to have stopped working on the product.
I read this article too, whose conclusion seems to dissuade developer from the building of a cross browser extension.
So, I have a few questions:
- Does anyone of you recommend a cross browser extension development framework, which is suitable for the purpose I described above?
- Is there a reason why the above frameworks are not maintained anymore?
- Does anyone discovered a more efficient way to pursue the same aim without developing a browser extension?
Thanks so much,
Daniele
I not tested it yet, but Firefox WebExtensions seems to be best choice. Yes, you must make some changes to code, but usually it is not that bad.
WebExtensions APIs are inspired by the existing Google Chrome
extension APIs, and are supported by Opera, Firefox, and Microsoft
Edge. We’re working to standardize these existing APIs as well as
proposing new ones! Our goal is to make extensions as easy to share
between browsers as the pages they browse, and powerful enough to let
people customize their browsers to match their needs.
You can take a look at Plasmo. It's by their words:
The Plasmo Framework is a battery-packed browser extension SDK made by hackers for hackers. Build your product and stop worrying about config files and the odd peculiarities of building browser extensions.
Even it's in early development stage, it has features like:
First-class React and TypeScript support
Hot reload
Support of .env files
Automated deployment
At the moment Iam evaluating java web frameworks. More precisely Iam talking about GWT, JSF2 and apache wicket. One very importent criteria in this evaluation is prototyping.
The prototyping process in my company can be described by the folloing:
The customer can produce GUIs with an easy to use WYSIWYG editor, by drag&drop-ing web components on the corporate predefined website structur. There is also a need for some litte dynamic being like navigation from one frame to another.
So Iam looking for tools. These tools should not only provide nice GUIs but also deliver
some basic code, which can be forwarded to the development. The aim is to avoid missunderstandings between designers and developers as much as possible. More or less the
developers just have to implements the code, but not to implement the optical requirements.
In addition it would be desirable to customize the components thats been used in the WYSIWYG editor. Does anyone know any good tools for the mentioned frameworks (GWT, JSF2, wicket)?
One of the challenges with WYSIWYG tools for UI is that you generally have to pick between rapid prototyping and maintainable code. Even then, as soon as you want to do something that's not supported by the prototyping tool, you can implement it as you would without the prototyping tool, but your round-trip functionality (namely turning your app back into something that can be edited) is broken or crippled unless extra work is done to generate the metadata that the editor needs.
Upgrading between major releases is another issue. Vendors and groups who have developed these tools have a historically spotty record of when they stop supporting older versions, reasonably because of limited resources and sometimes difficult problems with how to track solid innovation happening in the framework itself.
My suggestion instead is to prototype with an RIA prototyping tool like Balsamiq Mockups or use a grid system like 960 Grid to generate rapid prototypes, then use a web development framework that allows your developers to run the code with or without the backend server. Wicket has a tag called that is great for this kind of thing -- web devs can fill a div with stuff that a component should generate, and Wicket devs can wrap the contents of that tag with after they implement it. Both parties can coexist for a long time that way.
Try GWT Designer for GWT.
Introduction
Quick Start Guide
Download
There's nothing like this for Wicket that I know of. The closest you would get to any kind of resource reuse from your customer would be to give them a drag and drop HTML editor - the resulting HTML could then form the basis of Wicket page/panel layout.
if you are planing to use a javascript library, you may use extjs,
http://www.sencha.com/products/js/
they have developed a nice designer
www.sencha.com/products/designer/
there is also a port of ext in GWT
www.sencha.com/products/gwt/
You have to pay for a commercial license if your application isn't open source!
I would like to start a new project which will make extensive use of plugins. I know that both Eclipse and Netbeans have their respective Rich Client Platforms, both with their respective strengths and weaknesses.
I would like some comments on which the Stack Overflow community prefers.
Also, and most importantly, how easy it is with the respective platforms to write plugins for already existing applications. For example, if I finish my application, and would like to enable 3rd parties to extend it with their own plugins, how does each of these platforms provide functionality for this? Would they need my source to do it, or do these platforms provide plugin APIs towards which 3rd parties can code?
I would like some comments on which the Stack Overflow community prefers.
I lean my preference to Eclipse RCP, mostly because I still think that the IDE itself is the best right now. Eclipse RCP is also more mature, and has more books and documentations on the web. Netbeans RCP is slightly behind with only three books I can find on Amazon.com regarding the platform.
I'm also very eager to see the platform growing with its e4 projects which will simplify a lot of things (from dependency injection to UI customization)
Also, and most importantly, how easy it is with the respective platforms to write plugins for already existing applications. For example, if I finish my application, and would like to enable 3rd parties to extend it with their own plugins, how does each of these platforms provide functionality for this? Would they need my source to do it, or do these platforms provide plugin APIs towards which 3rd parties can code?
I can imagine that the answer for this question will not really be satisfying while both platform are designed to be extensible. They are pretty equals in this department.
The most important thing is to design your application to also be extensible. That is, providing extension points. You don't have to provide source code for that but you can document the extension points. Also, in case you need to provide interfaces, you can just provide the javadoc without the real source.
I repeat my point, designing application using RCP doesn't mean your application will automatically be extensible. You have to also design your application to be so. This won't come easily as you learn the platform for the first time but you will eventually learn about it from experience.
(Note: I'm not speaking for the community here ;) )
The two major differences between Netbeans and Eclipse RCP are:
OSGi (Netbeans 6.9 is only beginning to support it): it is designed to support extensions
Swing vs. SWT (can you app benefit from the native look supported by SWT)
Another factor, as you can read in this blog post is RAP (Rich Ajax Platform), which could help deploy your app on many platform based on one source code. But that may not concern you.
The maven integration is quite good from both side (see the Netbeans-RCP-Maven Hello World article), but the Maven3-Tycho integration is primarily developed on Eclipse.
Again, you might not need those new maven features (or you could use other build management system entirely, like Ivy or Graddle)
Consider if your plugins does really need such complex architecture as eclipse RCP or NetBeans provide. Plugins for RCP or NetBeans can be only created by Java Developers with strong RCP/NetBeans experience. Be aware that you can do (very easy) RCP application that is not pluggable at all. In some cases is better to write your own, maybe less flexible but more friendly way to attach new plugins. You can even do some wizards for them.
It's possible to use GWT in a Jruby app?
No, it is not possible to use GWT in any other programming language.
The key thing to understand is that "GWT" translates to "convert Java code to JavaScript"; in other words, it is fundamentally a compiler technology. While GWT offers other benefits, such as a rich collection of widgets, it's main purposes is running Java code as JavaScript.
However, between GWT and Google App Engine I am sure there are many ways to solve your problem. Can you share any more details about what you are trying to do?
What are the advantages of using Framework over Library or other way around while developing Web Applications or different types of Software.
I understand using Framework we can make use of basic functionality and then add upon functionality which we require but I am having hard time understanding the advantages of it as if we develop using Library than also we get some basic functionality and then add upon them the functionality as we need and so where in comes the actual advantages of using Framework.
I think it's important to distinguish between a framework and a library when answering.
A framework follows the Hollywood principle: "Don't call us; we'll call you." You plug your code into the framework according to its API. The framework acts as a constraint that solves the particular problem it was designed to solve (e.g., web application development).
A framework will use a combination of your code and 3rd party libraries to solve a particular problem. It will treat your code as one of those 3rd party libraries.
If you eschew a framework, the roles are reversed. Now you and your code are in charge: "I'll do the calling, thank you." A library is a self-contained piece that plugs into the software that you write.
So why prefer a framework? Use one that is written better than the scaffolding that you would be able to write yourself. A framework is likely to be tested more thoroughly and have a wider user base than code you'll write.
You'd write an application without a framework if you're working on a specialized problem, you have deep knowledge of the domain, and there are no frameworks available that demonstrate deeper insight than you have.
A library is just something that solves a problem but it is your job to integrate it the project. Basically it offers some feature that are context-free.
A framework will provide the features plus an infrastructure for them - you will have to develop according to the framework's rules. So you might have less control and freedom but you save time.