Thursday, October 17, 2013

On the subject of my recent blog about funding Eclipse committers with taxes...

On the subject of my recent blog about funding Eclipse committers with taxes...

Some people have commented saying it's the worst idea they've ever heard.


That was kind of the point :-)

I was trying to be subtle (maybe too subtle), but the whole thing was really intended as an exercise in why I think the notion of taxation isn't going to work.

The best hope you have of getting taxation to work is to do exactly the opposite of what IMHO you should be trying to do.  I.e. in order to try to get the tax to succeed, you end up shooting yourself in the foot by making it harder to contribute, and hence you probably lose more help than you would ever gain.

My point as well was that in order to fund developers at the Eclipse Foundation, it's going to take a lot of money.  I don't think some people have been appreciating the scale of it, so the lousy idea of taxing committers hopefully illustrates that the amount of money required for even a token effort is not going to be easy to get, regardless of the source.  You can't just wave a magic wand and say "we'll ask people to donate it!"  Half a million dollars is a LOT of money.

Is there a viable way to raise the money on a recurring basis?  I honestly don't know.  I'm open to suggestions.

Wednesday, October 9, 2013

The Tragedy of The Eclipse Commons and Taxation

I've seen it proposed recently that in order to undo some of the "Tragedy of The Commons" happening with the Eclipse platform, that we ought to somehow enact some sort of tax whereby the Eclipse Foundation would be funded by the community and would itself hire developers to work on the Platform.

It's an interesting and tempting idea.  I'm not entirely sure how it would work though.  What would you tax?  How would you tax it?  How much would you tax it?

When it comes to taxation in our "real" lives, it comes in various forms.  Some taxes are assessed on things we do, such as income taxes.  Others are assessed based on things we own, such as property taxes.  Some taxes are on things we purchase, such as sales taxes, gasoline taxes, etc.

The Foundation does not have the power of law behind it the way our governments do, so they cannot declare by fiat that the community must all start giving them money, just because they say so.  They must somehow convince us that we should give that money voluntarily.  We are all already free to donate money to the Foundation, and this hasn't happened, so I think we need to be practical and assume that people aren't just going to open up the chequebook all of a sudden out of altruism.  The only plausible solution would be that the Foundation would somehow tax some service that they provide to the community, and if you don't pay, you don't play.

Some have suggested that seats on architecture councils and whatnot are the solution.  Pay the tax, and you get a seat.  We've already basically had that for years (various levels of corporate membership got you seats on various councils), and it hasn't really worked, because as others have pointed out, in a largely autonomous meritocracy like we have at Eclipse, these councils can't really force anyone to do anything.  The architecture council might tell project X that it ought to be doing Y at point Z in time, but when it comes down to it, it's almost entirely the committers on project X and/or their employers that decide what they work on and what direction their project takes.

I don't really call purchase of council seats a solution, because really this is part of how we have gotten here in the first place.  By and large, if I'm a company paying people to be committers on project X, it is likely that I'm going to tell my committers to work on the things that I care about.  Where the needs of others intersect with that, that's great, and if I'm a really generous company, I may even devote resources from time to time towards the common good, but the bottom line is that if push comes to shove, I am paying those people to service my needs first and all other concerns are secondary.  This is just a simple fact of life and no one can be faulted for this.

When it comes down to it, I think they only thing you really could tax is the one thing that really gives one real power on Eclipse projects, and that's being a committer on the project in question.  Committer status and the rights and privileges that go with it are the single most valuable thing the Foundation has to offer.  Without committer status, your power to effect change is very limited, but with it, you can not only commit changes to the code itself, but you get a say in project votes and strategic direction (the latter by virtue of the "every committer has a veto on code changes" principle).  The pros are very tangible.  Pay the tax, and you are clearly empowered to do things;  don't pay, and your ability to do things is definitely diminished in comparison.  Note that we speak not of simply purchasing commit status outright;  you would still have to earn your commit rights the old fashioned way, but in order to have your committer account in working order and the associated committer rights and privileges, you would have to pay the tax periodically.

