Without going into the discussion of the question of what programming is - an art or a craft, we admit that in either case a programmer cannot do without tools for creating programs. Along with the evolution of the programming process (from "witchcraft" over machine instructions to the use of high-level languages), the possibilities of automating the hard work of programmers have also improved. The first development environments were limited to running compilers, linkers, loaders, and debuggers sequentially using the interface command line... In the 80s, along with personal computers, a market appeared software products a new class - integrated development environments (IDEs) for algorithmic (Pascal, etc.), and then object-oriented (Smalltalk, C ++) programming languages. This area has reached its true heyday thanks to the active adaptation by developers of the Java language; the most famous frameworks for building programs in this language are Borland JBuilder, Symantec Visual Cafe, Microsoft J ++, IBM VisualAge, and Oracle JDeveloper.

The main purpose of IDEs is to increase developer productivity. The first development environments that combined the functionality of program text editors, compilers and debuggers mainly freed consumers from routine operations. Over time, the IDE's feature set has become more and more rich. It includes step-by-step compilers, browsers for more logical presentation of programs, tools for automatic code generation, and visual editors to create graphical user interfaces. Following the trends of the times, development environments have transformed from tools to increase programmer productivity into tools to support all stages of teamwork on a software project. The latest trend is the transformation of IDEs into ALM (application lifecycle management), an integrated application lifecycle management system - from requirements definition and modeling to configuration and version management. software, deployment and maintenance of a ready-made solution.

Each new step in the evolution of IDEs has made development environments more complex. However, users of such products still had to resort to the help of tools not integrated into the IDE, if only because the creation of an application is not limited to writing and debugging programs in one programming language. The need to use in an application system, for example, HTML pages, relational database schemas, or pieces of code in other languages ​​(like Cobol or PL / 1) forces developers to use the appropriate toolkit that was not originally included in the IDE.

This is why many vendors of commercial development environments strive to make them as open as possible and provide special mechanisms for integrating external tools. But no one medium is able to satisfy all possible user requirements. To do this, it must be completely neutral to the programming language and support the maximum set of functions. Eclipse is not such an environment, but it is a base, a platform with which you can build multifunctional and multilingual development environments.

Platform

As the initiators of the Eclipse project explain, its idea was to create "Apache for development tools" - an open platform that provides maximum basic capabilities for development environments and providing mechanisms for integrating various tools. The first version of this platform was developed by IBM and released in open source at the end of 2001. Eclipse-based commercial implementations soon began to emerge, pioneered by the WebSphere Studio Application Developer 4.0 environment. Eclipse now has a whole open source development ecosystem that brings together tool vendors and users, research organizations, and individual developers.

In the official docs of the Eclipse Foundation ( www.eclipse.org) The Eclipse Platform is defined as a vendor-agnostic open development platform that provides frameworks, exemplary capabilities, and extensibles tools... The toolkit within the Eclipse Platform is generic in the sense that it verifies the applicability of the basic platform capabilities, illustrates typical situations of their use, and supports the development and maintenance of the Eclipse platform itself. The toolkit is extensible because its functionality is available through documented programming interfaces. Basic principles, which guided the creators of the Eclipse Platform and in accordance with which it continues to develop, are as follows:

• support for constructing tools for application development;
• support for an unlimited number of tool vendors, including independent software vendors;
• support for tools for working with arbitrary content types, including HTML, Java, C, JavaServer Pages, EJB, XML, GIF, etc .;
• providing a "seamless" integration of tools for working with different types content from different producers;
• support for application development environments with conventional and graphical user interfaces;
• providing the ability to run a development environment based on different operating systems (today the Eclipse-based toolkit is implemented for Linux, HP-UX, IBM AIX, Sun Solaris, QNX, Mac OS X, Windows);
• taking into account the popularity of the Java language in the interests of platform development when creating development tools.

The Eclipse Platform is a Java-based development environment for general purpose, the architecture of which provides for the solution of various tasks the integration of various tools and programming languages. Mechanisms of such integration allow using the Eclipse Platform to build advanced development environments, freeing from the routine of writing basic tools in favor of creating complex, specialized functions. This not only solves the problem of supporting multifunctional and multilingual development environments, but also lays the foundation for simplifying the transition from one type of environment to another in the process of their evolution. The community-driven Eclipse platform will build on the latest advances, making them available to product-specific developers and eliminating the need to fundamentally rewrite their systems.

