Jezz Santos

NuPattern Updated!

Jezz Santos — Thu, 16 May 2013 21:47:20 GMT

We just released our first minor update to NuPattern, version 1.3.21.0. No big deal, it just fixes some minor issues for the previous major release.

However, for the first time EVER we appear in the ‘Updates’ of the Extension Manager in Visual Studio.

I have to tell you that this IS a big deal to me, and perhaps others on the project who started with the project back in late 2009. We have had to wait a very long time (more than 3 years) to have presence in this nifty piece of UI with our stuff in it. Helping make sure everyone stays up to date with the technology! It is huge for us.

If you are wondering why we have had to wait so long for this, here is a summary:

The NuPattern project started in late 2009, and our first release followed 3 weeks later. We had something like 15 regular releases in 2010 as the project was incubated, proven and hardened. However, all these releases were hidden from public view as part of a ‘internal’ enterprise initiative between Microsoft and Raytheon. You can learn more about that here and here. After that initiative concluded, VSPAT (as it was known at the time) continued to be hardened and applied to other Microsoft initiatives, for other enterprise customers, none of which saw the public light of day. It was used in a public ‘Microsoft Amalga’ product release as their tooling platform, but ‘Microsoft Amalga’ is not really the sort of product you would buy shrink-wrapped, or for general consumption. The platform of VSPAT was as such, kept internal at Microsoft.
In late 2011, Microsoft finally open sourced the project on CodePlex, and we had the 19th release (1.2.19.0) on the Visual Studio Gallery. This being the first celebrated public release.
Then disaster struck. Further releases of VSPAT were seriously hampered because of the critical ‘Feature Builder Power Tool’ dependency that we had was not being supported for VS2012 by Microsoft. Prevented us releasing any updates, and that held us up for another 8 months!
That issue finally resolved, in March of this year we released the 20th version (1.3.20.0) of NuPattern, but the branding, identity and binary compatibility had to be seriously overhauled because of the transition from Microsoft ownership to Outercurve ownership, and with the support for VS2012, and integration of the ‘Feature Extension Runtime’ – i.e. no chance possible for an automatic update of NuPattern there.

Not until yesterday could we finally put out there a release (1.3.21.0) that could ‘automatically’ continue the journey of NuPattern.

We hope you all update soon, and look forward to new updates as we move the technology forward.

Congrats again to all that made this journey possible.

Feature Builder Power Tool Future

Jezz Santos — Thu, 09 May 2013 10:08:29 GMT

The ‘Feature Builder Power Tool’ was originally built by the Visual Studio Architecture team as a component of an overall vision to deliver software factory tooling to enterprise customers. The work started in earnest in 2008, and the FBPT project concluded within about 6-8 months. The project had a grander vision, but never received further funding to reach its full potential. Since its first release on the Visual Studio Gallery in 2009, the project has attracted some success.

The project delivered two parts:

The first part, the core part, was a Visual Studio extension that hosts Guidance Workflows in Visual Studio bringing contextualized and automated guidance into the IDE. It delivered both a ‘Guidance Workflow Explorer’ window which illustrated the workflow, and a ‘Guidance Browser’ window with which to browse the content of the individual elements in the workflow. A ‘Guidance Workflow’ is composed from of a set of instructional or informational steps, that can be sequential and multi-branched, and can be conditional on both manual gestures (like a tickbox) and automated conditions calculated form the development environment. The benefit of using such rich workflows is that they can not only help you understand a process where you could check off steps as you perform them manually, but also the workflow itself can calculate completed steps based on what you have done in your solution. The workflows allow multiple threads of concurrency in the workflow, which enables teams to complete complex or long running processes concurrently. As steps are completed in the workflow, new steps and paths through the process light up. You progress through the workflow until it is completed. Basically, it is an automated workflow processing engine. Very powerful indeed, especially for instructional kinds of guidance.

