Learn how to get small teams to embrace both using and contributing to open source in a healthy way. See case studies of open source projects and how they have contributed to the growth of a small team.

1. Going Open Source
with Small Teams
Jamie Thomas
Director of Software Development – VC3
Co-Founder - Cognito Forms

2. Agenda
Using Open Source
 When and why
 Licensing considerations
Creating Open Source
 When and why
 Contribution, not disruption
 Evangelism and community
building
Case Study 1
 Afterthought – a post
compilation code
weaver
Case Study 2
 Exo – a comprehensive
platform for model-
centric rules-based web
development
Deep Dive Demo

3. Using Open Source
Use it intentionally, not on accident

4. When
Always an option
Always consider open source solutions
when tackling both new and existing
technology problems.
Remember that open source ?= good
source, and in many cases commercial
closed source or custom development is
still the better option.

5. Why
Time is money
Open source software that sufficiently
addresses a core need can save
significant time both during initial
development and ongoing maintenance.
Good open source technologies are written
by subject matter experts.

6. Licensing
One important detail
Make sure the open source software is
licensed in a way that makes sense for
your business.
GPL = Open with Strings
LGPL, MIT, etc. = Open without Strings
Maintain copyright and license notices and
keep a list of what you use.

7. Stuff We Use
Just a taste of the dozens of open source projects and code snippets we leverage daily.
Electronic Signature
TinyMCE HTML Editor
DOM Manipulator
Spectrum Color Picker
Web
Framework

8. Why We Don’t Use More
We have travelled a long way through uncharted seas.
For those that come behind us the way will always be easier.

9. Creating Open Source
Create what does not exist, and dare to share

10. When
Rarely an option
Unlike the use of open source software,
there is rarely a compelling reason for a
small team with deadlines to create open
source software.
However, when your team has something
special to share, seize the moment!

11. Why
Something unique and
yet not central to the
core business
Creating open source software changes
mindsets, because you are sharing with the
world, not just your cubemates.
Every team occasionally solves a new
problem or an old problem in a unique way—
give this as a gift back to the open source
community.

12. Why Not
Some things must be
protected at all cost
Do not accidentally give away key
business secrets.
Do not share junk. It should be your best
work, not the stuff that did not make the
cut.

13. Contribute, not Disrupt
Figure out how to share your work without disrupting the team and core objectives.

14. How we
prevented
distruption
When we decided to start contributing our
work as open source, we selected GitHub as
the public repository.
However, our entire team heavily uses
Microsoft TFS, so we developed a tool that
automatically promotes check-ins to TFS up
to GitHub, including all details.
Automation is key

15. Building a Community is Hard Work!
Failure is hard, but success is harder!

16. Case Study 1
Afterthought

17. Afterthought
An open source .NET compile-time code amender

18. What is it?
A big time-saver
Afterthought allows .NET developers to
declaratively describe how to mutate
compiled code to add additional behavior
through IL injection and weaving.

19. How does it work?
Fluent API for describing how to amend compiled .NET assemblies

20. Who uses it
and why?
Afterthought leverages Microsoft’s open source
CCI libraries (now part of the Roslyn compiler)
to perform similar tasks as PostSharp.
VC3 uses Afterthought for almost all projects to
support code-first pattern-based development.
Thousands of community users use
Afterthought as a free alternative to PostSharp,
which costs $500 per developer.

21. Evangelism
Almost none
We decided to create Afterthought as an
open source alternative to PostSharp to
avoid recurring upgrade expenses for
essential technology.
We announced Afterthought and posted
it to GitHub and Nuget and had almost
an immediate following.

22. Community Engagement
After months of actively supporting our community, we finally decided that we had to focus on
our core products over developing features we did not actually need to support the open
source community.

23. Future
Plans
We know Afterthought meets a need.
We plan to release support for Visual
Studio 2015 soon, including an updated
Nuget package.
Long term, we plan to convert
Afterthought into a Roslyn extension.

24. Case Study 2
Exo

25. What is it?
Exo is a server-side model-abstraction layer, a server-side rules engine,
and a client-side model-centric rules-based web framework.