Eclipse development environment

The architecture of the Eclipse Platform is based on the principle of using plug-ins. The platform implements mechanisms for detecting, integrating and executing such modules (see figure). A developer who wants to take advantage of the capabilities of the Eclipse Platform writes their toolkit in Java as a separate plug-in. This module will work with files in the workspace, which is implemented using the workspace component. And his user interface is based on the tools of the workbench component that sets general structure interface and the possibility of its expansion.

Typically, a single plug-in implements the simplest functionality of an Eclipse Platform-based IDE, while more complex tools are compiled from multiple modules. However, almost all of the built-in functionality of the Eclipse Platform is also implemented using such modules - with the exception of a small Platform Runtime core. For each plug-in there is a manifest file (manifest), which describes the relationship of this module with others. When you start an Eclipse Platform-based development environment, the Platform Runtime component determines the set of available plug-ins, reads their manifest files, and builds a plug-in registry. After starting the system, additional modules can no longer be added. Within the framework of the Eclipse project, a special environment for creating plug-ins is implemented - Plug-In Development Environment (PDE).

The workspace and workbench components of the Eclipse platform are implemented using special modules. The workspace contains files that users of plug-in tools create. The workbench component provides a general structure and tools that allow you to extend the user interface of the development environment based on the Eclipse Platform, includes two components for implementing the means of presenting information to the user.

• The Standard Widget Toolkit (SWT) is a set of interface elements and graphics library that have mechanisms for integrating with the windowing system of a specific operating platform, but implement OS independent APIs. This allows, according to unified principles, to build user interfaces of the development environment that correspond to the window environment familiar to the consumer, but are designed for the maximum possible range of operating systems;
• JFace is a toolkit for implementing a number of common interface programming tasks using SWT tools.

Based on the APIs provided by the SWT and JFace components, a personalized user interface is built that defines the structure of consumer interaction with the development toolkit. The Eclipse Platform interface is organized using editors, views, and perspectives.

The purpose of editors is to open, edit, and save objects in the workspace. The platform has a built-in editor for text resources, and other features must be implemented as plug-ins. Views provide information about the object that the user is working with in this moment... Finally, the perspective engine allows you to select and organize the editors and views you want to display on the screen.

Organization

There are a number of advantages to running projects in open source. So, one of the tasks of such a platform is to provide developers with tools from a common base that is invariant for different development environments. Why would every manufacturer rewrite something that can be written once? But in order to build their developments on such a platform, the manufacturer must completely trust the one who created it. And this is possible only if he is able to try out everything that is in it, that is, to get an open source platform.

Developing a product in accordance with the principles of Open Source improves the quality of the code as it is jointly “polished” by many interested developers. Debugging becomes easier and better - thanks to access to the source code of the program and, again, the involvement of a distributed team in the work. Joint work allows you to share the risks of creating complex technologies. And the collective body of the platform development provides its support regardless of the twists and turns that may occur with the providers of specific development environments. Finally, using an open source development platform with a flexible plug-in mechanism to implement additional functionality opens up unlimited possibilities for improving it.

Eclipse Platform Architecture

However, you will not be able to realize the benefits of the open source development model by simply releasing a technical platform. We need an organization of the process. With the release of the first version of Eclipse in 2001, a consortium organized by IBM along with a number of leading market players took over this responsibility, and in February 2004 the Eclipse board of directors decided to transform the Eclipse Foundation into a non-profit independent corporation.

The Eclipse Foundation consortium of more than 60 companies coordinates work to improve the Eclipse platform and other open source projects.

The Eclipse project is completely open, any interested developer can participate in it, who does not have to be an employee of any company. In principle, everyone can not only be interested in the details of the development and contribute to the identification of errors, but also take part in the writing of the code and the general design of the next version of the platform. However, Eclipse follows the principle of prioritizing professionalism. A developer with a proven professional track record can count on additional responsibility and the opportunity to actively pursue their expertise in Eclipse projects. Some developers are defined as "responsible" (committer), since they are responsible for the source code, and only they have the right to create new versions in the open source repository. Typically, these developers are company employees who pay for their work on Eclipse projects.