The second part of the power tools was the set of developer authoring tools that you used to design such guidance workflows.

Both part one and two were bundled together in the ‘Feature Builder Power Tool’ extension.

At the time, the Visual Studio Architecture team decided to base the ‘authoring’ tools of the FBPT on the new UML Activity Diagram that they were marketing heavily. As such they purposely decided to restrict the building of guidance workflows to Visual Studio Ultimate customers only. A huge oversight in my mind, as it put contextual guidance out of reach for many who could have benefited from utilizing guidance. This move also inadvertently stifled the uptake and adoption of guidance workflows across the marketplace for ordinary developers, since they were not privileged enough to create it. IMHO building guidance should have been a thing Microsoft should have encouraged to all and any Visual Studio user, building bigger momentum around this new technology and approach. But alas, the authoring experience with the UML Activity designer turned out to be super clunky, very tedious and ultra esoteric. And furthermore, the guidance that shipped with the authoring tools, that was supposed to help you build better guidance workflows!, was a very poor example of why there was any value in building guidance workflows in the first place! A lot of hard but important lessons were learned from that release, especially how not to treat and address your potential marketplace. However, the technology did speak for itself, and as such has seen some adoption and praise.

Unfortunately, soon after the public release of the FBPT tools, the team that built them was disbanded quickly, and the tools have had little support since. Its predecessor: the Guidance Automation Toolkit (GAT) was being made obsolete around the same time. And when VS2012 was being announced there was no plan from Microsoft to support the ‘Feature Builder Power Tool’. Unaware of this, FBPT customers who had taken a bet on the technology were left high and dry and without an alternative, or roadmap, as was the whole software factories community.

Until very recently, the ‘Feature Builder Power Tool’ project has been slowly languishing. With many bugs, installation issues, a poor authoring experience, bad ratings, and no encouragement and support from the Microsoft Visual Studio team. Sadly, the project has suffered a great deal of loss over the last few years, and has even angered a few.

However, there is now some great news about the FBPT project. If you remember, at the start of this post, I mentioned that the FBPT was a component of a larger strategy around delivering a full suite of software factory tooling. The other components of that strategy came together, with the guidance workflow piece, into the NuPattern project. There is a great story to tell here one day, but the short story is that NuPattern was designed to build upon the guidance component that was shipped in the FBPT, and extend it out much further to complete the overall tooling strategy, and it is still evolving. NuPattern was to be the set of domain specific development tools and integration platform that you built and ran your software factories upon. However, the NuPattern project called ‘PLATU’ at the time, was concealed from public view and so this remaining part of the strategy was invisible to people interested in how the FBPT technology was going to evolve, and what Microsoft was doing in that space.

The NuPattern project has always had a very large and deep binary dependency on the runtime component of the FBPT, right from the start. This is because it not only drove the requirement for building the FBPT technology in the first place, but it also needed to deliver the missing piece around domain specific development tooling that was needed to build a software factory or toolkit. About a year ago NuPattern (called ‘VSPAT’ at the time) was finally released.

As the FBPT wasn’t supported for VS2012 or later, the NuPattern project faced the reality of having a stagnant foundational dependency, that prevented shipping NuPattern for VS2012. After several months of negotiation and due process with Microsoft, they contributed the source code of the runtime components of FBPT to the NuPattern project. This single and celebrated collaborative act enabled the NuPattern project to finally ship a VS2012 version, and removed the crippling stagnant dependency. And with that one move, support for the core runtime components of the FBPT have moved to the NuPattern open source community. Great news for anyone who was either interested in, or still interested in the ‘Feature Builder Power Tool’.

NuPattern has always had guidance workflow support. And its has always had its own supported authoring experience for building guidance workflows, that is a great deal easier and far more intuitive than using UML Activity diagrams. Which makes creating guidance workflows available to all Pro/Prem and Ultimate customers in NuPattern!