Such a tax though would be a barrier to entry for those that have the desire to help out, but not the financial means.  For example, students and small companies might not be able to afford the tax, and companies might simply fork the code and keep their contributions private if they thought the tax was too high.  Some might not pay no matter what the price.  So is this tax a good idea?

In order to start trying to put things in perspective, let's try putting actual numbers to the scenario.  To keep things simple, let's say you decided that individual committers (i.e. that aren't associated with a member company) were exempt from the tax, but all other committers had to pay.  Looking at the dashboard, if you take out the individual committers, there are 465 active commiters left that might, in our simplified scenario, pay the tax.

If your goal is to hire say, 4 developers in the Ottawa area (where the Foundation offices are), your burdened cost for them including benefits and whatnot is going to be somewhere in the neighbourhood of $140k each, or $560k total for all four of them.  Whether or not 4 developers is even sufficient is up for debate of course, but let's use the number just for the sake of the thought experiment, because we have to start somewhere.

Dividing that $560k up amongst 465 committers, you need to tax them a little over $1200 a piece to get the required funds.  (Maybe they would even need to pay more than that, I'm not sure how donations to the Foundation would or would not be taxed by the government.)

So the big question is whether companies would be willing to pay that.  Some companies already pay hundreds of thousands of dollars to be "members" of the Foundation... would they be willing to pay this tax on top of that?  How many committer would you lose that either couldn't or wouldn't pay the tax?

I do not purport to have the answers here, but it's something interesting to think about.

What do you think?


Wednesday, February 23, 2011

Do You Hate It When Resources Are Out Of Sync?

Do messages like this annoy you?

Do you wish Eclipse would just fix the problem, refresh the file, and let you edit it?

If the answers to these questions are "YES" then I invite you to comment/vote on a bunch of Bugzilla entries that we are discussing these issues on.

Bug 14867 - Don't force me to refresh all the time
Bug 303517 - Update IResource sync state in a timely manner when discovered out of sync
Bug 337446 - Text search should handle out-of-sync resources

Wednesday, October 27, 2010

e4.1 is Fast

I spent the morning with Eric Moffat from the Eclipse Platform Team, trying out e4.1 with CDT and RDT. We had heard a lot of complaints in the past about e4 being slow, and the Platform Team had assured us that 4.1 was doing a lot to fix that. So, we decided to give it a spin.

Eric was kind enough to sit with us and help us get up and running, which actually wasn't that hard. The compatibility layer in e4 really shines. All the JDT, PDE, and Team stuff that I use on a daily basis just worked. I added some RSE plugins to my workbench via the Indigo update site, checked out the CDT and RDT code from CVS, built it, launched it as a runtime workbench under the debugger, and I was off to the races. I was editing, compiling, and debugging C/C++ projects, both locally on my Windows box using just CDT, and remotely over the network on a Linux/PPC box using RDT.

"So, how was the speed" you ask?

In short, pretty damned fast. I never got around to trying out e4.0, so I can't comment on whether the performance there was lacking or not, but I can tell you that e4.1 feels pretty snappy. Snappier in fact than 3.6 or 3.7. I didn't put a stopwatch on it, but everything seems faster to me. Significantly faster. Startup time seems better. GUI operations all seem faster, whether it's progress monitor updates, drawing large trees full of data, scrolling windows full of content, or resizing areas in the workbench. I was skeptical going in, given the negative reviews of performance I had heard about e4.0, but I have to say that I'm pretty impressed.

The speedups make a lot of sense too once Eric pointed out some subtle things about how the UI has been redone. The workbench now uses far less SWT Composites, and less OS level widgets than it used to. That means less things to process, as well as less memory and less OS level resource consumption. They've redone a lot of other things under the hood that I'm sure are helping too. They're not done yet either. They've got quite a lot of time between now and June to make further improvements.

Now, I don't want to falsely give the impression that there were no problems whatsoever. There was the odd glitch here and there. This stuff is pretty bleeding edge though, and that's rather to be expected. We found a few issues here and there with NullPointerExceptions that didn't used to happen, for example, because the new code lacked some null checks. Eric is taking that stuff back to the team to get fixed though, and we were able to work around them.

So, is it perfect? No. But the future is looking bright, and the speed issue may have just given everyone that was taking the "wait and see" approach to e4 a reason to start looking at it again. Not everyone might care about style sheets, dependency injection, and other goodies, but we all certainly care about speed. Speed is probably the number one thing that those of us working on Eclipse products get beaten up about. The speed of e4.1 might just be the thing that makes it take off.

Wednesday, June 18, 2008

The More Things Slow Down, The More They Heat Up

Well, it's that time of year again. The big push to get CDT 5.0 out the door is essentially over. Ganymede bits are being uploaded to the servers by the various projects. Things are looking good. It seems like it's just about time to finally sit out on a patio somewhere with a nice frosty beverage and relax.

Or is it?

Firstly, I'm busy prepping to participate again this year in the Ride for Sight, which is the longest running motorcycle charity in Canada. It's going to be a full day this coming Saturday, with many hours of riding, and I have to make sure all my gear is in order. And also, it's the final stretch of fundraising, so I'm busily annoying all my friends. (Shameless plug... to find out how you can donate, go to my donation page ). Hopefully this weekend I won't forget my hat like I did at the Port Dover Friday the 13th Rally last weekend and get sunburnt...

But more on topic, my team still has a lot of work going on right now. Right now most of us are working on Remote Development Tools, which is not on the Ganymede train. We just contributed our first initial drop of our C/C++ remote indexing tools to Bugzilla for consideration, and are still working hard to get more done so that we can get to the point where people might actually start using this stuff.

So... what is this stuff?

Essentially, we are trying to create a development environment where you can run your IDE on your local workstation, but the actual code resides on another target machine. Maybe this machine is a mainframe with no graphical windowing capabilities, maybe it's a gigantic supercomputer that you don't physically have on your desk (or if you did, you'd need a REALLY big desk...). In any case, the code you're actually working on resides somewhere that is not local.

Most of the most exciting value adds provided by Eclipse compared to other development environments require knowledge of the structure of the user's source code. Features such as source code navigation, content assist, intelligent search, call hierarchy view, type hierarchy view, the include browser, refactoring, and other features all require parsing the user's source code and producing an index which allows for name based lookups of source code elements.

Parsing and indexing are both very CPU and memory intensive operations, and good performance is a key requirement if these features are to be used by the average user. The remote scenario provides for some unique, additional challenges which have to be overcome in order for the features to work quickly and correctly.

Some important points to consider:

  • Network mounting the files and operating on them "locally" has been proven to be slow, even on fast (100 megabit) connections with very few intermediate hops.
  • Downloading the entire set of remote files (both project files and included system headers, which are not generally found on the local machine) is similarly slow.
  • Sometimes the remote machine uses a different text codepage encoding than the local machine. This means that not only must the source files be transferred, but they may have to undergo a codepage conversion process, which slows things down even further.
  • Abstract Syntax Trees (ASTs) and indices are typically much larger than the original source code from which they are produced, because they store much more information. I.e., they store a certain amount of syntactic and/or semantic understanding, which is inherently more information than is imparted by the raw bytes that correspond to the source text. As such, it's even more impractical to transfer ASTs or indices than it is to just transfer the original source.
  • The way a file needs to be parsed in order to be interpreted correctly is often dependent upon the manner in which the file is compiled. E.g., macros and include paths may be defined/redefined on the command line of any individual compilation of any individual file. A successful parse requires that those same macros and include paths be provided to the parser when it runs.
  • Often the remote machine has greater CPU power than the local machine, so it can often complete parsing and indexing tasks more quickly than the local machine.
  • Remote machines are often accessed at geographically separated locations. The intermediate topology of the network can often be complicated, with many hops, and slow links. As such, in order to maintain performance it's important for as little data as possible be transferred back and forth between the local machine and the remote machine.

As such, we feel that if the Remote Development Tools are to be successful, then they must provide remote services that allow the user to do all of the parsing and indexing on the remote machine. The local machine can query the remote machine for data it is interested in, and only this data gets transferred over the remote connection.

So, that's the motivation. We just contributed a framework and reference implementation that implements the following features for C/C++:

  • A New Remote C/C++ Project wizard that allows you to create remote projects and configure your service model (files are served by EFS)
  • Integrated index lifecycle management
  • Automatic source code delta handling (the index is automatically updated when files in your project are added/removed/changed)
  • Remote Search
  • Remote Call Hierarchy
  • Remote Navigation (e.g. Go To Declaration)
Other planned services include:
  • Content Assist
  • Type Hierarchy
  • Include browser
  • Model builder
But that's not all. Currently I'm working on a remote make builder, which will essentially let you farm out the build commands for your project over the protocol of your choice (e.g. SSH), scan the build output for errors (like we already do in CDT), and map those back to the EFS resources in your project so that you can do standard things like click on errors in the Problems View from your remote compile and be whisked away to the corresponding source location.

The builder in fact is probably the most important feature to have. Really the "I" in IDE isn't there if you can't build anything. Source introspection tools are nice, but if your tool can't build my source, chances are I'm not going to use it.

At any rate... it's looking like it's going to be a busy summer...

Monday, May 26, 2008

e4: Now With More Openness!

Well I haven't been blogging too much since EclipseCon. I came home from EclipseCon with a nasty bout of pneumonia which kept me on the bench for a bit, and ever since I've been back in the game I've been working flat out on the Remote Development Tools (RDT) initiative. (So flat out in fact that the wiki page that link goes to is woefully out of date. ) A lot of late hours and many Red Bulls later, we've got a first proof of concept demo up and running on the new RDT framework in time for our upcoming deadline, so I can finally take a bit of time again for things like attending meetings and blogging about them.

I spent Thursday and Friday last week at the e4 Summit. I won't bore everyone with all the technical details, as those can be found on the wiki page, but I wanted to make a point to express some serious kudos to everyone that made this meeting happen, especially given my past criticisms of openness in the platform.

The platform is entering a new era of openness. Seeing thirty people from thirteen different companies/organizations all working together under the scrutiny of the public eye to help design and build the next generation of the Eclipse Platform is a wonderful sight to behold. All the discussion and decisions are being made in the open where anyone can participate, whether it's at the Summit, on the mailing lists, or on the upcoming project conference calls. All the people who attended the summit are going to receive commit rights (if they want them) under the aegis of the new incubator project (which is not the old incubator project).

So, massive props to the Platform Team and everyone else involved. You are doing a great thing right now, and you deserve to be recognized for it. Good on ya!

We've got a lot of momentum going right now on e4. Great opportunities are opening up for everyone to participate in something special here, whether it's on the new browser-based-Eclipse stuff, or working or a new resource model, or something else. If you think there is something that should be a part of e4 that isn't, now is your time to speak up and contribute.

I want to emphasize the word contribute as well. People have harped on the Platform for years about it being hard to contribute to. Now that things are changing in that respect, the onus is on the rest of the community to put their code where their mouth is. Being open is not the silver bullet to build a thriving, diverse committer community. Ultimately it takes people writing code, and you could be one of those people. If you want to see something happen, pick up a keyboard and lend a hand, any way you can. The Platform folks are doing their part in opening things up, now it's the community's turn to take advantage of the opportunity. Don't waste it.

Tuesday, April 1, 2008

Sneak Peek: Eclipse In The Browser

The whole e4 thing about being able to run Eclipse in a browser with AJAX is really exciting. What most people don't know is that there is another super secret aspect of e4 that's being worked on right now that will allow people to bring Eclipse to just about everywhere, which I think is even more exciting than AJAX. That work is the new HTML port of SWT.

Some screenshots are in order:

Here's a shot of an SWT example, running natively:

Here's a shot of the same example running under the HTML port (click for a larger view with more detail):

The awesome thing about the HTML port is it can be run in ANY browser, even on mobile or other embedded devices. The secret, if you zoom in really really far, is the following:

That's right. The graphics are actually being rendered as HTML text, and use the colour settings of the font to help render the graphics. The beauty of this is that this theoretically works with any display capable of colour text. This makes it possible to run RCP apps on a whole host of new places that previously didn't have the graphical horsepower to run SWT or eSWT. Perhaps we'll even see a text mode port of SWT eventually that won't even require a browser!

Truly this is an exciting time for Eclipse!