The development process is iterative to maximize the involvement of members of the Eclipse community in the project. The release of the next release is preceded by several stages of a fixed duration (on the order of several weeks), each of which is a complete cycle that includes planning, development, testing and an intermediate release of the version. The completion of the next cycle is accompanied by an open publication of a description of the new system capabilities, which stimulates community members to discuss, use and issue recommendations for improvement. As a result, at the next stages of development it becomes possible to take into account the community's reaction to the interim release. This is an open process of continually improving the Eclipse platform and developing other initiatives based on it.

The Eclipse Technology Project aims to coordinate the efforts of developers, researchers, academics and academics to identify the future of the Eclipse Platform and other open source developments. Among the most notable research subprojects in this direction are the development of aspect-oriented software (AspectJ and AJDT), the creation of a kernel, an alternative to the Eclipse Runtime (Equinox), the creation of a collaborative development platform (Koi), software configuration management (Stellation), toolkit for XML Schema Definition and for Generative Model Transformer.

Community

The use of all materials obtained from the implementation of Eclipse projects is governed by the licensing rules of the Common Public License (CPL), which are approved by the Open Source Initiative. Under the CPL, anyone can use and redistribute Eclipse for commercial and non-commercial purposes at no cost. The following are freely available on the eclipse.org website:

• current versions of the Eclipse Platform for direct use (in binary form);
• a source code repository where anyone can view the contents and revision history of any source file, as well as get scripts for recompiling and building the Eclipse platform from source codes;
• open discussion forums for discussing the Eclipse Platform;
• bug database for tracking defects and problems current versions platforms. With this database, users can identify known defects in their Eclipse-based designs and publish new issues they find;
• development plans and contacts for developers participating in Eclipse projects.

Today on eclipse.org Freely available - over a hundred source-code plug-ins for the Eclipse platform. Eclipse Open Projects are over 2 million lines of code in total.

Key to market development software tools Development has a participation in the Eclipse project of commercial companies. In the Eclipse Platform, they get out-of-the-box IDE services that are language- and platform-neutral, and can focus their efforts and investments on developing sophisticated functionality that will make their solutions competitive. There are examples of implementation on the basis of Eclipse as full-featured development environments that promote the most advanced solutions in this area, and specialized tools aimed at a specific range of tasks.

So, all products of the IBM Rational family work on the Eclipse platform. Borland To Move All Its Support Tools To Eclipse life cycle applications. There is an Eclipse version of QNX's embedded application development tools; a similar project is being implemented by Wind River. In turn, Hewlett-Packard offers an Eclipse-based development environment for components for its Internet Usage Manager system, the target audience of which is telecom operators. Nokia announced support for Eclipse as a development platform mobile applications... IBM has implemented a special toolkit Autonomic Computing Toolkit based on Eclipse, designed to support autonomous computing technologies in developed applications. Of all the world's leading software vendors, only Sun Microsystems and Microsoft do not partner with the Eclipse Foundation.

Eclipse-based commercial vendors enable ISVs to sell add-ons for their IDEs, and it happens that a company implements the same proprietary plug-in for different environments on the Eclipse platform. This is not only a method of entering new markets, but also another way to increase the value of the project. Users value freedom of choice: if they are not satisfied with the existing functionality of the open source platform-based environment, they can extend it by self-development or by purchasing commercial solutions of the same format.

These groups use Eclipse developments in different ways, but they all contribute to their development. The trend is to use the Eclipse framework to build non-IDE applications. This is possible because there are not many IDE-specific elements in the Eclipse Platform technology solution. The third version of Eclipse evolves from an IDE platform to a Rich Client Platform. It is no coincidence that IBM is implementing its promising environment working together Workplace is based on Eclipse.

Literature

1. Marc R. Erickson, Angus McIntyre. , 2001, November.
2. J. dea Rivieres, J. Wiegand. Eclipse. A platform for integrating development tools. IBM Systems Journal, 2004, No. 2.

Eclipse organization structure

The Eclipse Foundation, a non-profit independent consortium, coordinates the development of Eclipse and contributes to open source projects of various organizations and individual developers.

The Eclipse Foundation Board of Directors is formed from four main categories of members:

• Strategic Developers - Actuate, Borland, IBM, Computer Associates, Intel, QNX, Wind River, Sybase, Scapa Technologies, BEA Systems;
• strategic consumers - HP, Montavista Software, SAP, Serena Software;
• included providers (Add-in Providers);
• Open Source project leads.

All strategic developers and strategic consumers are on the board of directors, and the other two groups delegate their representatives to it. The strategic members of the consortium also have certain rights to participate in project management committees and Boards that coordinate development processes.