If you are still using, or used the ‘Feature Builder Power Tool’ extension to build ‘Feature Extensions’, and you saw value in the concept of sharing guidance workflows. And you want to create more of them - look to building a NuPattern Toolkit instead. A NuPattern toolkit brings a far superior platform for your guidance and automation to be experienced by your Visual Studio users. (and just quietly, its a great deal easier to create and support than a feature extension).

That said, there is no direct and supported path to migrate a ‘Feature Extension’ built with FBPT to a NuPattern toolkit. You can however, keep the code and guidance you may have had in your feature extension, and with some rework, repurpose them in a NuPattern toolkit. The concepts are almost identical because NuPattern has always used the foundation of the FBPT runtime. Same concepts, same classes, but now a different namespace, and richer context for your guidance.

In a nutshell: for all those on the ‘Feature Builder Power Tool’ or those who lost faith in the FBPT project, and still have an interest in the technology - check out the NuPattern project and give us your suggestions and feedback on how to continue to evolve contextual and automated guidance for you.

Narrator Inquire Within

Jezz Santos — Fri, 03 May 2013 10:58:00 GMT

We have long needed a decent video screencast that helps explain what NuPattern is all about for first time visitors to the NuPattern project. Something that gives a first timer an inkling of an idea what NuPattern does. It does not have to make logical sense even, but to walk away with a clear idea of what you would use NuPattern for.

Well now we have such a candidate video on YouTube - but it is silent – no voiceover!

The director and producers have done the hard work in scripting the video and producing it, but we are missing the most vital element, someone to explain what’s going on in the video!

The producers of the video don’t feel that their voices are suitable for the narration, so just for fun we are going to try a new idea, and recruit a narrator from the community.

So, the project is looking for anyone who would like to step forward, who likes the sound of their own voice, to be our voice of NuPattern, and bask in the glory of influencing many people to step in the direction the project is tracking.

Please apply within, post your interest on this discussion thread.

Why is NuPattern relevant to you?

Jezz Santos — Wed, 01 May 2013 03:00:17 GMT

Perhaps you blog software technology solutions, or write technical articles or presentations for your organization that are intended to document for others what you have learned about implementing the solutions that you have built. Perhaps you hope that others will reproduce your proven results. Perhaps you have a role in ensuring those without your knowledge and mastery of software implementation follow your guidelines and wisdom. The success of any approach is limited to how much time you can invest in explaining the details of your solution to people who don’t have your level of expertise. Such as: explaining the context of how your solution is applied and when, how it may vary based upon other people's needs, the need to know details about the technologies and frameworks it applies to, and any choices about its implementation that could be made to tailor it to their needs. It is a ton of information to cram in any kind of document that just anyone can read and understand well enough to comprehend fully the way you do. Let alone, how someone else without perhaps your deep knowledge and experience should practically and reliably integrate your solutions into their existing solution, or how to adapt the solution for their own requirements or constraints, which will surely be different from yours.

When you master proven implementations that can be reused, you tend to derive generalized and extensible patterns in them that you may see value in re-applying to other projects or solutions. So, how do you teach someone else to repeat those solutions and patterns the way you understand them?

Well, instead of just documenting step-by-step instructions on how to implement these patterns, best practices or solutions, and then just hope someone understands it as well as you do to a degree they can repeat it reliably – you could instead build a Pattern Toolkit that applies and automates the implementation of your solution or pattern reliably, consistently and correctly for them.

A toolkit that not only includes all the assumptions, details and information about the solution to be built, but includes custom tools and guidance to build it, and integrate it into an existing solution. A toolkit that has a simplified user interface, with templates, wizards, custom automation, menus, drag & drop and integrated guidance etc. that can be configured to suit the specific needs of those using it.

Your Pattern Toolkit will allow others to make choices and selections about how the pattern can be configured to apply and accommodate their specific requirements and constraints. It can even allow other pattern toolkits to plug into it, extending it further.

