PlanetMysql.ru — информация о СУБД MySQL

This is my assessment as a judge of the recently-held open source license debate held by the FOSS Learning Centre. We’ll have to begin with some qualifications and definitions, starting with the fact that there is no ‘best’ open source software license. Still, a star-studded open source software panel provided a lively, informative debate on the merits of some top open source licenses. For that, I congratulate and thank the panelists, Mike Milinkovich from the Eclipse Foundation arguing for the Eclipse Public License, Matt Asay of Alfresco arguing in favor of the GPL and David Maxwell from Coverity arguing for BSD. All three put forth some of the most important attributes and shortcomings of the three open source licenses, as well as other, related open source licenses. However, using a complex, proprietary formula awarding points for goodness and minuses for badness, I was able to deem a winner: Mike Milinkovich and the EPL. Perhaps fitting that the license that can best be described as the middle of the spectrum should be the winner. Here’s why:

Matt Asay kicked off the discussion, which became more of a debate as it developed, with a consistent message about GPL’s dominance among open source software projects, which is 70% or more based on most accounts (and considering GPLv2 and GPLv3). He also referred to monetization and the fact that GPL serves as the basis for successful support and services models, such as Red Hat. However, Matt did not initially mention the strategic and defensive benefits of GPL, which is often chosen because it mitigates the threat of a fork that someone can make proprietary. I was also hoping for him to address how GPL can deliver benefits of open source without having to share as in the spirit of the license, based on whether and how the software is distributed. Nevertheless, Matt made his most compelling arguments around the fact that GPL is the primary open source model and the license that developers understand and trust most. He furthered his argument later by agreeing EPL may be better for lawyers, but GPL is better for developers. Matt reinforced these ideas with his reference to large companies using GPL software, such as Google or TiVO, that gets it to vast numbers of users.

Mike Milinkovich spoke second with some background on EPL, its origin as a ‘legal document’ and how it links open source software to commercial products. He also hit on the fact that EPL covers patent rights, which is certainly important to vendors and developers. He later referred to the meaninglessness of Matt’s 70% GPL figure, based on the idea that software on repository is something different than software in use (where other licenses do have greater representation). However, our research indicates that the most popular open source licenses among hosted code are consistent with the most popular open source licenses among code in use, with GPL, BSD and EPL all in the top. Mike also referred to commercialization and money, which is certainly important to commercial open source, but did not give equal mention to community until later. Still, Mike earned back a point when he referred to monetization of open source software among traditional vendors and organizations beyond VC-funded, open source startups, where we are seeing significant growth for open source software. While I would have liked to have heard an argument in favor of EPL based on compatibility, Mike also made a good case for EPL in government — another consistent theme of the discussion — where code would belong to the public with commercial opportunity on top.

David Maxwell signaled a more rebuttal-type response and gave it in his arguments for the BSD license, which he introduced as the oldest license given its roots to Unix and the ’80s. David scored a point for simplicity and straightforwardness when he read the actual license, something his peers would’ve had a hard time doing. David did somewhat jump the gun, though, on rebutting with his counterpoints about GPL’s strict copyleft requirements, which he called ‘enforcement-based.’ Still, David recovered with an argument for BSD based on its emulation, which he credited for other popoular licenses such as the Apache Public License and Artistic License.

The debate portion was followed by some good discussion of business models, open core and proliferation with questions from the live and Web audiences. So why does my vote for the winner go to Mike and the EPL? While it was certainly close on my card and all three made compelling arguments, Mike and his portrayal of the EPL were the most realistic and pragmatic to today’s open source software in the enterprise. Communities, copyleft and the sharing that allows developers and projects to sustain effective, productive open source efforts must be balanced with commercial interests, endeavors and aspiration. Neither open source communities nor open source commercialization would be nearly as significant without one another, and Mike’s arguments and statements seemed most closely attuned to that.

Thanks again to the panelists, participants and FOSS Learning Centre for putting on the event. Please get involved in the discussion and watch the debate, comment here or elsewhere.

PlanetMySQL Voting: Vote UP / Vote DOWN

TOTD #97 showed how to install GlassFish Tools Bundle for Eclipse 1.1. Basically there are two options - either install Eclipse 3.4.2 with WTP and pre-bundled/configured with GlassFish v2/v3, MySQL JDBC driver and other features. Or if you are using Eclipse 3.5, then you can install the plug-in separately and get most of the functionality.

