I have had a chance to tally up the results from my second year of solar panel power production.  When  I purchased the solar panels in 2015,  I had estimated a six year payback based on estimated production, and on the subsidies payed on power generated.  For 2016, I generated 3.45 megawatts, which was down 13% from 2015:

I am assuming the two primary factors for the production drop off is 2015 was a exceedingly sunny year make it hard to match, along with the gradual drop off in efficiency of the panels over time.  I will be surprised if following years show the same level of dropoff.  Interesting, this year showed better production numbers for the last 5 months of the year vs 2015, so that gives me hope that its not a panel issue.

In my payback analysis I had budgeted $2,098 of revenue a year, and my check for 2016 came in at $1,853.  So early on it looks like 6 years might be optimistic.  The other danger to the 6 year payback is the possible lowering of incentives on home power generation.  The money available always seems to be at risk,  but it appears possible that incentives will be less then originally estimated.   House Bill 1048 was introduced to finalize the incentives (see bill summary here) so a lot will depend on if this passes this year.  Interestingly, this bill does include incentives past 2020, which I did not include in my payback analysis, so that is a plus.

The maintenance of the panels has been a pleasant surprise, an occasional hosing off of the panels from ground level, and once or twice a year I get up on the roof and wash and squeegy them.   In the spring the pollen was pretty dense on the panels, and I did notice an increase in production after a cleaning.

On a related power note, while I was out checking power meters, I checked my usage meter and my usage was 8.4 megawatts, up 4% for the year.  This surprised me a bit – since in 2015 we ran more air conditioning and in 2016 I replaced a number of lights with LEDs.  However,  I will attribute the increase in usage to the additional time I spent working from home in 2016, thus leaving more lights and heat on (maybe the refridgerator door being opened more often?).  Anyway, I am targeting a reduction in usage for 2017.

In summary, I am  still pleased with the investment, and am now shooting for a 7-8 year payback which still isn’t too bad.  Solar panel prices continue to drop, and when I get around to needing to replace my roof the solar shingles look like they might be ready.  So I plan to be in the power business for many years to come.

A followup to my previous post on the programming churn.  In my many years of programming, the thing I find amusing is how programming has gone back and forth between centralized and distributed computing.  Talk about a churn, re-envisioning architectures with new languages where old is new.

For example, when I first started coding the mainframe was king – central processing with multiple dumb terminals.  COBOL, Assembler, CICS where the tools of the day.  In the mid 1980’s ‘client server’ computing was hailed as the new world order, taking advantage of the power of these new PCs that were starting to appear in businesses.  One problem – the infrastructure in the 1980’s made it complex (and slow) for two machines to talk to each other – networking was in its infancy, and cross company communication was via modems and phone lines.  In the early 1990s, client server started to mature with software like Fox-pro, Microsoft Access and Visual Basic, as well as better PC based databases.

Then in the mid 1990’s the Internet came along, and from the late 1990’s til early 2010’s, the pendulum swung back to the server model – where all the processing was done on the server and dumb html pages were served up to the browser.   The model was eerily similar to mainframes.  New development in client server pretty much died as browser based apps became the new normal.

Did I say client server died?  Wait, like a zombie it is back, this time in the form of javascript, javascript libraries, and JavaScript frameworks.   JavaScript running in the browser has evolved from simple form validation to a full blown programming platform.  First JQuery started the flood of code onto the browser, now frameworks like AngularJS or React have pretty much brought us the return of fat client computing.

In the 80’s the infrastructure was the bane of client server – this time around, its the language.  By most accounts JavaScript is a terrible language that was pressed into service because it was the only cross platform language available.  So to get around the ugliness of JavaScript, it has been somewhat abstracted by libraries that generate JavaScript.  In someways its a convoluted mess (this is a great post discussing the current challenges..).  The current tooling is painful also – the whole front end world seems disjointed.

Lets not even get to the current horror story of if you want to build a phone app, you have to build the app twice (with very little code sharing) – one for Android, one for IOS.

So will client server win out?  I think in a couple of years the current hot mess will be cleaned up as the language and tooling improves.  One complicating  factor will be the rise of the internet of things – which will bring forth a zillion tiny devices that can talk to each other.  Yes your washer can talk to your dryer, your lights can talk to your doorbell, etc.  This is going to drive a whole new architecture of applications.  These ‘client’ devices will be pretty dumb – though some maybe servers since all they supply is data (lightbulbs, switches), and some may be considered clients because they have a user interface (thermostats, garage door openers).  This is going to blur the lines between what is a client and what is a server.

So maybe the the whole concept or servers and clients will disappear, finally putting an end to the client server debate.  One thing for sure though – there will be new languages and software architectures to learn, to keep the programming churn alive and well.