It will integrate and apply your best practice or patterns automatically, correctly and rapidly, and still allow manual customization of the final solution if needed. And, if your Pattern Toolkit does not quite or exactly meet the needs of the next project/community, anyone can install NuPattern, take your Pattern Toolkit, and extend or customize it for their specific needs (requirements, technical constraints etc.) without having to start from scratch again – and without your source code!

Finally, it’s important to understand that the intricacies of building and deploying custom tooling in Visual Studio are conveniently taken care of for you. A Pattern Toolkit is generated for you and is packaged in a single deployable package that can be emailed, posted on a blog, or downloaded from the Visual Studio Gallery. You will never need to learn all about the complexities of Visual Studio commands, menus, tool windows. It is all generated for you.

If this sounds like something you should be doing, go and get NuPattern today!

NuPattern Released!

Jezz Santos — Tue, 30 Apr 2013 03:07:29 GMT

It is with great pride and some trepidation that I would like to announce the release of the first version of NuPattern (v.1.3.20.0). Go get it here

I say first version version, because prior to this moment in time the product was called VSPAT, for which we have 19 previous releases. But NuPattern isn’t just a new name for the thing, it is a new direction and alignment that marks the independence of this product from its prior benefactor Microsoft, and opens it to a new community direction in developer tooling. NuPattern is now free to evolve by the development community to address broader market concerns around domain specific development and custom tooling development in Visual Studio. It is a huge milestone in this space.

One of these days, the story of NuPattern will emerge for those interested in its roots of development. For now though, we are hoping to start to build a new community around the project and take it in a new direction that adds value to any and every software development or deployment project. Please get involved.

Microsoft contributes Feature Builder to NuPattern

Jezz Santos — Wed, 17 Apr 2013 03:02:24 GMT

Today, Microsoft contributed the ‘Feature Extension Runtime’ components (the engine) of the ‘Feature Builder Power Tool’ to the NuPattern project!

This is fantastic news, and the NuPattern community is very grateful to all those at Microsoft who have made this generous contribution.

For those that may not be familiar with the significance of this move, the ‘Feature Extension Runtime’ (FERT) engine is the foundation upon which the NuPattern project was build, a key strategic dependency, and FERT exposes not only the some critical runtime components for NuPattern, but also provides the ability to run contextual and stateful guidance in Visual Studio. The ‘Feature Builder Power Tool’ is no longer supported in Visual Studio 2012, and having this contribution allows NuPattern to move forward to support Visual Studio 2012.

The ‘Feature Builder Power Tool’ was created by the Visual Studio Architecture Team as a first step in the direction of a new generation of contextualized automation tooling, which NuPattern then extended to add an automation platform and model-driven development approach for creating a new wave of domain specific tooling in Visual Studio, now available to everyone.

Now that the FERT components are integrated into the NuPattern project, we shall be able to support and extend this technology moving forward in current and future Visual Studio versions, and provide the ability to all developers to benefit from in-solution contextual guidance.

It marks a great moment in the history of the NuPattern project, and brings to light the work that Microsoft had invested over the last 5 years in a new generation of automation technologies that continue the to deliver on the vision of ‘Software Factories’ and ‘Domain Specific Development’.

More than anything though, this contribution now makes it possible to complete a new version of NuPattern for Visual Studio 2012. Which has been long awaited, and is now imminent.

We would like to recognize the efforts of the following people who have been key in this contribution: Brooke Hamilton, who has done all the hard work in driving and shepherding this contribution from Microsoft to the NuPattern project. This task which has taken months to complete, has been monumental in both effort, patience and tenacity to bring this valuable asset to us. To Gareth Jones from the Visual Studio Ultimate team who has worked closely with the project to make this key contribution. The team that originally created this contribution: David Trowbridge, Jack Greenfield, Michael Lehman, Christof Sprenger, Daniel Cazzulino and Mariano Rodriguez. And finally to the efforts and care of the Microsoft legal team, and the Outercurve Foundation team for getting us to this point.