TOTD #98 showed how to create a simple Metro/JAX-WS compliant Web service using that bundle and deploy on GlassFish.

This Tip Of The Day (TOTD) shows how to create a simple Java EE 6 application that reads data from a MySQL database using JPA 2.0 and Servlet 3.0 and display the results. A more formal support of Java EE 6/Servlet 3.0 is coming but in the meanwhile the approach mentioned below will work.

Lets get started!

1. Configure database connection - The key point to notice here is that the MySQL Connector/J driver is already built into the tool so there is no need to configure it explicitly.
   1. From "Window", "Show Perspective", change to the database perspective as shown below:
      
      
   2. In the "Data Source Explorer", right-click and click on "Database Connections" and select "New ...":
      
      
   3. Search for "mysql" and type the database name as "sakila":
      
      
      
      This blog uses MySQL sample database sakila. So please download and install the sample database before proceeding further.
   4. Click on "Next >" and specify the database configuration:
      
      
      
      Notice the "Drivers" indicate that the JDBC driver is pre-bundled so there is no extra configuration required. If you are using a stand-alone Eclipse bunde and installing the plugin separately, then you need to configure the MySQL JDBC driver explictily.
      
      The URL indicates the application is connecting to the sakila database. Click on "Test Connection" to test connection with the database and see the output as:
      
      
      
      and click on "Finish" to complete. The expanded database in the explorer looks like:
      
      
      
      The expanded view shows all the tables in the database.
2. Create the Web project & configure JPA
   1. Switch to JavaEE perspective by clicking "Window", "Choose Perspective", "Other ..." and choosing "Java EE".
   2. Create a new dynamic web project with the following settings:
      
      
      
      Only the project name needs to be specified and everything else is default. Notice the target runtime indicates that this is a Java EE 6 application. Click on "Finish".
   3. Right-click on the project, search for "facets" and enable "Java Persistence" as shown below:
      
      
   4. Click on "Further configuration available ..." and modify the facet as shown below:
      
      
      
      Make sure to disable "orm.xml" since we are generating a standard Java EE 6 web application. Choose "sakila" as the database. Click on "OK" and again on "OK" to complete the dialog.
3. Generate the JPA entities
   1. Right-click on the project, select "JPA Tools", "Generate Entities" as shown:
      
      
   2. Choose the schema "sakila":
      
      
      
      and click on "Next >". If no values are shown in the schema drop-down, then click on "Reconnect ...".
   3. Specify a package name for the generated entities as "model" and select "film" and "language" table:
      
      
      
      and click on "Finish". The "film" and "language" table are related so it would be nice if all the related tables can be identified and picked accordingly.
      
      Anyway this generates "model.Film" and "model.Language" classes and "persistence.xml" as shown below:
      
      
      
      Also notice that "web.xml" and "sun-web.xml" have been explicitly removed since they are not required by a Java EE 6 application.
   4. "model.Film" class needs to modified slightly because one of the columns is mapped to "Object" which is not a Serializable obect. So change the type of "specialFeatures" from Object to String and also change the corresponding getters/setters accordingly. The error message clearly conveyed during the initial deployment and so could be fixed. But it would be nice to generate the classes that will work out-of-the-box.
4. Create a Servlet client to retrieve/display data from the database
   1. Right-click on the project, select "New", "Class" and specify the values as:
      
      
      
      and click on "Finish". This class will be our Servlet client.
   2. Change the class such that it looks like:
      

      @WebServlet(urlPatterns="/ServletClient")
      public class ServletClient extends HttpServlet {
        @PersistenceUnit
        EntityManagerFactory factory;
      
        protected void doGet(HttpServletRequest req, HttpServletResponse resp)
               throws ServletException, IOException {
          ServletOutputStream out = resp.getOutputStream();
          List list = factory.createEntityManager().createQuery("select f from Film f where f.title like 'GL%';").getResultList();
          out.println("<html><table>");
          for (Object film : list) {
            out.print("<tr><td>" + ((Film)film).getTitle() + "</tr></td>");
          }
          out.println("</table></html>");
        }
      }
      

      
      and the imports as:
      

      import java.io.IOException;
      import java.util.List;
      
      import javax.persistence.EntityManagerFactory;
      import javax.persistence.PersistenceUnit;
      import javax.servlet.ServletException;
      import javax.servlet.ServletOutputStream;
      import javax.servlet.annotation.WebServlet;
      import javax.servlet.http.HttpServlet;
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      
      import model.Film;
      
      

      Basically, this is a Servlet 3.0 specification compliant Servlet that uses @WebServlet annotation. It uses @PersistenceUnit to inject the generated JPA Persistence Unit which is then used to query the database. The database query return all the movies whose title start with "GL" and the response is displayed in an HTML formatted table.
   3. Right-click on the project and select "Run As", "Run on Server" and select GlassFish v3 latest promoted build (this blog used build 61) as:
      
      
      
      and click on "Finish". The output at "http://localhost:8080/HelloJPA/ServletClient" looks like:
      
      

