Forum Controls
Spotlight Features

The Rich Engineering Heritage Behind Dependency Injection

Andrew McVeigh takes us on a tour of the rich heritage behind dependency injection, what it represents, and tells us why its here to stay.

Java, the OLPC, and community responsibility

The "One Laptop Per Child" project has a great device ready to ship, but there's no Java on there. Let's think about working together to put Java on OLPC!
Replies: 2 - Pages: 1  
  Click to reply to this thread Reply

NetBeans adopts Eclipse-style releases

URL: http://www.netbeans.org/community/news/index.html#886

At 1:51 PM on Jul 15, 2006, Riyad Kalla Javalobby Editors wrote:

Remember the days of yester-year when releases were handled with people just knowing the different version numbers? 1.2.0, then 1.2.1. Remember text-based change logs and how hundreds of lines of text would sometimes make your mouth water? "Oh, the API now has change notification for resources!" Remember in more obscure cases, like the Linux kernel, where odd-numbered releases were development (1.1, 1.3, 1.5, etc.) and even number were stable releases (1.2, 1.4, 1.6, etc.)? I still think that schema was used because kernel developers hate normal people. Regardless, I think in this age of everything-on-the-web the patience we have to read through 100s of lines of change logs or even Bugzilla queries listing bugs targeted for a release with a status of CLOSED are approaching an end. People don't have that kind of time anymore. People want their information distilled down for them so they can focus exclusively on the line items that effect them. If they are so inclined they are free to dig into Bugzilla or change logs to see more detail. If you doubt this, consider the success of sites like Digg .

Historically the software development realm has been an elite group of computer users who are not just savvy but actually write the software that average-Joe uses day-to-day. When Eclipse started making releases one of the things I noticed right away was the New and Noteworthy docs that accompanied each release. There was no need for me to dig through change logs to look at the new features I would be using; to boot, there were screenshots! In addition to this approach of noting all the new features in each release, Eclipse started using this concept of Milestones and General Availability (GA) releases instead of Betas and Stable releases. I personally didn't warm to this idea and still don't see why the different names had to be used. I do appreciate the level of testing and cleanup that go into Milestones so instead of being straight code-drops (Working or not) they are actually like mini-releases mid-development cycle. These are certainly more time consuming then just dropping code, but as the Eclipse community found out, people use these releases for every day development no matter what. Because people are going to be using Beta software so matter what, Eclipse set forth guidelines to make these Beta (or Milestone) releases a little bit more than just blind archives of the CVS repository at a certain date in time. These releases are strictly planned for and executed.

NetBeans had an idea similar to this called their QA builds in the past. Each QA build would be accompanied by a list of Issuezilla entries that were fixed in that release. Hardly any friendlier than what we have had in the past, but it got the point across. Planning and execution for the QA builds was very similar to the Eclipse builds. However, instead of treating the QA builds like mini-releases, they were released no matter what and simply given a flag of "safe to use" or "not safe to use" along with a reason, usually 1 more Priority 1 bugs that were show stoppers.

I was browsing around the NetBeans site when I came across an announcement for the NetBeans 6.0 Milestone 1 release. Not only is the NetBeans team using the Milestone methodology now but they also included a New and Noteworthy doc ! The doc talks about a lot of the new features coming in the 6.0 release that will be the next major release of NetBeans (5.5 was just 5.0 + nice JEE stuff).

What I liked so much about this isn't that NetBeans was using Milestones now or that they included the N&N (even though I like it), it's that the team sat back and said "Hey that's kind of a cool approach Eclipse uses, let's do that" and adopted it. There was no sibling rivalry causing NetBeans to invent their own solution that was really just a duplication with different words. This is absolutely my own personal take on the adoption of this approach and most of you will read this and think "who cares", but I think it's important. The open-mindedness of the NetBeans team I believe was marked by the introduction of the Glassfish Eclipse plugin for WTP . At that point I believe people started to see that NetBeans isn't going to fight Eclipse tooth and nail for the sake of fighting, they are just going to keep doing their thing and collaborate when they can. They showed an appreciation for what the Eclipse foundation has done and respect that work. Some of you might think that shows weakness, I think it shows open mindedness that will propel NetBeans forward. Companies, teams and people that are willing to collaborate will excel much farther than folks that have the mindset that they need to invent everything. Take a look at the Eclipse umbrella. Almost every major project under that umbrella is the brain child of a strategic partner that is collaborating with the Eclipse foundation members and community to develop something bigger and better than they could have done on their own.

Times have certainly changed and I think it's great.

  Click to reply to this thread Reply
1. At 7:04 AM on Jul 17, 2006, Alex Blewitt DeveloperZone Top 100 wrote:

Re: NetBeans adopts Eclipse-style releases

FYI the naming convention (Milestones instead of Betas) is more a reflection of the development process behind it, rather than a desire to confuse users :-)

Pre-agile projects would tend to be written over a long period of time, and tested towards the end of the cycle. So, in a year-long project such as Eclipse, you'd tend to get towards a finalised version a few months from the end. You'd call it a beta, release it to the developer community, and maybe get feedback and bug fixes that could contribute to the second beta (if there is one) or just the final/stable release.

Agile projects tend to plan around delivering functionality in bite-sized chunks. So instead of waiting until month 9 to see new goodness, you'd see a small step towards that in month 1. You'd then see another small step in month 2 etc. until month 9, when they'd look roughly the same. The bite-sized chunks are referred to as milestones in the project plan (quite possibly in both agile and non-agile projects), but the agile project aims to deliver a full functioning subset of functionality at each milestone (as opposed to the non-agile, which only delivers towards the end).

Betas are more like the Release Candidates that you see towards the end of an Eclipse cycle; that's when there's finished functionality that's available for final bug-testing, last-minute tweaks etc. However, by the time you get to that stage, you know that you've already tested a suite of functionality together, so the RC stages allow you to find finer bugs, as opposed to releasing a beta and finding that it doesn't even work together.

Of course, there are other benefits as well -- the nightly build/test runs, the fact that Eclipse developers use their own product to test the features from an Eclipse PoV, and the open community that contributes fixes all help.

Hope that's interesting,

Alex.
  Click to reply to this thread Reply
2. At 10:02 AM on Jul 17, 2006, Riyad Kalla Javalobby Editors wrote:

Re: NetBeans adopts Eclipse-style releases

Alex, very interesting. Thank you for the insight. It sits a little more firmly wtih me now.
Best, Riyad [kallasoft | The "Break it Down" Blog]

thread.rss_message