Roll on the VS2012 version of NuPattern!

Need a New Challenge

Jezz Santos — Mon, 11 Mar 2013 20:57:00 GMT

Bit of a shameful plug for myself, but finding work seems to be a little difficult right now.

I’ve been consulting globally for Microsoft for the last 11 years and been helping software development organizations across many industries and geographies, assuring delivery of their solutions and products. Now that I have left Microsoft as a Principal there, I am now looking for new opportunities in the local or global marketplace where I can contribute my experience. Ideally, I would wish to have a significant impact in generating new value for a progressive software organization or community, who perhaps need help in moving to more efficient and sustainable product development practices and processes. Keen to pursue new opportunities or existing ones.

Ideally, the organization or community will recognize that they have significant customer value and revenue to grow, and that their IT capability may not be realizing its full potential in delivering business value efficiently, or at a level of quality and integrity that delights their customers, and grows their social capital in the marketplace. They probably recognize that their current IT capability may be wasteful and slow to apply itself to new market opportunities, or unable to change to serve changing business needs cost effectively. They recognize that fostering self-empowered teams, continuous improvement and the requirement to drive delivery excellence and higher quality is critical in moving forward in today’s business environment. They are looking for strong and experienced leaders to help develop and mature their IT capability.

Please let me know if you may know of any opportunities you think I should pursue.

Desperately Seeking Contributions

Jezz Santos — Sun, 17 Feb 2013 03:23:16 GMT

As we reach the next milestone of the NuPattern project, the 1.3.20.0 release, I need to be looking to grow a new group of contributors to the project.

The acceptance and adoption of the technology has evidently been very slow to date, and this is understandable given that most people who encounter the technology are given little draw to it from any real visual example or illustration of what it can do for them. Its a great platform, so we say, but who has used it?

If there was only one thing I would wish for right now, its that someone could create a screencast of a toolkit built with NuPattern.

We Need Help!

We don’t even need someone to build a new toolkit to do this. We have such a toolkit over at the MVCPAT project, and I have even documented each step of a walkthrough showing off all the cool features of it. It is just that we need a video of that walkthrough to excite people and given them a quick look at what NuPattern can do for them or their communities. This is such a critical asset for generating interest in the project, that without this first step it it is extremely hard to sell the value of the NuPattern platform.

After the screencast we will need more examples of toolkits other have built in the public domain. Its not that no one has built any toolkits with this technology, there are many 10’s of them out there within enterprises, its just that none of them can be shared with the public. Which again does not help demonstrate the effectiveness of the NuPattern technology. We need more publically available toolkits to show off the benefits of building and using toolkits.

If we had the above two things, I believe that is all it would take to get the project moving in the right direction, and have the community involvement to keep it moving. I never in a million years imagined that NuPattern would be pleading for new contributors moving forward given the history and success of the project, but the reality of the situation is that here we are.

So humbly, I am requesting your help.

NuPattern.org

Jezz Santos — Tue, 05 Feb 2013 22:03:16 GMT

The NuPattern project has finally claimed our own domain http://nupattern.org and secured the new project name!

For now the site redirects to our project site http://nupattern.codeplex.com. But we hope in the future we can use this site host our documentation, and perhaps even a toolkit gallery at some point.