Simple, easy and clean!

How are you using Eclipse and GlassFish - the consolidated bundle or standalone Eclipse + GlassFish plugin ?

Download GlassFish Tools Bundle for Eclipse now.

Technorati: glassfish eclipse mysql jpa database

PlanetMySQL Voting: Vote UP / Vote DOWN

Jay has already provided a good overview of the debate related to the apparent decline in the usage of the GPLv2. I don’t intend to cover the same ground, but I did want to quickly respond to a statement made by Matt Asay in his assessment of the reasons for and implications of reduced GPLv2 usage.

He wrote:

“as Open Core becomes the default business model for ‘pure-play’ open-source companies, we will see more software licensed under the Apache license”

I don’t doubt that we will see more software licensed under the Apache license, and also more vendors making use of permissively-licensed code, but I don’t see a correlation with the Open-Core model.

In our report, “Open Source is Not a Business Model“, report we found that 23.7% of the 114 vendors we covered were using Open-Core as a vendor licensing strategy. Looking at the stats, over 70% of Open-Core strategy users also used a variant of the GPL or LGPL.

The main reason for the correlation of the L/GPL and Open-Core is, as Matt notes, that “the GPL makes sense in a world where vendors hope to exercise control over their communities”. Carlo Daffara agrees: “the GPL is not a barrier in adopting this new style of open core model, and certainly creates a barrier for potential freeriding by competitors”.

Carlo cites as an example the use of the GPL by the usually Apache-focused SpringSource for its SpringSource dm Server as a means of restricting the commercial opportunities for potential rivals, something that we covered here.

As Matt explains, however, “if the desire is to foster unfettered growth, Apache licensing offers a better path”. Savio Rodrigues offers an example of a usually L/GPL-focused company - Red Hat/JBoss - choosing the Apache License for its new HornetQ messaging software because “the project team felt that the Apache license would ensure that the project’s code could be more easily included into products from the ecosystem.”

1-1 then. But this isn’t about point scoring. What the examples demonstrate is that vendors choose licenses for individual projects/products based on pragmatic business reasons rather than dogmatic commitment to licensing philosophy, and that - as we previously suggested - there is actually some benefit in the proliferation of different licenses.

Of course it is also important to remember that many vendors don’t have the luxury or choosing a license for the project they attempt to commercialize. Mike Olson notes that adoption has been a factor related to the Apache licensed Hadoop project - but what came first commercialization or adoption?

I believe we are seeing increased adoption of permissively-licensed open source software by both new open source specialists, such as Mike’s Cloudera, and also proprietary vendors such as Oracle, SAP and - as recently discussed - Day Software.

In these cases, the commercial vendor doesn’t choose the Apache license for software to encourage widespread adoption, it is encouraged to choose Apache-licensed software because of widespread adoption (not to mention the low cost and high quality advantages of being part of a true developer *community*).

That has more to do with the patron model, as discussed by Day Software’s chief marketing officer, Kevin Cochrane, than it does Open-Core.

Additionally, as Carlo notes, it is a product of the shift towards what he calls “consortia-managed projects”. Or as I previously stated: “if Open-Core was a significant revenue strategy of open source 3.0 (vendor-dominated open source projects such as MySQL, JasperSoft), then Embedded [as I was referring to the patron model at the time] is one of the commercial open source strategies of open source 4.0 (vendor-dominated open source communities such as Eclipse, Symbian).”

So while we expect Open-Core to remain a significant business model for ‘pure-play’ open-source companies, and we expect to see more software licensed under the Apache license, we don’t see the two as being directly related.

Anyway, this was supposed to be a quick post. That’s enough for now.

PlanetMySQL Voting: Vote UP / Vote DOWN