incubator-general mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Geir Magnusson Jr." <>
Subject Re: [VOTE] Incubate new podling, "River" (nee Braintree, nee..., nee Jini)
Date Thu, 21 Dec 2006 04:13:35 GMT
Note - this vote will be for 3 days, ending midnight, saturday december 
23rd, 2006.

Geir Magnusson Jr. wrote:
> It is with great relief and hope that I propose that the Apache 
> Incubator PMC vote to incubate a new podling, to be known as "River". 
> You may be familiar with this project as it has been discussed under 
> other names, including Braintree and Jini.  I've actually lost track of 
> the Quest for a Name, and actually feel very responsible for this naming 
> mess, for which I apologize.
> Therefore, please vote on the proposal that follows :
> [ ] +1 Accept River as a new podling as described below
> [ ] -1 Do not accept the new podling (provide reason, please)
> The proposal can be found here :
> and is included below for archival purposes :
> ----------------------------------------------------------------
>  RiverProposal
> *Proposal for new project River*
> 8 December 2006
> (0) rationale
> Jini technology is a service oriented architecture that defines a 
> programming model which both exploits and extends Java technology to 
> enable the construction of secure, distributed systems consisting of 
> federations of services and clients. Jini technology can be used to 
> build adaptive network systems that are scalable, evolvable and flexible 
> as typically required in dynamic computing environments.
> Quoting from The Jini Specifications 
> ( book:
> "Jini technology is a simple infrastructure for providing services in a
> network, and for creating spontaneous interactions between programs that 
> use these services. Services can join or leave the network in a robust 
> fashion, and clients can rely upon the availability of visible services, 
> or at least upon clear failure conditions. When you interact with a 
> service, you do so through a Java object provided by that service. This 
> object is downloaded into your program so that you can talk to the 
> service even if you have never seen its kind before - the downloaded 
> object knows how to do the talking. That's the whole system in a nutshell."
> Sun Microsystems originally introduced the technology in January, 1999 
> by providing a Jini Technology Starter Kit 
> ( This includes a contributed 
> implementation of all of the specifications, as well as helpful 
> utilities and tools. The source code was made available through the Sun 
> Community Source License (SCSL) as an attempt to make the code widely 
> available and accessible to both individuals and companies. Sun has 
> continued to innovate throughout the years, releasing many versions of 
> the starter kit. The license associated with the starter kit was changed 
> (

> in March, 2005 to the Apache License, Version 2.0.
> Since its beginning, there was desire and effort to form a developer 
> community around the technology. This has helped to create an 
> interesting, active, and passionate community - the Jini Community. This 
> global Community has engaged on technology projects, discussions and 
> debates, events, and a decision making process. It has contributed to, 
> and helped influence the direction of the starter kit. Some of the 
> collaborative technology projects have led to key contributions being 
> used by other technology projects as well as commercial products. One 
> example is the Service UI API (, 
> which is a way to attach user interfaces to Jini services.
> Despite the obvious successes of the technology and Community, some 
> changes are in store as outlined in a recent note to the Community: "A 
> New Day" 
> (

> The most critical part of the new plan is to find the right place for 
> the future development and advancement of the core Jini technology. We 
> wanted an environment that was synergistic with our exisiting Community 
> culture -- so one that is active, with open communication and 
> collaboration, and a reputation for producing high quality software. We 
> think we've found that place with the Apache Software Foundation.
> (0.1) criteria
> /Meritocracy:/
> The River project will be meritocractic. The project will follow the 
> guidelines ( 
> of the Apache Software Foundation. In order to achieve this, we plan on 
> proactively recruiting individuals in the Community to get involved in 
> the project: specifying work that needs to be done, encouraging bug 
> fixes, enhancements, and advancements, and engaging in discussion on how 
> the code works and is structured. In the end, we are committed to 
> creating an environment to foster a meritocracy.
> /Community:/
> There has been a diverse and active Community built around Jini 
> technology since it was first introduced in January, 1999. The Jini 
> Community consists of a global set of individuals, companies, non-profit 
> organizations, and universities. The Community communicates primarily 
> through various email lists: jini-users 
> ( (~1400 
> subscriptions), and javaspaces-users 
> ( (~800 
> subscriptions). There are shared works and collaborative projects around 
> the core infrastructure in the Community, with many of them gathered at 
> ( There is a wiki -based web site, 
> (, which hosts a variety of information, 
> links, and content on "all things Jini". This includes organization and 
> information on events ( that 
> the Community has leveraged to share ideas and come together. There are 
> also many individuals in the Community who have chosen to evangelize the 
> technology at various conferences, user groups, blogs, etc. In summary, 
> while it isn't quite the same as running an open source community, we 
> believe we've developed an incredibly strong base on which to build.
> /Core Developers:/
> Most of the initial core developers are key members of Sun's Jini 
> development, test, and Community management team. There are three (non 
> Sun) initial core developers that are well recognized technology and 
> thought leaders in the Jini Community, including giving presentations 
> ( 
> at Jini Community Meetings, and receiving the annual Jini Community 
> Contributor's Award in recognition of their contributions to the 
> Community. There are a number of other strong developers in the 
> Community interested and we expect will prove themselves worthy 
> committers in short order.
> /Alignment:/
> River is aligned well with Apache in terms of technologies and 
> licensing. It fits in well technologically with other Apache projects, 
> which also focus on clustering, web frameworks, and Java technolgies. 
> Also, the starter kit build framework is based on Ant. The license of 
> the initial source being proposed is already aligned as it is licensed 
> under the Apache License, Version 2.0.
> (0.2) warning signs
> /Orphaned products:/
> The project being proposed is a natural evolution of the technology and 
> Community. Sun has shepherded both since 1999, and in recent years the 
> Jini Community has been pressing to be more involved and empowered. Once 
> the license for Jini technology was opened up and the Apache License, 
> Version 2.0 was chosen for Sun's contributions 
> (,

> an open development model was the obvious next step. The response from 
> the Jini Community on this direction has been very positive, with many 
> Community members anxious to get active. This is a proposal we're making 
> with a full committment to construct an active and successful project.
> /Inexperience with open source:/
> The initial committers have varying degrees of experience with open 
> source projects. All have been involved with source code that has been 
> released under an open source license, but there is limited experience 
> developing code with an open source development process. We do not, 
> however, expect any difficulty in executing under normal meritocracy rules.
> /Homogenous developers:/
> Since the Jini Technology Starter Kit has been mainly developed to date 
> by Sun Microsystems, the vast majority of initial committers to the 
> project are from Sun. Over the years, Sun has received bug fixes and 
> enhancements from other developers which have been incorporated into the 
> code. Our plan is to work with these other developers and add them as 
> committers as we progress. There are five other initial committers (non 
> Sun): Bill Venners, Dan Creswell, Mark Brouwer, Nigel Daley, and Geir 
> Magnusson. Bill is the lead of the Service UI API work; Dan has been 
> involved with much Jini-based development, including an implementation 
> of the JavaSpaces service called Blitz (; 
> Mark is a veteran of much Jini-based development, including commercial 
> work at Virgil ( as well as leading the open source 
> Cheiron ( project; Nigel was formerly at Sun as 
> the Jini test lead, but now is with another company; Geir is the 
> Champion for our Apache project proposal.
> /Reliance on salaried developers:/
> It is expected that River development will occur on both salaried time 
> and on volunteer time, after hours. While there is reliance on salaried 
> developers (currently from Sun, but it's expected that other company's 
> salaried developers will also be involved), the Jini Community is very 
> active and things should balance out fairly quickly. In the meantime, 
> Sun will support the project in the future by dedicating 'work time' to 
> River, so that there is a smooth transition.
> /No ties to other Apache products:/
> Currently the only tie to Apache projects is the starter kit's use of 
> the Ant build tool. There are potential future ties (http server, 
> database backend, etc) that will be explored.
> /A fascination with the Apache brand:/
> Many of us have been working on advancing Jini technology and developing 
> the Jini Community for many years. We care deeply about it and want the 
> technology and Commutity to continue to flourish. As we considered 
> options for where/how to move Jini technology to an open source 
> development model, our respect and admiration for the work done by the 
> Apache Software Foundation drove us to choose this as our best option. 
> As a Java-based infrastructure for building systems, River fits in well 
> with the other projects at Apache, and the Community we've built shares 
> many philosophies (open communication, fairness, diversity, etc). We 
> believe there are strong synergies here.
> (1) scope of the project
> The scope of the River project would be the continued development of 
> Jini technology core infrastructure software, including the 
> implementation of Jini specifications, related utilities and tools. The 
> development would include adding new features and improving performance, 
> scalability, quality, and extensibility.
> (2) identify the initial source from which the project is to be populated
> The initial resources would be garnered from:
> * Jini Technology Starter Kit 
> ( project 
> on,
> * Service UI implementation 
> ( from,
> * QATests (formerly, a project on
> (3) identify the ASF resources to be created
> (3.1) mailing list(s)
>     * river-private (with moderated subscriptions)
>     * river-dev
>     * river-commits
>     * river-user
> (3.2) Subversion or CVS repositories
> River would like to use a Subversion repository.
> (3.3) Jira (issue tracking)
> Since River would have its own release cycle, it should have its own 
> JIRA project
>     * Project Name: River
>     * Project Key: RIVER
> (4) identify the initial set of committers
>     * Dan Creswell (
>     * Bill Venners (
>     * Mark Brouwer (
>     * Geir Magnusson Jr (
>     * Bob Scheifler (
>     * Jim Waldo (
>     * John McClain (
>     * Brian Murphy (
>     * Peter Jones (
>     * Juan Ramirez (
>     * Frank Barnaby (
>     * Fred Oliver (
>     * Robert Resendes (
>     * Vinod Johnson (
>     * Ron Mann (
>     * Nigel Daley (
>     * Jim Hurley (
> (5) identify apache sponsoring individual
> * Champion
>     * Geir Magnusson Jr.
> * Mentors
>     * Geir Magnusson Jr.
>     * Phil Steitz
>     * Gianugo Rabellino
> ---------------------------------------------------------------------
> To unsubscribe, e-mail:
> For additional commands, e-mail:

To unsubscribe, e-mail:
For additional commands, e-mail:

View raw message