The consortium maintains several basic open source projects, which include a certain number of subprojects. The base project is managed by the Project Management Committee (PMC). To manage the development as a whole, three main councils are created - for the definition of requirements (Requirements Council), for architecture (Architecture Council) and planning (Planning Council).

The Requirements Board analyzes and structures the requirements for a project. They combine requirements that address the overall goals of the Eclipse Foundation and specific project goals, the challenges of key consortium members, and the development of the Eclipse ecosystem. Based on the analysis, a list of topics and priorities is formulated that will determine the development progress. The Architecture Council is responsible for developing the Eclipse Platform architecture, describing it clearly, communicating the message to the development teams, and protecting them from inadvertent tampering. The Planning Board creates a coordinated platform release plan.

Projects are delivered by development teams led by project managers, including developers and responsible developers. The former are engaged in writing code, identifying bugs, testing and documenting programs, and also perform other tasks within the project. Responsible developers have the right to contribute to the source code repository and must influence the development progress within the project. Companies with strategic developer status in the Eclipse Foundation are required to lead at least one project. Their leadership of the committees is also encouraged.

IT technologies do not stand still, they develop every day. New programming languages ​​are being created that allow us to use all the possibilities that a computer gives us. One of the most flexible, powerful and interesting languages ​​is Java. To work with Java, you must have a software development environment. We'll take a look at Eclipse.

Eclipse is an extensible and freely available IDE. It is Eclipse that is the main rival of IntelliJ IDEA and the question: "Which is better?" still remains open. Eclipse is a powerful IDE that many Java and Android developers use to write various applications on any OS.

Attention!
Eclipse requires a lot additional files, the latest versions of which can be downloaded from the official Java website. Without them, Eclipse won't even start installing.

Of course, Eclipse is built for writing programs. After creating the project, in the text editor you can enter the program code. In case of errors, the compiler will issue a warning, highlight the line in which the error was made, and explain its reason. But the compiler will not be able to detect logical errors, that is, conditional errors (incorrect formulas, calculations).

Setting up the environment

The main difference between Eclipse and IntelliJ IDEA is that you can customize the environment completely for yourself. You can install additional plugins on Eclipse, change hotkeys, customize the work window and much more. There are sites where official and user-developed add-ons are collected and where you can download it all for free. This is definitely a plus.

Documentation

Eclipse has a very complete and easy-to-use online help system. You will find many tutorials that you can use when starting to work in the environment or in case you run into difficulties. In the Help, you will find all the information about any Eclipse tool and a variety of step by step instructions... One "but" - it's all in English.

Dignity

1. Cross-platform;
2. Ability to install add-ons and customize the environment;
3. Speed ​​of execution;
4. Convenient and intuitive interface.

Flaws

1. High consumption of system resources;
2. Requires a lot of additional files to install.

Eclipse is a great, powerful development environment that is flexible and user-friendly. It is suitable for both beginners in the field of programming and experienced developers. With this IDE you can create projects of any size and complexity.

EclipseIDE 4.5.2 is a free integrated software development environment. It differs from the rest of the IDE by the presence of open source code. Designed primarily for Java, C / C ++ and PHP developers.

Today on the Internet you can find a huge number of different text editors with code highlighting. They are free, and in principle, cope with the function of writing code, but an IDE is a completely different matter. It has a compiler that simple ones cannot boast of. text editors, as well as the ability to integrate with version control systems for team development of projects.

Description of the Eclipse IDE

The most popular and priority area for Eclipse IDE developers was Java programming. In the beginning, Eclipse was developed by the well-known company IBM and, at that time, this IDE was not free. But soon, all the developments were transferred to the Eclipse Foundation community, which is still developing this software product.

As mentioned above, the Eclipse IDE has integration with various version control systems, which allows the development team to work on a project, as well as to have all versions of the software available.

The Eclipse IDE is modular. Since it was developed at first exclusively for JAVA, there was a need for additional modules, extensions that would allow supporting other programming languages. At the moment, there are many such extensions, both paid and freely available.

Despite the free distribution, the Eclipse IDE is the main development environment for most JAVA programmers. Recently, people have grown to love her even more, since a module has been released that allows you to develop applications for Android.

Java is a high-level programming language that was developed by Sun Microsystems back in 1995. Today the development of this technology is carried out by the JCP (Java Community Process) company. One of the main features of the language is compilation, which is performed directly when the program is assembled.

