2016-02-11
2015-08-26
Promotion, pyVmomi & future updates
I was recently promoted at VMware and I have new duties. The new day job (as I lovingly call it) is taking a great deal of time that I would normally devote to side projects like pyVmomi. I am hoping we will be able to find others inside VMware that I can delegate duties to.
In the mean time, I'm unable to predict project velocity because I'm unable to predict how much focus I can direct at the project. My next major action on the project will be to attempt to release an alpha release of pyVmomi with some spot-fixes embedded.
When I have a few hours to steal away for this I'll post here and talk about how to get this version and a disclaimer that the release is alpha quality and may put your own systems at risk should you use it. However, I also want to put something into user and administrator hands sooner rather than later.
Thanks to the community for continuing on as I'm working heads down.
In the mean time, I'm unable to predict project velocity because I'm unable to predict how much focus I can direct at the project. My next major action on the project will be to attempt to release an alpha release of pyVmomi with some spot-fixes embedded.
When I have a few hours to steal away for this I'll post here and talk about how to get this version and a disclaimer that the release is alpha quality and may put your own systems at risk should you use it. However, I also want to put something into user and administrator hands sooner rather than later.
Thanks to the community for continuing on as I'm working heads down.
2015-07-22
Return on Investment: high, low, and durability.
I'm heads down focusing on delivering a critical new feature to another team. But, I wanted to stop a moment and mention some of what drives how I prioritize things, how on occasion I'm directed privately to deprioritize some tasks that were very high priority previously and what the thought process behind these choices are.
We all have 24 hours in a day and 7 days in a week. Studies show that from a pure numerical stand point working more hours beyond a certain point produces a net loss in output. That is to say, plugging away at a job beyond a certain point produces a net negative return due to increased defects, mistakes, and general fatigue and a phenomena we call burnout.
Part of your own self-management should be guarding against burnout and working for net-positive output. The other part of this is to ensure that you are working in an area that will yield the best return for your personal investment. In this case, I'm talking about choosing a project and place to sink your time and effort.
... in which we make sure we keep doing the things that are important and never allow ourselves to dig into the unimportant and never urgent things.
I'm going to tell you that this particular grid is a great idea for business people in general. But we are not business people. We're innovators by definition. For us there's one more dimension that should influence our decision making.
We all have 24 hours in a day and 7 days in a week. Studies show that from a pure numerical stand point working more hours beyond a certain point produces a net loss in output. That is to say, plugging away at a job beyond a certain point produces a net negative return due to increased defects, mistakes, and general fatigue and a phenomena we call burnout.
Part of your own self-management should be guarding against burnout and working for net-positive output. The other part of this is to ensure that you are working in an area that will yield the best return for your personal investment. In this case, I'm talking about choosing a project and place to sink your time and effort.
Classical Prioritizing
We take a project and walk it through our decision making process then, we prioritize it based on its return on investment. Most folks are familiar with this decision making grid: |
| Source: http://www.ashpfoundation.org/leadershipprimer/Primer19.html (which I thought had nice graphics but don't necessarily endorse) |
I'm going to tell you that this particular grid is a great idea for business people in general. But we are not business people. We're innovators by definition. For us there's one more dimension that should influence our decision making.
Durability and priority
As an engineer, software developer, or innovator your job isn't merely to do your job. Your job is also to invent the future. That means if you are forever under the tyranny of the present you'll never get around to inventing the future. You absolutely must make room to invest part of your time into things that seem like a waste of time now on that 2D chart but will make more time later.
For example:
- automation
- invention
- mentoring
If it is repetitious, it is in a computer or involves a computer, and it is well understood... why isn't it automated? If you answer "because I don't have time" then take a moment to calculate the total time you and/or your colleges will spend doing this task over the total projected life-span of the technology stack. Then calculate a rough order-of-magnitude estimate of how long it will take to automate the task. If the two number are at all close you should automate. That's because even if you personally don't create the automation there's a high probability one of your less experienced peers might be able to use the project as a learning tool allowing you to mentor them into a higher level of proficiency. This process in turn leads to invention and innovation of the problem space.
This is the property of durability of an investment. It may be a low yield on the traditional return on investment style calculation you might perform but sometimes these apparent time-sinks when used properly enable a long term durable return.
That automation that took 3 months to invent and deliver (delaying another project like pyVmomi for example) will eventually yield a savings of 5 minutes a day over 300 engineers or a dividend of something in the neighborhood of 375,000 engineer minutes over a year. Break it down another way and you could call it 375,000 minutes (divided by 60 minutes in an hour & 8 hours in a work day & 4 work weeks per month) = 195 mythical man-months or in other words, delay now and save a whole year of effort over the next decade.
Is it worth the trade? Keeping in mind that having a wonderful 10 year plan does you no good if you're dead in the water tomorrow. So we do still have to consider the classical decision making matrix but we should also pull our 3rd dimension of durability into consideration when two opportunities look the same otherwise the more durable investment of energy should win since it will pay us back for longer.
The next question is whether you should do the task or if you should delegate the task. This is a slightly different set of calculations. We've established that the task (whatever it is) should be automated, just not precisely how. That's highly dependent on what resources you have available for performing the separate tasks of inventing the automations you need to eliminate the initial task we were considering. If the personal savings exceeds the personal expense then you should definitely perform the automation. If the group savings exceeds the group expense then the group should have someone perform the automation. Incidentally, when the personal benefit doesn't match the group benefit, we've got the potential for conflict.
At the moment I'm personally pinned working on only the #1 quadrant of important and urgent.
More on this later as I get more room to delegate.
2015-05-05
How to make a choice
Today's post is just general life philosophy. Nothing technical, and just some fatherly advice of the kind I might pass to my sons. Here's a simple set of things I ask myself before I choose to invest myself personally in something. This came up because my eldest son is working on his college career and making hard choices about what classes he'll take and which jobs he'll work.
These days I follow this process instinctively. I don't consciously think about it. I do this in everything from marriage to Open Source projects. And, when there's a crisis or decision to make I will stop and work through this set of questions again. That's because things change and sometimes we have to as well in response. It's advice, take it or leave it. I think it probably applies to relationships just as well, but I'll focus on career choices for the sake of clarity and brevity.
It's hilarious to me that so many people trying to convince me to spend my blood, sweat, tears, and years on their project don't bother to explain to me wether their wonderful idea is going to work or not. There's usually a two sided argument to this first part of my decision making process. It's got to be a dance. The first side of the dance is the optimistic side that believes the idea, the other side is the pessimistic side that doubts. For me, I need to see that both sides have played a part in the dance. If I see only one side entertained, I'm likely to leave feeling that I've been deceived at some point. That sense of deception will likely make things unworkable later.
On the other hand, if you dwell only on the pessimistic reasons something won't work, you'll never entertain any new ideas. I was all pessimism when I reviewed Netflix in the early 2000's. I had been solicited by someone (I forget who) before Netflix's IPO and I didn't follow through on pursuing the job because all I could think of were the reasons Netflix would fail. I was terribly wrong. They succeeded wonderfully but I couldn't see how at the time, and that's a bit of a shame.
These same instincts also prevented me from taking jobs at companies that really were truly total disasters. There's a few dozen risky moves I could have taken that I won't bother listing that really would have tanked my career. So, there's a careful balance, a dance or courtship with a new idea. You have to allow for the good and account for the bad. You can't be terribly precise at this phase, but you should at least stop and evaluate in dispassionate isolation the idea first.
If you don't have the tools to answer this question, you might have to just own that inability and decide whether you're an optimist or a pessimist. Now, you're just going with your gut. At least know that's what you're doing. It's practically a defining trait of being human, we don't know things and sometimes we jump without knowing. Know that you don't know and that you're taking a leap of faith.
Answer this question from all the wisdom you have, not bravado, not fear.
In some ways, this question too comes down to being wise enough to balance bravado and fear. You are a quantifiable value to yourself. You should have done some work already in this area. Sometimes this is learning to do something a bit scary or a bit hard for you and seeing how you overcome obstacles and what trips you up.
Are you bad at math? Is math going to be key to making this idea work? Are you bad at working with people? Is this idea going to sink or swim based on people-skills? You need to have as accurate a picture as you can of what you do well and play to your strengths.
That doesn't mean you have to carry the whole project, idea, relationship, community, or whatever it is all by your lonesome. You'll hopefully have a group of others along with you for this experience. You'll need to assess whether you and that group can work together, overcome together, and if the group of you have the right skills, in the right place, and at the right time to actually pull this thing off.
Answer this question from a deep understanding of yourself and your partners in this enterprise. You don't have to be able to do it all right now, you just have to be able to grow into it. You may have to continually evaluate and adjust this part as things change.
These days I follow this process instinctively. I don't consciously think about it. I do this in everything from marriage to Open Source projects. And, when there's a crisis or decision to make I will stop and work through this set of questions again. That's because things change and sometimes we have to as well in response. It's advice, take it or leave it. I think it probably applies to relationships just as well, but I'll focus on career choices for the sake of clarity and brevity.
Will it work?
The first step to evaluating whether or not to invest yourself in a project, a technology stack, a start-up, or a community is to really honestly ask yourself if this hare-brained thing will actually work. When I interview for a job, talk to start-up founders, or even projects at big multi-national multi-billion dollar corporations I ask: will this actually work? If everything is perfect but the core idea is completely unworkable it's time to move on, no other factors (like love or money) will really matter.It's hilarious to me that so many people trying to convince me to spend my blood, sweat, tears, and years on their project don't bother to explain to me wether their wonderful idea is going to work or not. There's usually a two sided argument to this first part of my decision making process. It's got to be a dance. The first side of the dance is the optimistic side that believes the idea, the other side is the pessimistic side that doubts. For me, I need to see that both sides have played a part in the dance. If I see only one side entertained, I'm likely to leave feeling that I've been deceived at some point. That sense of deception will likely make things unworkable later.
On the other hand, if you dwell only on the pessimistic reasons something won't work, you'll never entertain any new ideas. I was all pessimism when I reviewed Netflix in the early 2000's. I had been solicited by someone (I forget who) before Netflix's IPO and I didn't follow through on pursuing the job because all I could think of were the reasons Netflix would fail. I was terribly wrong. They succeeded wonderfully but I couldn't see how at the time, and that's a bit of a shame.
These same instincts also prevented me from taking jobs at companies that really were truly total disasters. There's a few dozen risky moves I could have taken that I won't bother listing that really would have tanked my career. So, there's a careful balance, a dance or courtship with a new idea. You have to allow for the good and account for the bad. You can't be terribly precise at this phase, but you should at least stop and evaluate in dispassionate isolation the idea first.
If you don't have the tools to answer this question, you might have to just own that inability and decide whether you're an optimist or a pessimist. Now, you're just going with your gut. At least know that's what you're doing. It's practically a defining trait of being human, we don't know things and sometimes we jump without knowing. Know that you don't know and that you're taking a leap of faith.
Answer this question from all the wisdom you have, not bravado, not fear.
Can you do it?
Just because an idea will work, it doesn't mean you personally can make it work. You may not have the skills, training, or talent to make a good idea actually fly. There are plenty of wonderful ideas and opportunities in the world but if it requires a skill that you can't possibly gain there's no point in pursuing it.In some ways, this question too comes down to being wise enough to balance bravado and fear. You are a quantifiable value to yourself. You should have done some work already in this area. Sometimes this is learning to do something a bit scary or a bit hard for you and seeing how you overcome obstacles and what trips you up.
Are you bad at math? Is math going to be key to making this idea work? Are you bad at working with people? Is this idea going to sink or swim based on people-skills? You need to have as accurate a picture as you can of what you do well and play to your strengths.
That doesn't mean you have to carry the whole project, idea, relationship, community, or whatever it is all by your lonesome. You'll hopefully have a group of others along with you for this experience. You'll need to assess whether you and that group can work together, overcome together, and if the group of you have the right skills, in the right place, and at the right time to actually pull this thing off.
Answer this question from a deep understanding of yourself and your partners in this enterprise. You don't have to be able to do it all right now, you just have to be able to grow into it. You may have to continually evaluate and adjust this part as things change.
Is it worth it?
Since, I've already mentioned Netflix, I'll mention them again. The second time I talked to Netflix was post IPO. I had a son in High School and even though I think we all thought I was a good "fit" for Netflix at the time, I wasn't prepared to sacrifice his high school and potentially college experience for my personal career satisfaction. To me, my son's continuity of community was more valuable than the amazing opportunity Netflix was potentially offering me. Part of me is wistful about that choice, but I made it knowing that my sons are the most valuable thing in the world to me and I was sacrificing for them. When I look back at it in that light I'm actually proud of the choice I made even though a potentially great future died because of it.
Most of the people I've known are great at sacrificing profoundly for something they really believed was worth it. I save this for last because it's too easy to answer blindly. A great idea might self-evidently work and the reward for making it work might ostensibly be worth it ... "we'll be rich!" ... "we'll be famous!" ... some move or sacrifice might seem worth it when viewed in isolation. The trick is, you never get to do anything in isolation.
You are always going to be you. You will always care the most about the things that you care the most about. If you don't count those things up first before you ask "is it worth it?" then you don't really know what you're selling to be able to buy this shiny new thing. I personally believe this is the source of many people's regret. They chose without knowing what it was they were doing and ended up giving up something they, in their inner most core, thought was more valuable for something that was simply not worth the thing that they exchanged.
I've known women that sacrificed family for career. I've known men who have sacrificed career for family. These people are happy or depressed depending on whether they understood the value of these trades and whether they chose the thing that was truly the most valuable to them. For some, children are worth more than billions of dollars and a place in history, for others a place in history is worth more than any personal comfort. Which are you? Which are you really? These things change.
The final question of what is worth your sacrifice relies on having answered the other two well and on knowing yourself well. If you know the idea works and you work with the idea... when all is said and done, will you be proud or ashamed of the sacrifices you made? Choose well, you can't know the end from the beginning.
Will you be proud to have failed at this?
Conclusion
If you're into this sort of thing, my three questions are based on the parables from Luke 14:25 to 15:32 just dressed in modern clothes and removed from the period language and concepts. It's not a complicated set of ideas. I'm sure other faiths have similar teachings, but I don't know enough other scriptures to tie them in I would love to hear other faith's teachings on this topic.
These parables in particular are about being human, making choices, and living with the consequences. They're valuable in practical ways for making us think about what we're doing and how we're living. As a collection of teachings they're an invitation to live deliberately wether or not you ascribe supernatural meanings to them.
Another analogy I've invented for this particular lesson is:
Imagine you are old and spent. There's a child you care about. You can't lie to them. You have to tell them your life's story. What will you tell them about this moment? What will you tell them you gave up? What will you tell them you chased after? Was it worth it?Knowing that you can't tell if you'll win or lose yet, you have to be comfortable discussing the loss. Live deliberately, not accidentally. Choose well, and live well.
2015-04-17
pyVmomi and VMware’s internal R&D Innovation Offsite for 2015
I've been invited to speak at VMware’s internal R&D Innovation Offsite (RADIO) on the topic of my experiences with pyVmomi. This is a rare honor, and I'm very pleased even just to be invited. For the pyVmomi community this potentially is a big boost to our visibility.
I expect to be sharing the stage with some heavy hitting presenters with big ideas to share in a fast-paced TED Talk like format. So, I'm spending a good deal of effort making sure I make the most of the opportunity.
I only have so many hours in a work week. That extra effort in one area means other areas slow down a bit. For you, that translates into a bit less predictability in when things are going to happen on pyVmomi in the near term. Right now, the plan of action looks something like this:
I have also resolved to spend more time mentoring new developers. That kind of work may cut into my actual code output and slow things down a bit when it comes to things that I personally code. The return for that slow down will be that we will grow a larger core group of developers who will be highly skilled and capable of executing projects like this one in the broader community. That's something the world just needs more of in general, so I think it's a good investment.
In a nutshell in 2015, I want to focus on mentoring more developers who can help drive this type of work forward. If you want to help and don't know how to get started, reach out to me and I'll do my best to connect you to the right places depending on your skill level. If you just want to start cutting code, feel free to jump into the samples project and start slinging away.
Either way, welcome to the party... it's just getting started.
I expect to be sharing the stage with some heavy hitting presenters with big ideas to share in a fast-paced TED Talk like format. So, I'm spending a good deal of effort making sure I make the most of the opportunity.
I only have so many hours in a work week. That extra effort in one area means other areas slow down a bit. For you, that translates into a bit less predictability in when things are going to happen on pyVmomi in the near term. Right now, the plan of action looks something like this:
- Roll out a beta of v5.5.0.2015.1 by the end of Q2 2015 as a bug fix only release
- Begin alpha work of v6.0.0.2015.2 for alpha release by the end of Q3 2015
I have also resolved to spend more time mentoring new developers. That kind of work may cut into my actual code output and slow things down a bit when it comes to things that I personally code. The return for that slow down will be that we will grow a larger core group of developers who will be highly skilled and capable of executing projects like this one in the broader community. That's something the world just needs more of in general, so I think it's a good investment.
In a nutshell in 2015, I want to focus on mentoring more developers who can help drive this type of work forward. If you want to help and don't know how to get started, reach out to me and I'll do my best to connect you to the right places depending on your skill level. If you just want to start cutting code, feel free to jump into the samples project and start slinging away.
Either way, welcome to the party... it's just getting started.
2015-02-13
retrospective and prospectives
You're busy, I'm busy, so here's a Summary of the post's points.
I'm currently juggling pyVmomi, rbVmomi, and a separate academic research project that I made commitments to. I've been talking to folks about delegating some of this work. Each of these projects deserves my full attention right now, but I can only divide myself so much. In the case of pyVmomi and rbVmomi your participation is vital and I view my job in this area as supporting the community's desire to get things done on vSphere.
I'm not the primary mover here, you are. That includes work on getting pyVmomi into the hands of python developers however they manage libraries. That is all work initiated by and driven by folks like you. As I dig deeper into what needs to happen in 2015, I would welcome your participation. If you want to take on one of the fixes that need to happen, let me know via GitHub or via IRC.
I've also gotten an early look at the vSphere 6.0 SDK and I know that there are a few new API features that developers will find immensely useful. There is also a grand SDK vision to be worked out and its early days to be talking about that yet. Remember that pyVmomi is currently a Fling from VMware so it's living in slightly different product support space than most VMware products do.
- I'm focusing on pyVmomi for a Q2 release (hopefully earlier)
- I'll be assisting in on boarding rbVmomi contributors from inside VMware in Q2 (I hope, no solid commitments there yet.)
- Both rbVmomi and pyVmomi will have samples of the vSphere 6.0 API some time in 2015
Retrospective
If we look back at the amazing output we saw in 2014, it was driven by a clear targeted focus. We knew that pyVmomi needed to be future proof. It had to be able to survive into the Python 3 era. A quick survey of the pyVmomi code base reveals that the project has existed since 2008. (I've personally been doing integrations with vSphere on some level since that time without knowledge that pyVmomi existed.) This was a big step for VMware to Open Source the project.
Today pyVmomi is a fork of that internal project. The idea of a vibrant and collaborative Open Source community improving vSphere is a novel idea. It's one that I hope will catch on. That said, 2008 was a long time ago in internet time. The future is coming and it's called vSphere 6.0
Much of this goes for rbVmomi too. I have a mental cycle that I use when approaching a project. When I enter a new project there is always a period of observation and orientation before I make decisions and start acting. When my attention is divided that forces me to lengthen my input phase before I make a decision and then act.
On the pyVmomi project I've come to trust the judgement of a select handful of contributors. If they like the submission I'm more likely to accept it. I've not built relationships like that on rbVmomi. It takes time to form that kind of trust and I'm actively soliciting VMware staff who are deeply experienced Rubyists for help in forming those.
Prospective
Most VMware followers will know the company had a big launch in February. Some of what I've been doing is coming along side folks who needed a fresh pair of eyes just before release. The launch of vSphere 6.0 is a big step toward a new future for VMware. There are many new features and new ways to integrate, converge, and innovate with these offerings. The new vSphere 6.0 API collectively point the way to how VMware of the future will deliver API, I am eager to hear people's reactions and to help adjust these offerings.I'm currently juggling pyVmomi, rbVmomi, and a separate academic research project that I made commitments to. I've been talking to folks about delegating some of this work. Each of these projects deserves my full attention right now, but I can only divide myself so much. In the case of pyVmomi and rbVmomi your participation is vital and I view my job in this area as supporting the community's desire to get things done on vSphere.
I'm not the primary mover here, you are. That includes work on getting pyVmomi into the hands of python developers however they manage libraries. That is all work initiated by and driven by folks like you. As I dig deeper into what needs to happen in 2015, I would welcome your participation. If you want to take on one of the fixes that need to happen, let me know via GitHub or via IRC.
I've also gotten an early look at the vSphere 6.0 SDK and I know that there are a few new API features that developers will find immensely useful. There is also a grand SDK vision to be worked out and its early days to be talking about that yet. Remember that pyVmomi is currently a Fling from VMware so it's living in slightly different product support space than most VMware products do.
Project Goals
Both rbVmomi and pyVmomi will have code samples available that will show off the new vSphere 6.0 API and I can talk about that more as we come up on the release. In the mean time I'll be firming up what we're going to deliver in our rapid succession 1st and 2nd releases of 2015.
2014-12-19
Projects status for Q4 2014
I'm presently allocated to several other vmware projects that are running up against hard deadlines in January 2015. Because of these resource constraints, I've been forced to remove the time lines from my other projects including the public GitHub facing projects. Both pyVmomi and rbVmomi presently do not have time lines for release anymore. I can't control my velocity on these projects, therefore I can't reliably forecast release time lines.
It is important to note that these particular versions of these projects are not officially supported VMware products and do not have purchasable support plans at this time. I will continue advocating inside VMware for the inclusion of these Open Source projects as part of the over-all product suite and API plans, however, at the moment these are Flings under the VMware labs umbrella.
I have truly relished working on pyVmomi in this very open manner and I'm actively looking for ways to make the best parts of this project parts of every project that I work on. I have already presented to various groups the wonderful lessons we've learned from both pyVmomi and rbVmomi. I feel some of my audiences were truly enlightened by my frank assessments of the lives of both these projects.
That reaction to these experiments encourages me in my pursuit of finding better ways to make impactful software. What every developer should be after is impact, not volume. We should pursue not creating more code, nor more refined code, but creating code that makes a bigger impact with lesser effort. By the term 'impact' I mean various permutations of the words 'useful', 'efficient', 'important', 'delightful', and 'powerful'.
I will post more updates in the first three months of 2015 as I have them. Progress will be quite slow between now and then as I will have to address a number of other duties and deadlines. Happy New Year to you all and I look forward to getting back down to business in 2015.
I will revisit both pyVmomi and rbVmomi in February of 2015 and update the projects respective time lines when I gain clarity on what can be done and how long it will take.
It is important to note that these particular versions of these projects are not officially supported VMware products and do not have purchasable support plans at this time. I will continue advocating inside VMware for the inclusion of these Open Source projects as part of the over-all product suite and API plans, however, at the moment these are Flings under the VMware labs umbrella.
I have truly relished working on pyVmomi in this very open manner and I'm actively looking for ways to make the best parts of this project parts of every project that I work on. I have already presented to various groups the wonderful lessons we've learned from both pyVmomi and rbVmomi. I feel some of my audiences were truly enlightened by my frank assessments of the lives of both these projects.
That reaction to these experiments encourages me in my pursuit of finding better ways to make impactful software. What every developer should be after is impact, not volume. We should pursue not creating more code, nor more refined code, but creating code that makes a bigger impact with lesser effort. By the term 'impact' I mean various permutations of the words 'useful', 'efficient', 'important', 'delightful', and 'powerful'.
I will post more updates in the first three months of 2015 as I have them. Progress will be quite slow between now and then as I will have to address a number of other duties and deadlines. Happy New Year to you all and I look forward to getting back down to business in 2015.
2014-10-16
This week on pyVmomi/rbVmomi
Last week, I took on a high priority task for VMware so my work on pyVmomi and rbVmomi had to move down in priority for me. I'll continue to post regular updates on progress but the velocity will have slowed on both project until I have cleared my higher priority tasks.
rbVmomi
- I have slid out the next release until November 15th
- I have begun learning how to upstream the github changes into the VMware git repos for rbVmomi
- we will need to determine the upstreaming process' impact on the public repo
- I need to get any merge requests peer reviewed by VMware internal folks before proceeding
pyVmomi
- I have triaged 2 new bugs
- issue 176 is an interesting issue we've seen directly impact integrations like OpenStack, SaltStack, and Ansible. I would like to find a clean answer.
- issue 180 is a problem I've heard reported before, it has to do with a newer vCenter server speaking to an older ESXi host. The current work-around is to ask the programmer to select a lowest acceptable version number (ie: 5.1) and use that namespace exclusively. The bug reporter has done a good job of breaking down the problem. We need to have a solution that will work robustly and impact client code minimally. EDIT: This issue is only known to impact ESXCLI use at this time
- I wrote a simple sample for an IRC user today describing how to navigate a virtual machine's hardware devices. The sample is rather straight forward and I was glad to get to write a sample after having neglecting samples for so long
- I revisited pyVmomi-tools and started a testing refactor using VCRpy
Thursdays will be my rbVmomi/pyVmomi day and I'll alternate between the projects. This week I spent most of my time on pyVmomi so next week I'll try to focus on rbVmomi.
More next week...
2014-10-10
Software Engineering at scale is Social Engineering
This week, I spent time at VMware's HQ in Silicon Valley. I gave a number of talks on my lessons learned with pyVmomi and rbVmomi and gave several calls to action. This week, I'd like to share one of the more profound lessons from the project. It has to do with how tools impact social interactions.
The first social networks were the ones that built software. The Software Development Life Cycle (SDLC) were social actions of developers directed, enabled, and enforced through the software tools that they used. If you take this view of creating software, then you it's natural to view any conflicts between departments or teams of developers as an opportunity to invent and apply new technology.
Let's examine something really interesting and profound about Travis CI that may not even have been intentional. The way that Travis CI shifts responsibilities through a tiny change in how builds are specified. The magic is in that .travis.yaml file and any build system that emulated the .travis.yaml file strategy would exhibit the same magical effects (even without using yaml). To understand the profundity of the change, let's revisit the bad-old-days of Developer Operations for a moment.
On the left, our developer builds some code and designs a build system to build their module. On the right an operations person builds a CI server to match. This process has some issues with it already. First off, the operations person must be told what the developer needs in a CI server. This requires a conversation and frequently its one that the operations person isn't directly incentivized to pay much attention to since this isn't likely to be their primary job.
The Operations person may even feel that their cooperation with the developer is a gift. That comes from the fact that the developer likely isn't in the Operations persons direct line of report and their collaboration is a cross-functional team. What is the Operations person really on the hook for?
Let's assume the previous gift from the Operations person lead to success. There's a working build. Over time the build works and breaks as you would expect. The developer is quite happy to fix their code to repair the build problems. Until one day... the build breaks permanently.
First the developer will try their normal work-around tricks. These won't work. The build environment is operationally broken now because the developer changed a library dependency or some other build criteria. Or, perhaps, our developer is spinning their wheels this effort is pointless, because something in the data center is broken.
What's the problem?
In the most extreme cases, the Operations person is going to be bothered during a crisis. This will result in loss of developer time as they wait on Operations (at best), or it will result in the Developer demanding more services from an already busy operations crew what the Operations person thought was a gift. And, often the timing is terrible. Both parties are blocked from doing their jobs effectively.
I've known at least one developer who would handle this by screaming "This is your job! Do your damn job!" Not only did this not get people to do their "damn jobs" but it also made them defensive viewing development as an enemy to defend against. This developer was not pleasant to be around.
Demanding people do their jobs and threatening their livelihoods doesn't exactly setup a safe place for innovation. Not all of us are high-priced-prostitutes and instead aspire to other motivations. (By the way, if you think I'm talking about you ... I'm not. I'm really really not.) If you find yourself here, start asking how to keep people from feeling like they need pitch-forks and torches.
Let's tear down this conflict. What are the facts in this scenario?
The first social networks were the ones that built software. The Software Development Life Cycle (SDLC) were social actions of developers directed, enabled, and enforced through the software tools that they used. If you take this view of creating software, then you it's natural to view any conflicts between departments or teams of developers as an opportunity to invent and apply new technology.
Let's examine something really interesting and profound about Travis CI that may not even have been intentional. The way that Travis CI shifts responsibilities through a tiny change in how builds are specified. The magic is in that .travis.yaml file and any build system that emulated the .travis.yaml file strategy would exhibit the same magical effects (even without using yaml). To understand the profundity of the change, let's revisit the bad-old-days of Developer Operations for a moment.
On the left, our developer builds some code and designs a build system to build their module. On the right an operations person builds a CI server to match. This process has some issues with it already. First off, the operations person must be told what the developer needs in a CI server. This requires a conversation and frequently its one that the operations person isn't directly incentivized to pay much attention to since this isn't likely to be their primary job.
The Operations person may even feel that their cooperation with the developer is a gift. That comes from the fact that the developer likely isn't in the Operations persons direct line of report and their collaboration is a cross-functional team. What is the Operations person really on the hook for?
Let's assume the previous gift from the Operations person lead to success. There's a working build. Over time the build works and breaks as you would expect. The developer is quite happy to fix their code to repair the build problems. Until one day... the build breaks permanently.
First the developer will try their normal work-around tricks. These won't work. The build environment is operationally broken now because the developer changed a library dependency or some other build criteria. Or, perhaps, our developer is spinning their wheels this effort is pointless, because something in the data center is broken.
What's the problem?
- if the fault is in the build service we waste time debugging code that isn't broken
- the developer is helpless to do their job without direct intervention from operations
- the operations people have no view into when a build is broken because of a service problem
- Operations may exercise their right to change how the server is running and break the build without notice to the developers
In the most extreme cases, the Operations person is going to be bothered during a crisis. This will result in loss of developer time as they wait on Operations (at best), or it will result in the Developer demanding more services from an already busy operations crew what the Operations person thought was a gift. And, often the timing is terrible. Both parties are blocked from doing their jobs effectively.
I've known at least one developer who would handle this by screaming "This is your job! Do your damn job!" Not only did this not get people to do their "damn jobs" but it also made them defensive viewing development as an enemy to defend against. This developer was not pleasant to be around.
Demanding people do their jobs and threatening their livelihoods doesn't exactly setup a safe place for innovation. Not all of us are high-priced-prostitutes and instead aspire to other motivations. (By the way, if you think I'm talking about you ... I'm not. I'm really really not.) If you find yourself here, start asking how to keep people from feeling like they need pitch-forks and torches.
Let's tear down this conflict. What are the facts in this scenario?
- The developer specifies the build's operational requirements
- building software is their job
- running build servers is not their job
- The operations person runs the build server
- running workloads, servers, and Infrastructure is their job
- deciding how software is built is not their job
Does this about cover it?
With these facts consider the following:
- The developer
- can't build software without asking for permission from operations
- Operations can't create the build server on their own
- ops has to stop a dev and ask for direction
Enter .travis.yaml
The Travis CI build setup is minimal. Point a Travis job at a repository and branch. The configuration work typically carried by an Operations person (those long configuration forms) is carried by the .travis.yaml file. This file is versioned with the code-base itself. That means, when the developer exercises their right to change their own build, the yaml file goes through version control and we can see if things break because of the change in build specification.
We now have two options as the developer:
- modify our build to fit current expectations
- request a new build environment that fits our new needs
The .travis.yaml file does not eliminate conflict or eliminate the problem, it frames the issue in a different manner.
Using a build specification by configuration file model means, the build configuration is now part of the project it describes. We have placed the control and authority over that process in the correct place ... with the person who's responsibility it is to maintain it. So one possible conflict is removed, the developer no longer has to beg and wait on Operations to donate their time to allow the developers to do their jobs.
The other part of this new social reality is, if we build a .travis.yaml file that our CI can't support we know it will fail. What's the conversation we're going to have now? The developer now has highlighted boldly that Operations is prepared to give certain services but not others and to ask for new services is to ask someone to go beyond their normal duties.
Operations persons now equipped with the right back-end tools can see what kinds of build requests are coming in, what their resource consumption and performance profiles look like... and without having to interfere with the developer's jobs they can tune their environment to cope. Build configuration by document now becomes a workload specification that an IaaS or a PaaS operator can judge for themselves whether or not they can service.
The conflict and struggle is still there, but now it's framed properly. We accomplish this through software. And, this ability to shape social interaction through software tools is why Software Engineering with more than a handful of people who know each other personally is really Social Engineering.
2014-10-03
This week in pyVmomi & rbVmomi
rbVmomi
pyVmomi
- here's an example of using vcrpy as a flight recorder for pyvmomi.
I'm in Silicon Valley next week for an unrelated project so it will likely be a slow week on the *Vmomi projects. If folks would like to meet up I'm trying to organize a hack-night for projects in pyVmomi or rbVmomi while I'm in town. Contact me for details.
2014-09-26
This week in pyVmomi & rbVmomi
pyVmomi
Not much motion this week. I've spent the majority of the week focused on coming up to speed on rbVmomi. Of note we did have a bug report of sockets getting left open and I'll be spending quality time debugging that next week.- The next major revision of pyVmomi is slipped to December now in light of my new work commitments. I will keep github up to date on how these projects are going.
- Disconnect doesn't close socket is this a pervasive bug or a quirk? TBD I'll carve time from my schedule next week to attempt to reproduce and resolve the bug as either a quirk or create a fix. The fix will go in 2014.2 at minimum but might be bad enough to cut 2014.1.2 if needed.
- We need some more education and evolution on tasks. I've shelved my work on pyvmomi-tools temporarily while I come up to speed on rbVmomi. But, tasks are one of those areas I feel the raw API is too rich for new developers to grasp right away. Some syntax sugar should help.
- Currently stalled on my desktop is an effort to introduce an SMS "plugin" (plugin isn't the right word but it's close) which I wanted to introduce through pyvmomi-tools. I'll ask for review inside VMware and from key thought leaders in the python and pyVmomi communities before shipping it to pypi ... more on this as we have time.
- We changed version conventions yet again. On pyVmomi we wanted the version number to communicate freshness and compatibility. So the year-dot-quarter method was used. Then releases moved to every six months so it's 1st half and 2nd half now. Then we found out `-` means something in pypi so now it's just a `.` character. Finally we have 5.5.0.2014.1 and 5.5.0.2014.1.1 to indicate 1st half of 2014 bug fix 1 is compatible with vSphere 5.5.0. Part of this is we still don't know precisely how pyVmomi github and pyVmomi vSphere will interact on a code-base level going forward. That's TBD be the vSphere teams in charge of that. The admittedly complex interaction between these two things
rbVmomi
Just coming up to speed on the modern state of Ruby gem management since it's been a number of years since I've had to work with them. I'm also moving cautiously since there's a standing development practice and tradition in place that I need to be mindful of.
- A prerelease for rbVmomi 1.8.2 is available on rubygems now please test!
- A regular release for 1.8.2 will happen October 1st barring any negative testing results
- A 1.8.3 release is tentatively set to got to pre-release October 17th (or so) depending on how well we can manage the process of upstreaming pull requests and this is very tentative. Note: this is a change I had intended to hold the release 2 weeks for myself to gain familiarity first. Instead I like this pre-release, delay for 3rd party testing/review, then release strategy and I'll likely adopt it as my normal operating style from now on.
- Long term planning will have to happen for a 1.9.1 release but I'll not comment much on that until I know what my long term relationship to the project looks like.
- I opened a low priority research ticket for [higher performance XML](https://github.com/vmware/rbvmomi/issues/57) which seems to be a minor scalability problem rbVmomi faces. My initial research is in the ticket. It's a help wanted item so feedback is much appreciated.
- NOTE: any item I tag 'help wanted' is an area I feel a 3rd party can either easily help with (usually also tagged 'low hanging fruit') or an area we can't really move on without outside help.
- NOTE: any item I tag 'VMware staff assistance needed' is something that I feel a 3rd party should probably avoid working on since the issue is fuzzy and bleeds into VMware internal technical details, decisions, or other issues muddy the ticket such that it's not going to move without someone (usually me) bridging the Open Source and VMware internal engineering communities.
General Status
My Friday posts will probably take this two part pyvmomi then rbvmomi flavor as long as I'm bridging both communities. Sorry if that confuses things but that's a function of Conway's law and at the moment the Open Source to VMware and back communications conduit is basically me for both projects so you have to expect a bit of that.
Thanks for your support! The following freenode IRC channels will at least have my IRC 'bot in them #pyvmomi , #pyvmomi-dev , #rbvmomi , #rbvmomi-dev , #govmomi , #govmomi-dev and I'll eventually see IRC messages in those channels through my 'bots. The -dev channels are for advanced programming topics while the other channels will be open for newblings and will need community support since I'm pretty bad at dealing with neophyte level problems these days.
More on each of these threads as progress is made...
2014-09-24
On the topic of rbVmomi
Earlier this week I started helping out on the rbVmomi project. My involvement is just to help take some pressure off of Christian Dickmann around reviewing and releasing the next version of rbVmomi.
Compared with pyVmomi, the rbVmomi project has a longer history in Open Source. While pyVmomi has existed longer, rbVmomi has the benefit of being designed from the ground up for the type of collaborative effort an API binding like this can represent. I'll want to be cautious and observant of that established project workflow and primarily act as an accelerant for the processes already there.
To address the initial problem of there being no release this year, I've begun drafting v1.8.2 which should be ready for release in a few days. Having learned from pyVmomi, I've set up a follow up release v1.8.3 to try and catch anything we miss in the earlier release. The follow up release should hit in mid-October if we need it. If it turns out we don't or can't hit mid-October I'll drop the milestone and we'll move to long-term planning. Future release schedules are TBD.
For pyVmomi, this means my attentions are divided and I've shifted out milestones for that project to match my expectations. The second release of 2014 for pyVmomi is now tentatively set for mid-December. (I hope that pyVmomi reaches feature parity with rbVmomi by that release.) Our big additions for the next release of pyVmomi should be SMS and SPBM API support provided we don't hit any hidden issues. We'll hopefully have time for EAM as well.
My role on rbVmomi at this time is just to assist in the current release plan. Christian is very much still the lead developer. I'll be using tags on the open issues and pull requests to help decide what to call out for Christian's direct attention. There's also a bit of process for this project that I'll need to work out on the fly.
More on these topics as things happen...
Compared with pyVmomi, the rbVmomi project has a longer history in Open Source. While pyVmomi has existed longer, rbVmomi has the benefit of being designed from the ground up for the type of collaborative effort an API binding like this can represent. I'll want to be cautious and observant of that established project workflow and primarily act as an accelerant for the processes already there.
To address the initial problem of there being no release this year, I've begun drafting v1.8.2 which should be ready for release in a few days. Having learned from pyVmomi, I've set up a follow up release v1.8.3 to try and catch anything we miss in the earlier release. The follow up release should hit in mid-October if we need it. If it turns out we don't or can't hit mid-October I'll drop the milestone and we'll move to long-term planning. Future release schedules are TBD.
For pyVmomi, this means my attentions are divided and I've shifted out milestones for that project to match my expectations. The second release of 2014 for pyVmomi is now tentatively set for mid-December. (I hope that pyVmomi reaches feature parity with rbVmomi by that release.) Our big additions for the next release of pyVmomi should be SMS and SPBM API support provided we don't hit any hidden issues. We'll hopefully have time for EAM as well.
My role on rbVmomi at this time is just to assist in the current release plan. Christian is very much still the lead developer. I'll be using tags on the open issues and pull requests to help decide what to call out for Christian's direct attention. There's also a bit of process for this project that I'll need to work out on the fly.
More on these topics as things happen...
2014-09-19
How to use Conway's Law for good and not evil
If you've been paying attention to our github repository you'll have noticed some noise around the following API additions to pyVmomi...
These are all presently scheduled for the next major release of pyVmomi which is currently set for December of 2014 and will be called 5.5.0-2014.2 barring any major issues.
I'll be working with the various feature teams inside VMware to figure out how best to Open Source their existing API bindings. More importantly, I'll be work with these teams to find a way that allows the effect described in Conway's Law to function beneficially on this set of projects.
I'll be working with the various feature teams inside VMware to figure out how best to Open Source their existing API bindings. More importantly, I'll be work with these teams to find a way that allows the effect described in Conway's Law to function beneficially on this set of projects.
In other words, pyVmomi isn't one large project with one BDFL directing the entire API. The reality is that the APIs potentially exposed by pyVmomi are in fact the result of multiple collaborating teams. Each of these teams will tend to be their own unique snowflake.
Couple this with the fact that we will also have the opportunity to leverage contributions from interested third parties, vendors, and partners and you can see that the previous monolithic structure might not survive the strain. I'll be taking some vital time to implement at least one or more extension strategies for the library and have them evaluated. This will probably cost 3 or more weeks worth of time but it will be worth the pain because these are long-lived projects with minimum life-spans on the order of 3 or more years.
Couple this with the fact that we will also have the opportunity to leverage contributions from interested third parties, vendors, and partners and you can see that the previous monolithic structure might not survive the strain. I'll be taking some vital time to implement at least one or more extension strategies for the library and have them evaluated. This will probably cost 3 or more weeks worth of time but it will be worth the pain because these are long-lived projects with minimum life-spans on the order of 3 or more years.
As part of this research I've come back time and again to a talk by Doug Hellmann titled Dynamic Code Patterns.
Not to diminish Doug's work at all, but his Stevedore project is an implementation of the Extensibility Pattern which is itself part of the previous generation's Software Design Patterns movement. The design patterns technique came under understandable criticism for not really contributing much to programming and more than occasionally over complicating things. It's these concerns about over complication that are going to slow me down a bit. After all, making things simple is not easy and my goal is to make things as simple as possible and no simpler.
The Stevedore project does offer something to a library like pyVmomi. It is a tool to create extensions. The term 'plugin' is not really accurate when we're talking about modules like SMS. The SMS module is neither a driver, nor is it a hook, but it is an extension. These are new classes and methods that provide new capabilities from the primary facade of the pyVmomi library itself. You can call these plugins but not in the normal sense.
There is also danger in approaching the problem of extending into these new API as a plugin. It quite possibly introduces the problem of turning pyVmomi into a framework and such a transformation would be wholly inappropriate. In particular, I am considering the use case for pyVmomi as a helper library to deliver a driver for SaltStack. What happens to the outer project if pyVmomi itself becomes a framework and does this make those consumer projects unnecessarily more complex?
We want extensibility but not at the cost of adding the need to be aware of more details. We want the library to appear as a unit even though it is actually composed of multiple sub-units. That's something that requires some subtlety. It's not something to bother with if we don't need it so... why do I think we need it?
Over the next 2 weeks I'll be experimenting with SMS support provided in a couple of different ways in the hopes of finding a sustainable, flexible, and robust mechanism to use Conway's law as a means of enforcing a structure of collaboration between teams. In particular there's a set of existing organizational and structural relationships that I feel the current design violates..
In particular, at VMware, I do not personally manage, dictate, or control what the structure or design a given ... feature interface (or sub-API) looks like. It's impractical to think I could. My role is to act as a bridge between VMware and the developer communities interested in building software on-top of the VMware platforms.
Some details about the practical nature of how modules like SMS, SPBM, and EAM for use in pyVmomi are produced directly informs our library design considerations. For example...
The Stevedore project does offer something to a library like pyVmomi. It is a tool to create extensions. The term 'plugin' is not really accurate when we're talking about modules like SMS. The SMS module is neither a driver, nor is it a hook, but it is an extension. These are new classes and methods that provide new capabilities from the primary facade of the pyVmomi library itself. You can call these plugins but not in the normal sense.
There is also danger in approaching the problem of extending into these new API as a plugin. It quite possibly introduces the problem of turning pyVmomi into a framework and such a transformation would be wholly inappropriate. In particular, I am considering the use case for pyVmomi as a helper library to deliver a driver for SaltStack. What happens to the outer project if pyVmomi itself becomes a framework and does this make those consumer projects unnecessarily more complex?
We want extensibility but not at the cost of adding the need to be aware of more details. We want the library to appear as a unit even though it is actually composed of multiple sub-units. That's something that requires some subtlety. It's not something to bother with if we don't need it so... why do I think we need it?
Over the next 2 weeks I'll be experimenting with SMS support provided in a couple of different ways in the hopes of finding a sustainable, flexible, and robust mechanism to use Conway's law as a means of enforcing a structure of collaboration between teams. In particular there's a set of existing organizational and structural relationships that I feel the current design violates..
In particular, at VMware, I do not personally manage, dictate, or control what the structure or design a given ... feature interface (or sub-API) looks like. It's impractical to think I could. My role is to act as a bridge between VMware and the developer communities interested in building software on-top of the VMware platforms.
Some details about the practical nature of how modules like SMS, SPBM, and EAM for use in pyVmomi are produced directly informs our library design considerations. For example...
- Feature teams (and their management)
- design, maintain, and release their own API
- dictate what API are official, unofficial, and deprecated
- have their own schedules, priorities, and deadlines
- are fundamentally disinterested in low-level concerns
Knowing this, any design I create for pyVmomi that dictates that a feature team must talk to me first and then convince me to do things a certain way are very likely to fail. Why? Well, let's take the opposite approach as a thought experiment and see what happens.
If I were to decide that I was going to tightly control pyVmomi and force feature teams to first get approval for API from me before I clicked my big "approved" button and there by uploading their API to github that would mean I could conceivably derail their priorities or deadlines.
What do you think would happen? I could cause a vital product or feature to slip it's release; I could force an unnecessary conflict between managers; I could find my project usurped by something the feature team felt could disentangle themselves from my meddling in their affairs. Any or all these and other scenarios could happen. In short, I would create an unnecessary friction and unintentional power-struggle as people tried to focus on issues wholly unrelated to something as trivial as providing API to people like yourself.
So, if I want to instead create a successful project in this environment I have to engineer my software so that it can function with the natural (and proper) social boundaries already present. The structure of the code itself will also influence how social interactions occur around the code base. And finally, the modularity of the code will allow me to potentially delegate power, authority, and autonomy to other people.
So what are our design concerns?
- For feature creators adding to pyVmomi we should,
- leverage existing library features
- hide low-level concerns
- allow independent ownership
- simplify the process of creating a binding as much as possible
- For integrating developers working with pyVmomi in their separate projects we should,
- present a single unified "surface" for them to use
- hide accidental complexity but expose essential complexity
- follow a rule of least surprise
I admittedly may think of more as I work through the problems but this captures what we're after in a nutshell. This library in the world of Conway's Law represents a bridge between multiple parties and it's structure will end up reflecting how these groups relate. The pyVmomi software sitting between these groups will be least painful to work with for everyone if it can be molded to it present reality.
After we tackle Open Sourcing these three new API I'll have a better picture of what that reality is. And, that's what large-scale software development is really about, not as much computers and code so much as people, relationships, and communication. Our tools affect our lives and better tools make better lives.
More on this another time...
2014-09-12
Developer Community Engagement
If you've not been following along at home, pyVmomi was run in a different manner from most VMware Open Source projects. It's been a bit of a social experiment. The last two weeks since our release, I've been working on distilling lessons learned from the past five months of the project.
I did not plan on also looking into rbVmomi ... but ... at the same time just after VMworld a certain blog post started making the rounds on social media. It's clearly an opportunity to examine what we're doing at VMware around OpenSource development projects.
rbVmomi is a more typical VMware fling project. These start as a developer driven POC project and these are developed on a best-effort basis. The rbVmomi project has closed 6 issues and closed 10 pull requests during its entire lifetime as a VMware project.
pyVmomi has benefited from having my attention full time since April/May of 2014. The total number of issues closed to date is 59 with a total number of 70 merges. These differences in numbers shouldn't be surprising, that's to be expected when you go from free time development to full time development. My personal stats have become quite impressive due to the full-time activity on GitHub.
That's all nice for me, but, what does that really mean for the library? What does that mean for developer use, experience, and over-all for VMware? It's a matter of audience and SDK adoption.
Over on stackoverflow, you can see that in its entire life-span rbVmomi has had 9 questions asked as of this writing. That indicates 9 times people who are likely to seek help on stackoverflow have sought help and those 9 times only 4 of those questions got answers.
I did not plan on also looking into rbVmomi ... but ... at the same time just after VMworld a certain blog post started making the rounds on social media. It's clearly an opportunity to examine what we're doing at VMware around OpenSource development projects.
rbVmomi is a more typical VMware fling project. These start as a developer driven POC project and these are developed on a best-effort basis. The rbVmomi project has closed 6 issues and closed 10 pull requests during its entire lifetime as a VMware project.
pyVmomi has benefited from having my attention full time since April/May of 2014. The total number of issues closed to date is 59 with a total number of 70 merges. These differences in numbers shouldn't be surprising, that's to be expected when you go from free time development to full time development. My personal stats have become quite impressive due to the full-time activity on GitHub.
That's all nice for me, but, what does that really mean for the library? What does that mean for developer use, experience, and over-all for VMware? It's a matter of audience and SDK adoption.
Over on stackoverflow, you can see that in its entire life-span rbVmomi has had 9 questions asked as of this writing. That indicates 9 times people who are likely to seek help on stackoverflow have sought help and those 9 times only 4 of those questions got answers.
Taking a look at the same search for pyVmomi yields 24 questions over a much shorter life-span.
13 of these questions have been answered and 19 of times people voted on the questions where as with rbVmomi no one voted. If you take a closer look, 17 of those questions occur after my full time commitment to the project. In the shorter time-frame my public commitment and effort to the library has helped increase developer engagement with the library improve by an order of magnitude.
The next question is... is this effort worth it? And how do we determine that?
I'm open to suggestions. What else should I be looking at?
2014-09-05
This week: Retrospectives
This was a short week, so I would like to take a moment and reflect on where we've been since May.
This week I've been getting ready for a creating a set of new spikes around a few of our unanswered sample requests. Out of these will come my development plan is to create new features to include in pyvmomi-tools. By the way, if you're new to the projects or haven't been following along, part of the reason for breaking out pyvmomi from pyvmomi-tools is to allow us to develop different release cycles and development standards and styles. It would allow a quicker-turn around on some items and also allow some experimentation in pyvmomi-tools that we might not want to risk in the core pyvmomi library.
This is all part of a social experiment I'm conducting trying to help VMware at large find the best way to engage with the open source communities. Earlier in the week someone called out this negative reaction in the rbVmomi community. Ironically, rbVmomi is much older, more robust, and feature complete than pyVmomi but the community reception to pyVmomi has been much warmer in recent weeks.
I'm getting reports of a number of python projects shifting from other vSphere API bindings to pyVmomi as the confidence in the library grows. I've been getting almost nothing but positive feedback from users of the library and I think we're well on our way to becoming the best way for integrators to work with vSphere. And, we're reaching that goal by encouraging better developer practice.
From some IRC chats earlier in the week I found out that at least one shop has traded from vijava to pyVmomi running in jython. I've not tested or verified jython for use with pyVmomi but I'm encouraged to hear the work is progressing well. If anyone else is attempting this kind of work I would appreciate hearing and/or reading about the experience.
I also find this language switch curious because vijava is actually quite well done. As a side note I am doubly curious because of my own past involvement in alternative languages for the JVM. I've not attempted jython with Java hybrid projects before and I'm curious as to how and why these fit together.
I'll be presenting these stories to VMware teams to help build the case for this style of community engagement and I plan on having a series of discussions around rbVmomi as well. As I've mentioned multiple times in this blog, merely building pyVmomi up is only one of the objectives toward my much larger goal of helping change the way we write software for the cloud.
Part of that larger goal is testing, process, and engagement.
More on this next time...
This week I've been getting ready for a creating a set of new spikes around a few of our unanswered sample requests. Out of these will come my development plan is to create new features to include in pyvmomi-tools. By the way, if you're new to the projects or haven't been following along, part of the reason for breaking out pyvmomi from pyvmomi-tools is to allow us to develop different release cycles and development standards and styles. It would allow a quicker-turn around on some items and also allow some experimentation in pyvmomi-tools that we might not want to risk in the core pyvmomi library.
This is all part of a social experiment I'm conducting trying to help VMware at large find the best way to engage with the open source communities. Earlier in the week someone called out this negative reaction in the rbVmomi community. Ironically, rbVmomi is much older, more robust, and feature complete than pyVmomi but the community reception to pyVmomi has been much warmer in recent weeks.
I'm getting reports of a number of python projects shifting from other vSphere API bindings to pyVmomi as the confidence in the library grows. I've been getting almost nothing but positive feedback from users of the library and I think we're well on our way to becoming the best way for integrators to work with vSphere. And, we're reaching that goal by encouraging better developer practice.
From some IRC chats earlier in the week I found out that at least one shop has traded from vijava to pyVmomi running in jython. I've not tested or verified jython for use with pyVmomi but I'm encouraged to hear the work is progressing well. If anyone else is attempting this kind of work I would appreciate hearing and/or reading about the experience.
I also find this language switch curious because vijava is actually quite well done. As a side note I am doubly curious because of my own past involvement in alternative languages for the JVM. I've not attempted jython with Java hybrid projects before and I'm curious as to how and why these fit together.
I'll be presenting these stories to VMware teams to help build the case for this style of community engagement and I plan on having a series of discussions around rbVmomi as well. As I've mentioned multiple times in this blog, merely building pyVmomi up is only one of the objectives toward my much larger goal of helping change the way we write software for the cloud.
Part of that larger goal is testing, process, and engagement.
More on this next time...
2014-08-29
pyVmomi v5.5.0-2014.1.1 - bug fix - is available from pypi.
This week was VMworld and we still managed to release a quick turn-around bug-fix release for pyVmomi. Up on pypi right now is the v5.5.0-2014.1.1 release. Part of the changes made involved improving our release process and incorporating feedback from RPM and DEB package maintainers.
If you're still using the December release, here's a unified change list between 5.5.0 and 5.5.0_2014.1.1:
Far and away, working on the pyVmomi has been one of the most professionally satisfying projects of my career. That's chiefly because of how immediate the interaction and feedback from users of pyVmomi has been. In most other projects feedback from users of your code base has to navigate its way back to you over time, instead on pyVmomi the feedback has been immediate.
Part of this is due to the ease of public interaction that tools like github, freenode, pypi, and twitter (with ifttt automations) offers. I plan on evangelizing this working-style to other teams within VMware and your positive feedback can only help. For a developer it's a very rewarding way to work and hopefully for a customer it's also very satisfying.
Next week, I'll be working on our 2014.2 milestone and setting up to make a go at some more community samples. It should be noted that while pyVmomi itself is able to run just fine on Python 3, many of the samples are written assuming Python 2.7 ... this is fine since the two projects are decoupled.
The reason we keep the community samples repository separate from the core pyvmomi project is to allow for each project to exercise its own standards. The samples project is very loose while pyVmomi is run extremely tightly. That's a function of where on the stack each project lives. In general the deeper down the stack you go, the more rigid the project needs to run to ensure quality and stability for all the projects built on top of it.
More on the community project next week...
- Here's the v5.5.0-2014.1.1 release notes
- Here's the v5.5.0-2014.1 release notes
If you're still using the December release, here's a unified change list between 5.5.0 and 5.5.0_2014.1.1:
- fixed session timeouts issue
- added RST documentation
- Fixes bug with Iso8601 date serialization (for messages sent to the service)
- Simplifies test-requirements.txt
- Introduces support for
tox
- Changes version number scheme
- Fixes README to be pypi compatible
- Improved sdist and bdist packaging support
- Changes to package information based on The Python Packaging Authority instructions
- Fix bug that produces traceback when running tests for the first time
- Fixes testing bug present on some distributions.
Far and away, working on the pyVmomi has been one of the most professionally satisfying projects of my career. That's chiefly because of how immediate the interaction and feedback from users of pyVmomi has been. In most other projects feedback from users of your code base has to navigate its way back to you over time, instead on pyVmomi the feedback has been immediate.
Part of this is due to the ease of public interaction that tools like github, freenode, pypi, and twitter (with ifttt automations) offers. I plan on evangelizing this working-style to other teams within VMware and your positive feedback can only help. For a developer it's a very rewarding way to work and hopefully for a customer it's also very satisfying.
Next week, I'll be working on our 2014.2 milestone and setting up to make a go at some more community samples. It should be noted that while pyVmomi itself is able to run just fine on Python 3, many of the samples are written assuming Python 2.7 ... this is fine since the two projects are decoupled.
The reason we keep the community samples repository separate from the core pyvmomi project is to allow for each project to exercise its own standards. The samples project is very loose while pyVmomi is run extremely tightly. That's a function of where on the stack each project lives. In general the deeper down the stack you go, the more rigid the project needs to run to ensure quality and stability for all the projects built on top of it.
More on the community project next week...
2014-08-22
pyVmomi: preparing for 5.5.0-2014.1.1 our first bug fix release.
I've been heads down this week, so a short update this time.
Last week, we released pyVmomi 5.5.0_2014.1 to pypi. This week we started work on preparing RPM and Debian packages which will allow pyVmomi to be included with Linux distributions important for OpenStack work.
Having released 2014.1 I opened a milestone for 2014.1.1 as a bug fix release and identified a few smaller quick turn around tasks. We have one known bug and a few minor improvements and changes that we'll have to get in place. (Being right up against VMworld has slowed down a few tasks, but we're still moving rapidly.)
Notably the 5.5.0-2014.1.1 release will:
I noted that...
In the next week-or-so, we should be able to deliver a quick-turn around bug fix release with the improvements I've listed here. We're doing well for this now that we're getting more attention from last week's release. The 2014.2 is tentatively scheduled for November 15th this year.
More on these topics next week...
Last week, we released pyVmomi 5.5.0_2014.1 to pypi. This week we started work on preparing RPM and Debian packages which will allow pyVmomi to be included with Linux distributions important for OpenStack work.
Having released 2014.1 I opened a milestone for 2014.1.1 as a bug fix release and identified a few smaller quick turn around tasks. We have one known bug and a few minor improvements and changes that we'll have to get in place. (Being right up against VMworld has slowed down a few tasks, but we're still moving rapidly.)
Notably the 5.5.0-2014.1.1 release will:
- Fix a bug with sending date-time stamps to the server
- Tweak the version number standard to fit better with pypi and RPM.
- Standardize packaging for the pyVmomi library
- Improve release documentation and processes for versions.
I noted that...
- The order of xmlns="*" attributes inside tags can occur in random order
- The amount of whitespace in documents can vary in some situations
In the next week-or-so, we should be able to deliver a quick-turn around bug fix release with the improvements I've listed here. We're doing well for this now that we're getting more attention from last week's release. The 2014.2 is tentatively scheduled for November 15th this year.
More on these topics next week...
2014-08-15
pyVmomi version 5.5.0-2014.1 is available.
Earlier today with help from other VMware employees and #python IRC users, I pushed the buttons necessary to release pyVmomi version 5.5.0-2014.1 to the general public. This is the first open source community built and released version of the vSphere Management API library since VMware open sourced the project in December.
This release featured contributions from 13 contributors, 10 of which were completely unaffiliated with VMware. With the exception of myself the most active contributors are not at all affiliated with VMware.
Special Thanks to...
Thanks as well to William Lam for championing our project as well.
This release marks an important step for pyVmomi, most notably the ability to use pyVmomi with vcrpy means we can do much more in-depth and thorough bug reporting for 3rd party developers. It also means that the focus of development can move from infrastructure to feature parity.
More on that next time...
This release featured contributions from 13 contributors, 10 of which were completely unaffiliated with VMware. With the exception of myself the most active contributors are not at all affiliated with VMware.
Special Thanks to...
- Kevin McCarthy for his vcrpy project and his contributions to pyVmomi that made stand-alone and automated testing possible.
- Michael Rice for is help in setting up Travis builds, tracking down issues, and helping out on IRC when I wasn't around.
Thanks as well to William Lam for championing our project as well.
This release marks an important step for pyVmomi, most notably the ability to use pyVmomi with vcrpy means we can do much more in-depth and thorough bug reporting for 3rd party developers. It also means that the focus of development can move from infrastructure to feature parity.
More on that next time...
2014-08-13
On the topic of Goals and Objectives for pyVmomi
As long as I'm working on the pyVmomi project, its goal will be to become the single best way to talk to vSphere technologies. This is a broad and hard to measure thing, and with luck as VMware technologies evolve, it's also a moving target. Once we arrive at one location there will be a new version to sail toward. In order to steer accurately, we must set a course by some kind of metaphorical guiding star, and this is what objectives are meant to be.
While the goal is the destination we are sailing our metaphorical ship toward, our near-term objectives are the metaphorical stars we choose to help guide us toward that goal. Just as sailing a ship may require course corrections, which implies choosing different stars; so too might managing a project require course corrections which implies choosing different near term objectives. When we course-correct ourselves, our projects, our teams, or our careers, we are changing the objectives much as a ship navigator might choose a different guiding star at different times during a ships journey toward a distant destination.
In common parlance, the terms goal and objective are virtually synonymous but it makes sense to make a distinction between them when we're talking about conducting the daily business of building software. Being "the best" is kind of hard to measure, it implies quality, adaptiveness, and nimbleness in the library as well as a breadth of uses for the library. This requires us to choose some guiding stars with wisdom.
How do you design a library for these attributes? How do you pick the correct guiding stars?
So what are some philosophies I could hold in this case?
Examples of projects guided by this principle to the exclusion of others might include things like PHP. The design choices in PHP were early on driven by getting broad adoption and rapidly securing mind-share. Very little time was spent thinking about the long-term impact of design decisions. The result is PHP is the most successful programming language (in its niche) of all time and one of the most hated.
I might choose to believe that 'feature count' was a better measure for project success. If I believed that cranking out code was the way to 'get stuff done', then I would probably believe that anything that got in your way of 'getting stuff done' was a waste of time. That would probably mean I would be after the largest volume of code in the shortest amount of time. More code means more function right?
The problem with this is feature creep. If you want to keep a light nimble software project that can respond quickly to changes in its environment a small modular project is best. You keep the project itself small or suffer the consequences. There's usually an 80/20 rule for features and following it can result in faster release cycles.
After years of working on software systems big and small, with tiny audiences and accidental audiences of millions, I've come to believe a few things.
In 2012 it was hard to tell if there was a marketplace winner in the video game console market. The three top video game consoles of the time period had traded top position on various metrics repeatedly but by Q2 2014 there is a clear winner in market sales (only time will tell if this is a permanent state of affairs).
Sony had always invested in a complete engineering package for its consoles and frequently talked about 10 year plans with its ecosystem. Ironically, this same business strategy had failed them before. When it came to BetaMax versus VHS this same strategy of 'technical superiority' did not pay off, however, and that's a cautionary tale. The entire engineering process matters.
When building a system you have to take into account all the pertinent forces shaping its market share. These include multiple product audiences, shareholders, and customers, as well as multiple engineering considerations about how the product functions. Not the least of which includes the process by which you create the product itself.
Over the years, I've been thoroughly impressed at how products generated by very bad engineering can sometimes capture and dominate markets when very good engineering fails. I believe the problem comes from improperly balancing objectives. A single dimension of engineering and design has been maximized at the expense of balancing concerns. It's far too easy to make an easy to measure metric, set it as an objective, and steer the metaphorical ship by a star that has nothing to do with the goal. Such engineering produces something that is arguably beautiful yet broken.
Merely increasing code coverage does not universally improve the code in all its dimensions. In fact, improperly applied test coverage can create tightly coupled systems that are worse suited. This is perhaps the starkest lesson you can learn about successfully reaching a 100% code-coverage goal: you can end up with more technical debt not less. (I could call out certain open source projects here but I won't for brevity's sake.)
If no metric can measure this concept of tight coupling to balance the code coverage metric, then, merely measuring code coverage percentages pushes the software design in the wrong direction. Your team will optimize for coverage at the expense of other attributes. One of those attributes can actually be code quality (in that fixing a simple bug can take an inordinately long time) and flexibility (in the sense that your code can lose the ability to respond to new requirements).
I have come to believe Test Driven Development just as code coverage can also become a trap. Improperly applied, it similarly optimizes systems for unit tests which may not reflect the real design forces that the unit of code is under. These circumstances the code developed can end up very far from the intended destination just as high code coverage numbers can degrade actual quality of a software system.
To effectively use these tools (agile or otherwise) you can't fly by instrument. You need to get a feel for the real market and engineering forces at play in building your software product. These are things that require a sense of taste and refined aesthetics. You don't get these from a text book, you get them from experience.
My experience has taught me that you actually don't want to write more code you actually want to write less. You want to accomplish as much as possible while writing as little code as necessary without falling into code golf. That means that the most effective programmer may have some of the worst numbers on your leader board. Negative lines of code might be more productive than positive, fewer commits may be more profound than more. The mark of good engineering is doing a great deal with very little and that's what we strive for in software engineering.
I also want to avoid solidifying library internals around dynamic package and class creation as well as internal aspects of the SOAP parser and its details. This puts me in an awkward position because the simplest most naive way to fence off units and begin busting-gut on test coverage would also force the tests to tightly couple onto the classes currently defined in what long-time pyVmomi developers refer to as the pyVmomi infrastructure.
If we avoid testing directly design elements (things like the XML parser itself), and we avoid testing in isolation concerns that are deemed infrastructure versus not-infrastructure, then we are left with testing the API "surface" as exposed by pyVmomi. The unit tests call on the actual symbols we want to expose to developers and these are the API surfaces as I call them. The outermost exposed interface intended for end consumption.
The shape of these fixture-based tests are virtually identical to targeted samples of the API pyVmomi is binding. Given a large enough volume of use-cases these unit tests with fixtures might eventually encompass a body of official samples. Existing as tests means that these samples will also validate the fitness of any changes against known uses of the library.
This strategy effectively retro-fits tests onto the library without locking in design decisions that may not have had very much thought. It frees us to build use-cases and eventually fearlessly refactor the library since the tests will not tightly couple to implementation specifics and instead the tests couple to interface symbols.
So far we've accomplished the following objectives in the up-coming release due to come out in mere days:
The samples and the pyvmomi unit tests need not have a 1-to-1 relationship between sample script and test, but each sample should have a set of corollary unit tests with fixtures that give basic examples and tests for the use case illustrated in the parent sample. That means one sample might inspire a large number of unit tests.
These are some of the high level objectives to reach going forward on pyVmomi:
More on that in a future post...
While the goal is the destination we are sailing our metaphorical ship toward, our near-term objectives are the metaphorical stars we choose to help guide us toward that goal. Just as sailing a ship may require course corrections, which implies choosing different stars; so too might managing a project require course corrections which implies choosing different near term objectives. When we course-correct ourselves, our projects, our teams, or our careers, we are changing the objectives much as a ship navigator might choose a different guiding star at different times during a ships journey toward a distant destination.
In common parlance, the terms goal and objective are virtually synonymous but it makes sense to make a distinction between them when we're talking about conducting the daily business of building software. Being "the best" is kind of hard to measure, it implies quality, adaptiveness, and nimbleness in the library as well as a breadth of uses for the library. This requires us to choose some guiding stars with wisdom.
How do you design a library for these attributes? How do you pick the correct guiding stars?
A little philosophy
A little philosophy is necessary to guide how we go about setting our objectives to achieve our goals. Just a little philosophy is necessary, too much and we spend our days navel gazing, too little and we flail about wildly wondering why we work so hard and accomplish so little. Regular periods of slack followed by pressure are best for this. Creativity can only come when you are free to explore but productivity only really truly solidifies itself under threat of deadline.So what are some philosophies I could hold in this case?
A few contrary points of view
I might think that audience size is the best measure of project success. That might mean I would have less priority on other aspects of the software and more on things that make the software appeal to a wide audience. In other words, a bug's priority only matters as a measure of the number of new users it can net.Examples of projects guided by this principle to the exclusion of others might include things like PHP. The design choices in PHP were early on driven by getting broad adoption and rapidly securing mind-share. Very little time was spent thinking about the long-term impact of design decisions. The result is PHP is the most successful programming language (in its niche) of all time and one of the most hated.
I might choose to believe that 'feature count' was a better measure for project success. If I believed that cranking out code was the way to 'get stuff done', then I would probably believe that anything that got in your way of 'getting stuff done' was a waste of time. That would probably mean I would be after the largest volume of code in the shortest amount of time. More code means more function right?
The problem with this is feature creep. If you want to keep a light nimble software project that can respond quickly to changes in its environment a small modular project is best. You keep the project itself small or suffer the consequences. There's usually an 80/20 rule for features and following it can result in faster release cycles.
After years of working on software systems big and small, with tiny audiences and accidental audiences of millions, I've come to believe a few things.
In Generalities
I feel that the competition between Xbox versus Playstation in the marketplace is a good case-study of these philosophical disagreements in action. The results have mostly played out in the marketplace for us all to study. If we take a lesson from this history we might be able to improve our own state of practice.In 2012 it was hard to tell if there was a marketplace winner in the video game console market. The three top video game consoles of the time period had traded top position on various metrics repeatedly but by Q2 2014 there is a clear winner in market sales (only time will tell if this is a permanent state of affairs).
Sony had always invested in a complete engineering package for its consoles and frequently talked about 10 year plans with its ecosystem. Ironically, this same business strategy had failed them before. When it came to BetaMax versus VHS this same strategy of 'technical superiority' did not pay off, however, and that's a cautionary tale. The entire engineering process matters.
When building a system you have to take into account all the pertinent forces shaping its market share. These include multiple product audiences, shareholders, and customers, as well as multiple engineering considerations about how the product functions. Not the least of which includes the process by which you create the product itself.
Engineering Objectives
Audience size matters, feature count matters, and perceived quality matters. Each affects the other and each affects the total impact of your software project. Minmaxing on only one dimension or another doesn't necessarily equate to a lasting victory. So we need to find ways to incorporate all these elements into our daily choices. That's what setting objectives is all about.Over the years, I've been thoroughly impressed at how products generated by very bad engineering can sometimes capture and dominate markets when very good engineering fails. I believe the problem comes from improperly balancing objectives. A single dimension of engineering and design has been maximized at the expense of balancing concerns. It's far too easy to make an easy to measure metric, set it as an objective, and steer the metaphorical ship by a star that has nothing to do with the goal. Such engineering produces something that is arguably beautiful yet broken.
Broken Strategy
For example, a typical strategy used to solve quality issues in software systems is to increase test coverage. Coverage is an easy number to measure. It makes nice charts and gives a wonderful feeling of progress to developers. It's also a trap.Merely increasing code coverage does not universally improve the code in all its dimensions. In fact, improperly applied test coverage can create tightly coupled systems that are worse suited. This is perhaps the starkest lesson you can learn about successfully reaching a 100% code-coverage goal: you can end up with more technical debt not less. (I could call out certain open source projects here but I won't for brevity's sake.)
If no metric can measure this concept of tight coupling to balance the code coverage metric, then, merely measuring code coverage percentages pushes the software design in the wrong direction. Your team will optimize for coverage at the expense of other attributes. One of those attributes can actually be code quality (in that fixing a simple bug can take an inordinately long time) and flexibility (in the sense that your code can lose the ability to respond to new requirements).
I have come to believe Test Driven Development just as code coverage can also become a trap. Improperly applied, it similarly optimizes systems for unit tests which may not reflect the real design forces that the unit of code is under. These circumstances the code developed can end up very far from the intended destination just as high code coverage numbers can degrade actual quality of a software system.
Actively Compensating
Agile methodologies were intended as a tool to compensate for this dis-joint between the steering stars of objectives and the actual destination. The ability to course correct is vital. That means one set of objectives are perfect for a certain season while the same objectives might be completely wrong for another season.To effectively use these tools (agile or otherwise) you can't fly by instrument. You need to get a feel for the real market and engineering forces at play in building your software product. These are things that require a sense of taste and refined aesthetics. You don't get these from a text book, you get them from experience.
My experience has taught me that you actually don't want to write more code you actually want to write less. You want to accomplish as much as possible while writing as little code as necessary without falling into code golf. That means that the most effective programmer may have some of the worst numbers on your leader board. Negative lines of code might be more productive than positive, fewer commits may be more profound than more. The mark of good engineering is doing a great deal with very little and that's what we strive for in software engineering.
From Philosophy to Concrete Objective
In the case of pyVmomi, we have no open sourced tests that shipped with version 5.5.0 as released from VMware's core API team. (Note: there are tests but they are fenced off from public contributors and this is a problem when it comes to getting quality contributions from the general population.) With no unit tests available it is almost impossible for a contributor to independently determine if their change positively or negatively impacts the project's goals. Some over-steer in the area of code coverage would be forgivable.I also want to avoid solidifying library internals around dynamic package and class creation as well as internal aspects of the SOAP parser and its details. This puts me in an awkward position because the simplest most naive way to fence off units and begin busting-gut on test coverage would also force the tests to tightly couple onto the classes currently defined in what long-time pyVmomi developers refer to as the pyVmomi infrastructure.
Separation of Concerns
The fact that there is even a term 'pyVmomi infrastructure' means that there is an aspect of the library that some people need to talk about separately from some other aspect of the library. That indicates a conflation of separate concerns. This particular point in itself would be a lovely talking point for a whole different article on how software engineering becomes social engineering after a certain point. To become a highly used, trusted, and distributed library; pyVmomi should disambiguate these concerns. But, I digress.Application of Philosophy as Strategy
I spent no less than three weeks developing the test strategy for pyVmomi that will allow us to test without boxing in the library itself. The strategy leans heavily on fixture based testing and specifically on the vcrpy library. In our case, the nuance is that our fixture needs to setup a fake socket with all the correct information in it to simulate an interaction with vCenter and/or ESXi without requiring mocked, stubbed, or simulated versions of each.If we avoid testing directly design elements (things like the XML parser itself), and we avoid testing in isolation concerns that are deemed infrastructure versus not-infrastructure, then we are left with testing the API "surface" as exposed by pyVmomi. The unit tests call on the actual symbols we want to expose to developers and these are the API surfaces as I call them. The outermost exposed interface intended for end consumption.
The shape of these fixture-based tests are virtually identical to targeted samples of the API pyVmomi is binding. Given a large enough volume of use-cases these unit tests with fixtures might eventually encompass a body of official samples. Existing as tests means that these samples will also validate the fitness of any changes against known uses of the library.
This strategy effectively retro-fits tests onto the library without locking in design decisions that may not have had very much thought. It frees us to build use-cases and eventually fearlessly refactor the library since the tests will not tightly couple to implementation specifics and instead the tests couple to interface symbols.
Objectives Accomplished
We want pyVmomi to continue to exist long enough that it can accomplish its goal of being the best library for working with vSphere. To survive, we need the library to have a lifespan beyond Python 2. We need the library to allow contributors to objectively measure the quality and fitness of their own contributions so it attracts enough developers to evolve and spread toward its goal.So far we've accomplished the following objectives in the up-coming release due to come out in mere days:
- Python 3 support gives the pyVmomi library time to live and flexibility to grow
- Fixture based tests give users and contributors confidence to develop while also...
- avoiding design detail lock-in
- hiding irrelevant library infrastructure details
- providing official samples based on actual API units that will not break as the API changes
- we also established contribution standards
Objectives to Accomplish
While we want pyVmomi community samples to evolve unrestricted and rapidly, it is also the source for requirements for the library. The samples project is separate so that it can welcome all comers with a low barrier to entry. But, it is very important as it will feed the main pyvmomi project in a very vital way. The samples become the requirements for pyVmomi.The samples and the pyvmomi unit tests need not have a 1-to-1 relationship between sample script and test, but each sample should have a set of corollary unit tests with fixtures that give basic examples and tests for the use case illustrated in the parent sample. That means one sample might inspire a large number of unit tests.
These are some of the high level objectives to reach going forward on pyVmomi:
- remain highly reliable and worthy of trust
- cover all major vSphere API use cases in unit tests with fixtures
- squash all high priority bugs rapidly which implies releasing fixes rapidly
- reach feature parity with all competing and cooperating API bindings
More on that in a future post...
Subscribe to:
Posts (Atom)