Vision Statement of the NetBeans Open Source Project
A look back
Let's look a little into the past. NetBeans started as a Java IDE. At
the beginning it was like every other IDE with an editor, GUI designer,
debugger, etc. The IDE was written in Java and it ran on any platform. The
people writing it were developing NetBeans using NetBeans (they still are).
After a while the IDE began to evolve in some interesting ways:
Open APIs were introduced to make the IDE extensible. The
team developing it grew. NetBeans was open sourced. Developers began
to use various tools to manage the code. In each case, it proved worthwhile
to integrate the tools used to develop the IDE into the IDE itself. The result
is that NetBeans contains things like version control support, building
using ANT, Javadoc search and generation and more.
Each new integration showed the strengths and
weaknesses of the APIs. As a result, the APIs were evolved to be increasingly
generic, to accommodate the maximum number of use cases, while making
the minimum assumptions about those use cases.
More and more the developers worked to make NetBeans not just a Java IDE, but a
platform for tools no matter what language or technology was being used.
NetBeans became more of a platform, integrating a huge variety of tools
into a seamless environment, enhancing, not compromising, the usefulness of
those tools by themselves.
This turned out to be even more valuable than it seemed. For example,
when you integrate a debugger from one place, source control system from another,
and a code browser from a third into the same environment, you end up
with something greater than the sum of its parts. And so the concept
of a "tools platform" was born.
IDEs and Platform
IDE stands for Integrated Development Environment. Integration in
old-fashioned, monolithic IDEs meant a set of tools are available as part of a single
program. Yet development today needs more than this kind of integration. A
better meaning for integration can be had by looking at the modern software
development process. Applications and application development
- Are multiplatform and distributed - various OS's, servers,
workstations, handheld devices, etc.
- Are multi-language - Java, HTML, C/C++, Perl, Python, etc.
- Use various technologies and standards - databases, XML, Servlets, JSP, UML, ...
- Go through many stages - such as design, modelling, implementation,
documentation, deployment and support.
- Are developed in a variety of styles - from individuals, to small teams, to
large distributed teams, to open source.
A really good, useful IDE should work with the tools used by people
playing different roles in a project, integrate them and make them available
as a part of one environment. An IDE should cover all aspects of the
application and stages of the development cycle, and which can be used by
all members of the development team.
Providing tools for all the aspects of development, and
integrating them in the deeper sense of the word is not an easy task.
Therefore, our goal is to create a Platform which achieves these goals, and
let everyone add their own tools to it. We know that there is no "one
size fits all" IDE - so it is better to empower developers and
teams to customize the IDE to meet their unique needs.
Where we are going
We must ensure the NetBeans Platform is solid, stable, performant and
backward compatible, since it is the foundation of other
projects. At the same time we have to work toward maximum
extensibility and the most generic and flexible framework possible. We
will continue to develop and release NetBeans IDE and focus
on making it a powerful and popular IDE for developing in Java and other
We will improve NetBeans simultaneously in all areas in an iterative
way. There will be times when the above goals contradict each other, e.g.
purity of the APIs vs. backward compatibility vs. performance vs. genericity
- these are not always compatible. Especially in such cases the community
should determine the right course of action in broad discussion,
preserving backward compatibility where possible, and providing workarounds
to keep existing integrations effective.
We will continue to encourage use of NetBeans IDE for development
with any language or technology. Addition of support for new languages and
technologies will continue.
We will continue to make the sources public under a very liberal license
which will allow both individuals and companies to benefit from
participating in the project. By providing
a safety blanket - the source code is always available, and the license does not
prohibit modifications to it - those who integrate with it can feel comfortable because
they are not at risk of vendor lock-in.
We will continue to grow the NetBeans community
We believe that it is not possible to achieve these goals without a
thriving community. NetBeans is developed as an open source project. We
believe that this development model is ideal for building such a platform.
Every piece of information, every special case, every experience integrating
something new reveals new paths and new possibilities.
Community-based, public development allows everyone to benefit from each other's experiences.
Something that develops from this process is "institutional memory". We need
to learn from our experiences, and incorporate the lessons learned into what
we do next. Community makes that happen.