The code turns into bytecode, after which it is executed in virtual machine Java. The JVM acts as a translator linking the programming language with the necessary computer components. This principle allows programs to run on any system where a virtual machine is installed.

Features of the programming language

Object oriented and typed language Java has many features that are useful to developers. Among them are the following:

• Easy to learn. Basic knowledge of object-oriented programming will be enough for comfortable mastering of the language.
• Object oriented methodology. Programs are made up of objects that can be easily expanded and adapted to achieve your goals.
• Safety. Public key encryption provides the best authentication methods.
• Platform independence. Programs written in the language are compiled into bytecode that can run on absolutely any platform of modern operating systems.
• Portability. The programming language does not depend in any way on the aspects of the specifications being implemented.
• Strength. The Java machine is capable of coping with many errors due to the developer's orientation and emphasis on continual validation and reduction in compilation time.

Besides, given language very common, as it is characterized as multi-threaded, high performance, interpreted and dynamic.

Features of Java software platforms

There are several implementations of this platform, among which Eclipse occupies a special place. The development environment for modular cross-platform applications has a number of mandatory features that are present in other similar products. Among them are:

• Generally accepted technologies for deploying programs in a user environment.
• Toolkits for creating graphical interfaces of any complexity.
• Libraries for remote control facilities and programmatic access to the data.
• Tools for running, debugging, compiling, monitoring and other actions with applications.

What is Eclipse?

Eclipse is a development environment currently controlled by the Eclipse Foundation. It provides open source code that provides new opportunities for developers. It is written in Java and is designed to improve the software development process.

This project is an infrastructure that provides basic services that are important for developers. The tools available allow you to create new technologies in Eclipse. A development environment is not just a collection of APIs - it can handle full-fledged tasks.

A huge number of open source plugins provide unlimited possibilities for tool developers. Any additions can be added to the program, which ultimately will allow you to customize and adapt it for any task.

Platform features

The programming environment has the following features:

• A wide assembly of API for adding new modules, as well as a framework for programming any extensions.
• Support for all popular operating systems.
• Eclipse, the development environment, allows programming in most well-known languages. C Sharp (C #), Java, PHP, C, Python, C ++ and many other languages ​​are supported by this program.
• RCP technology is available, the capabilities of which will be sufficient for the development of client software of any complexity and scale.
• The modularity of the program provides incredible convenience and flexibility in work.

The Eclipse project continues to evolve in many ways. The program is constantly being improved, its functionality is expanding by adding new plugins.

Platform architecture

The programming environment consists of several basic elements. First, there is the Eclipse Runtime, which is responsible for the operation of modules and plugins. This runtime environment includes basic functionality. This includes managing updates, interacting with the system, configuring plugins, maintaining the functionality of the help section.

Secondly, it is the IDE itself, which is responsible for managing projects, leading elements of the program, as well as for debugging, team development and searching among files.

Plugins such as PDE and Java Development Tools are also included in Eclipse. The environment for developing Java programs and new additions using these plugins becomes many times more functional.

Examples of other specialized assemblies

The above Eclipse SDK is one of the platform versions. Several more IDE assemblies are available with unique features, namely:

• For Java EE Developers. The version is intended for programming corporate or web applications using Java EE.
• For JavaScript Web Developers. Build to create web products with using CSS, XML, HTML and JavaScript.
• For Java Developers. Java programming version.
• For C / C ++ Developers. Assembly for programming in C ++ and C.

Each version has unique features, but the basic functionality for beginners is fully provided by the standard Eclipse (development environment). Lessons on it are available online for free, which will greatly simplify the study of the program.

Competing products

This development environment has many competitors, but it is impossible to finally choose the best representative. Eclipse can be confidently considered the most popular. Almost all developers have used it, thanks to a number of undeniable advantages.

When developing mobile applications, Eclipse (development environment) is often used. The Android platform is rapidly evolving, and the IDE's Java language support has attracted developers. However, it should be noted that its capabilities are much greater.

The main competitor of this program is NetBeans, and it is completely free. You have to pay for the Eclipse license, and this is intimidating for some. Among other competing products, one can also highlight IntelliJ IDEA, JDeveloper, Android Studio, DrJava and MyEclipse. But many consider Eclipse to be the best. The development environment has been pleasing users for many years and does not stop doing it!