26. How does it
work?
Simply too much to
describe in a single
slide.
ExoModel provides an abstract, meta-
data aware, wrapper of a concrete
instance model. It could wrap EF
objects, POCO’s or even dynamic types.
ExoRule is an powerful event-driven
model-based rules engine.
ExoWeb brings all of this awesomeness
to the browser.

27. Who uses it
and why?
We use Exo extensively in all of our
products and many of our consulting
engagements.
Outside of VC3, no other organization
currently uses Exo (that we know of).

28. Evangelism
Significant effort, but to
no avail…
Unlike Afterthought, which solves a small
problem and took off like wildfire, Exo is a
sophisticated framework.
We created a dedicated website for Exo,
and even created a demonstration app with
step-by-step instructions.
Our conclusion is that successful open
source projects solve small defined
problems and are easy to search for.

29. Future
Plans
One day…
The technologies in Exo are downright
amazing, both for .NET and JavaScript
developers (but especially for both
together).
We want to eventually break our
dependency on ASP.NET AJAX and
move to something like Angular for
templating, thus providing a clearer path
for user adoption.

30. Deep Dive Demo
Cognito Forms Calculations

31. Christmas Tree Order Form
Model-based calculations and rules highlight the power of our Exo framework.

32. Under the
Hood
Sometimes it is hard to
believe it is even
possible that it works!
Calculations entered in Cognito Forms are sent to
the server.
The server builds the dynamic model (ExoModel)
from the form definition.
The expression parser builds an expression tree
while supporting both intellisense and expression
validation.
The expressions dynamically compile and execute
natively on the server as rules (ExoRule) and
ExoWeb translates them to JavaScript to run on the
client.

33. JSON
Meta Data
"BulkDiscount": {
"type": "Number",
"isPersisted": false,
"isCalculated": true,
"index": 11,
"format": "C",
"label": "Bulk Discount",
"rules": {
"calculated": {
"onChangeOf": ["ChristmasTrees{Height_Amount,Lights_Amount}"],
"calculate": "function(){var result = (((this ? this.get('ChristmasTrees') : null).map(function(p0) {return
(((p0 ? p0.get('Height_Amount') : null) || 0) + ((p0 ? p0.get('Lights_Amount') : null) || 0)); }, this).reduce(function
(p,c) { return p + c; }, 0) > 200) ? ((this ? this.get('ChristmasTrees') : null).map(function(p1) {return (((p1 ?
p1.get('Height_Amount') : null) || 0) + ((p1 ? p1.get('Lights_Amount') : null) || 0)); }, this).reduce(function (p,c) {
return p + c; }, 0) * -0.2) : 0);return isFinite(result) ? result : null; }.call(this)"
}
}
}
A simple property
definition for ExoModel

34. Calculation Conversion
This
=ChristmasTrees.Sum(Height_Amount + Lights_Amount) > 200 ?
ChristmasTrees.Sum(Height_Amount + Lights_Amount) * -0.2 : 0
Becomes
(((this ? this.get('ChristmasTrees') : null).map(function(p0) {return (((p0 ?
p0.get('Height_Amount') : null) || 0) + ((p0 ? p0.get('Lights_Amount') : null) || 0)); },
this).reduce(function (p,c) { return p + c; }, 0) > 200) ? ((this ?
this.get('ChristmasTrees') : null).map(function(p1) {return (((p1 ?
p1.get('Height_Amount') : null) || 0) + ((p1 ? p1.get('Lights_Amount') : null) || 0)); },
this).reduce(function (p,c) { return p + c; }, 0) * -0.2) : 0)

35. Millions use
Exo
We just had to be
sneaky about it!
Earlier I stated that only VC3 used Exo—that was a
half truth.
As you can see, millions use Cognito Forms either to
build or fill out custom online forms that leverage
almost every feature of Exo, including dynamic
modelling, advanced rules, expression processing,
client templating, and rich validation.
Even if you efforts to share your projects go
unnoticed, do not loose faith in the benefits of
trying—it is definitely worth the investment!

36. Conclusion
Any questions?
As in the case of Cognito Forms, enabling
technologies can be open sourced without
jeopardizing the success of an
organization’s core business.
Find champions within your team with a
passion to contribute and empower them to
evangelize within your team and engage
with the world.