(http://nupattern.com also redirects for us)

Thanks to Clare Madden, Paula Hunter and Eric Shultz at The Outercurve Foundation for the hard work in setting this all up.

Season’s Greetings

Jezz Santos — Thu, 27 Dec 2012 10:19:42 GMT

In the build up to Christmas we have been busily preparing for our next release of ~~VSPAT~~ NuPattern. This release will not only support VS2012, (as well as VS2010 of course), but we are rebranding the name and targeting a new audience in the hope of encouraging more supporters and contributors to find value in, and follow the project. We need more contributors!!!

Compatibility Issues

The big part of this upcoming release has been creating a version that works in VS2012. As well as dealing with the gray scale look and feel, new themed styles, and binary incompatibilities between VS2010 and VS2012, it has been a huge technical challenge figuring out how to maintain a single code base that can be targeted for building our VSIX toolset for both VS2010 and VS2012. You may be surprised to know that it is almost impossible (unless you have a very simple VSIX extension) to create one that works in both VS2010 and VS2012. At the time of writing, there is not a whole lot of practical help nor guidance out there for VSIX builders to help them deal to these compatibility issues. And the only viable and workable solution is to create two versions of your extension, each targeted to a specific version of VS. That usually means splitting the codebase (proliferating the problem), multiple solutions, awkward and tough workarounds in the code, multiple VSIX deliverables and lots of complexity! Not good news for an open source project wishing to attract new contributors! The root cause of all this drama? the VS teams decided a while back on a very poor (and what seems to be a partial) versioning strategy that includes naming some assemblies with the version number in their name (e.g. Microsoft.VisualStudio.Shell.10.0.dll) which has now led to having a deep impact on VSIX extension builders. The issue may not be apparent at first look. But for example, if your wizzy extension is built against a VS assembly like the one mentioned, which is a core extensibility assembly for VSIXes, your extension simply won’t run against the newer version of the assembly in the next of VS, because that assembly will be named Microsoft.VisualStudio.Shell.11.0.dll. Different name, different assembly, binary incompatibility issues. Even redirecting the assembly bindings won’t work.

Naturally, no software project every desires to maintain separate source code branches/forks/whatever for the same product just because you have to deal with different versions of your platform (in our case VS). We chose not to accept this disappointing outcome, so I have been putting in the hard cycles figuring out all the workable strategies and mechanics of dealing with both versions of VS (and potentially others down the track) so that we can maintain a single codebase with one set of unified shared features (at least at this stage). Of course, its pretty disappointing that Microsoft has not made this easier for VSIX builders like ourselves with the new release of VS2012. Not only have we had to deal with the assembly naming conflicts, but we also have to deal with breaking changes in API’s, and changes (bug fixes) in static artifacts (i.e. *.targets files, text templates, and changes in project types) shipped in the VSSDK, DSLTools and testing frameworks. Which has made life even harder for our project. You see our particular project specializes in creating VSIX toolkits, which themselves will face these compat issues a well. But enough of that, if you are interested in how we resolved these compat issues and kept a single codebase on the project, take a look around the 1.3.20.0 branch (and pending pull requests) of the source code on the project. I am happy to provide more in depth info about this later if asked. See the developer notes for more details if you want to take those steps.

So at this stage, the current development iteration for the VS2012 edition is just about at a close. We are still waiting to resolve the long outstanding dependency we have on Feature Builder Power Tool, and hoping that sorts itself out early in the new year. Once we have a resolution to that issue, we will have a new release shortly after, and we can start to focus on building a larger community around the project and pattern toolkits.

A New Name

As part of this upcoming release, the big news is that we have a new name for the project. We are now called ‘NuPattern’. Which replaces the name ‘~~VSPAT’~~ from here on out. You can check out the discussion thread on how we converged on that particular name, it has been something we have been deliberating on for some time, and now with the new major release, and change in project ownership, it seems like the right time to make the change. We never really liked the VS association in the VSPAT acronym, and based on feedback, it was too much of a mouthful. Besides, no one ever remembered the acronym correctly anyways! We needed a proper and cool project name that people will remember, and vaguely associate with the delivered technology.

We are hoping that the new name appeals to (at least attracts) many of the same engineering audiences that may use NuGet today, and for the same kinds of reasons that those folks use and build NuGet packages (automation, consistency, reliability, relevancy, trust, etc.) , we hope they see the value in using and building Pattern Toolkits too. NuGet –> NuPattern. maybe?

Of course, NuGet consumers are not he only kinds of software professionals NuPattern should appeal to. See below. But, we are proud to show solidarity for the ‘Nu’ prefix in our name, as we are incidentally very closely related projects (e.g. in origin, platform, audience, etc.), and perhaps that may even encourage a new wave of other OSS projects to using this prefix to grow a family of new and exciting technologies around automated software development and deployment. Besides, I am not embarrassed to say that if the NuPattern project attracted even a small fraction of the audience that NuGet has over the years, the investment that has been made in the NuPattern project will have been finally realized.

A Question

As part of the name change, we have of course had to change a bunch of project collateral, including the codebase, all the documentation, and our project sites. So, the good folks over at The Outercurve Foundation recently asked me to identify exactly the target audiences we are going after with the new brand, and how they can help target that audience better. A question I have been answering for several years, and I think I have had a crack at it about a thousand different times for just about every kind of audience. But for this particular request, I think I captured a pretty decent summary that I felt was worth sharing, and in doing so, I though it might be a good way to get some feedback on whether you think we have targeted the right audiences or not.

Thanks goes to Don Smith, who helped me frame this question and answer better than I have done in the past.

Question:

So the broader question really is, “What is NuPattern” and who does it apply to”?

Answer:

The short answer: VSPAT is a set of Visual Studio extensions that help you build Visual Studio extensions, called ‘Pattern Toolkits'. The people that build the ‘Pattern Toolkits’ are called toolkit authors. The people who use the ‘Pattern Toolkits’ to develop/deploy software are called toolkit users.

The longer answer:

Users: these are ordinary (software/infrastructure engineers) developers/deployers from any organization/community/project, who are chartered to design and develop a solution.
- They are entrusted to comply with any practices/standards/principles for the project, and generate and apply elegant and efficient solutions to problems they face on the project. They take accountability for their personal input into the project.
- They architect, design, craft code/scripts, and deploy software, they experiment, they seek knowledge and mastery of their technologies as they encounter them on their project.
- They define themselves by their mastery of their technologies, tools, architectures, solutions etc.
- They are looking for great flexible tooling that helps them complete their work, the way they work to an acceptable standard, and rapidly. They seek guidance and best practices, and tooling which understands their specific technical needs on the project, using agreed-to technologies and architectures defined for the project.
- They expect to be provided tooling that does the heavy lifting and tedious tasks for them, but at the same time, allows them the freedom to create and manipulate the outcome.
These folks are the ultimate end users of the custom toolkits that the Authors (below) will build for them, using NuPattern.

Authors: these are the seasoned and skilled (software/infrastructure engineers) developers/deployers from any organization/community/project, who are entrusted by organizations/communities/projects to ensure high-quality, correctness and completeness of solutions the organization/community/project embraces.
- They are entrusted to define and enforce that best practices are followed on their development/deployment projects, so that maintainability and supportability of the project long term is assured. They take personal accountability for the success and the future of the projects they work on.
- They architect, design, craft code/script, and deploy software, they experiment, they seek new knowledge and maintain mastery of patterns, proven technologies and tools, as they evolve.
- They define themselves by their ability to identify, reason about, select and adapt patterns of implementation across similar solutions.
- They architect new processes, practices and solutions to make other developers more efficient, and to maintain high levels of quality, reliability, maintainability and supportability of the software.
- They organize, guide and refine processes to help other developers/deployers in complying with those architectures and processes.
- They are looking for great flexible tooling that they can manipulate, to adapt and apply automation to solve general problems across their projects. They will have already developed their own tooling/scripts/automation etc. to help apply best practices they have proven to be successful across multiple projects.
- They expect to have to harvest commonality and define variability in patterns across multiple solutions, and generalize the requirements of the project for reuse in another.
These folks are the authors of the custom toolkits, that are used by the Users (above) to bring higher productivity and consistency to their projects.

Let me know what you think?

Happy New Year!