5. Douglas C. Schmidt Says.. Frameworks define “semi-complete” application that embody domain-specific object structures and functionality.
6. Libraries is.. Application Block DATABASE ADTs MATH NETWORKING App Specific Logic OO Design Invocations GRAPHICS GUI Event Loop Singleton Strategy Selections Reactor Adapter State Active Object Design Pattern Class Library Component Architecture
7. But Framework is .. Active Object State NETWORKING GUI Control – Flow (IoC) MATH Reactor Event Loop App Specific Logic Invocations Callbacks ADTs Singleton Adapter DATABASE GRAPHICS Application Framework Component Architecture
8. Why Do You Need Framework? Productivity Avoid Duplication
11. Seed References “Framework Engineering”, TechED 2007 Europe “Framework Design Guidelines” , Addison Wesley Krzysztof Cwalina Program Manager on .NET Framework Team
32. Skyscrapers Peanut Butter Focus: features Results: stability, incremental improvements, not great end-to-end scenarios Focus: scenarios Results: Excitement, breakthroughs, but beware of leaving existing customers behind P
37. Primitives Very little policy (behavior design decisions) Stable design Commonly appear in publicly accessible APIs Almost impossible to evolve/change design; any design changes have huge breaking change impact on other APIs Example: Int32, String A
38. Libraries Definition: Libraries are types that are not passed between components Examples EventLog, Debug. Easy to Evolve Leave old in, add new one Beware of duplication! A
39. Abstractions Definition: Abstractions are interfaces or classes with unsealed members that are passed between components. Examples Stream, IComponent Hard to Evolve Unfortunately, pressure to evolve A
40. Primitive Oriented Design A.K.A. “Handle based design” (functional) Great evolvability, poor usability (sometimes) Low level stable primitives + high level reusable components with limited dependencies other than to the primitives E.g. Type.GetType(object) – works, but not as convenient as Object.GetType A
41. Extension Method for primitive.. C# 3.0 New Feature namespace MyCompany.StringManipulation { public static class StringExtensions{ public static bool IsNullOrEmpty(this string s){ return String.IsNullOrEmpty(s); } } } … using MyCompany.StringManipulation; string message= “hello world”; if(message.IsNullOrEmpty()){ Console.WriteLine(“EMPTY”); }
42. Component Oriented Design Rich APIs with lots of features, thus with lots of dependencies Great usability, poor evolvability Good for higher level components, not for the core of a platform A
47. API Dependency Component A has an API dependency on component B, if a type in B shows in the publicly accessible API surface of a type in A. This includes: Base types and implemented interfaces Generic parameter constraints Return types and parameters of members Applied attributes Nested types A
48. Implemenatin Dependency If a type in A uses a type in B in its implementation. Hard Dependencies (required to run) Soft Dependencies (optional) A
66. Heavy Dependency. // your API public class Tracer { MessageQueue mq = new MessageQueue(…); public void Trace(string message){ mq.Send(message); } } // your customer’s program that is hard to test Tracer tracer = new Tracer(); public void ProcessOrder(Order order){ tracer.Trace(order.Id); … } A
67. Inversion of Control // your better API public abstract class TraceListener { public abstract void Trace(string message); } public class Tracer { TraceListener listener; public Tracer(TraceListener listener){ this.listener = listener; } public void Trace(string message){ listener.Trace(message); } } A
68. Dependency Injection // your customer’s program that is easier to test Tracer tracer = new Tracer(new FileListener()); public void ProcessOrder(Order order){ tracer.Trace(order.Id); … } A
69. Dependency Injection Containers // customer’s program that is even easier to test Tracer tracer = container.Resolve<Tracer>(); public void ProcessOrder(Order order){ tracer.Trace(order.Id); … } Check outDI Containers (a.k.a. IoC Containers):autofac, Castle Windsor, PicoContainer.NET, Spring.NET, StructureMap, Unity, nInject and others. http://www.nInject.org A
70. Packaging Principle Package Cohesion Principle REP (Release Reuse Equivalency) CCP (Common Closure Principle) CRP (Common Reuse Principle) Package Coupling Principle ADP (Acyclic Dependencies Principle) SDP (Stable Dependencies Principle) SAP (Stable Abstraction Principle) A Robert C. Martin, Principle of Package Architecture http://www.objectmentor.com/resources/articles/Principles_and_Patterns.pdf
75. Establishing Compatibility Bar Define what’s a “breaking change” This definition depends on the objective E.g. Enable portable code between Silverlight and .NET Framework E.g. Enable cross-version portability? A
77. Team Space Show and Tell Problem Space PLoP – Capable, Productive and Satisfied Patterns for Productivity http://hillside.net/plop/plop98/final_submissions/P54.pdf A
78. When to Replace Existing APIs When the new technology is “10x better” Make sure you understand the impact on the ecosystem What would happen if the BCL team added a new String? What’s the migration path for code using the old API? Support Automatic Migration Tool. (VB -> VB.NET, .NET 1.0 -> .NET 2.0) Provide Code Based Migration Manual. COM+ -> WCF , ASP.NET Web Service -> WCF A
93. KISS (Keep It Simple! Stupid!) Remove Requirements (ATAM). Reuse Existing Concepts or APIs Adjust Abstraction Level Consider framework users(experience, knowledge) Three Example D
95. Specification Document: Qualities Performance Goals (XML Parser..) Baseline: What do is the best my API could do? Measure delta from the baseline Threat Models (Security ..) Threat: What is the worst that my component could do? Mitigate the threats Keep a balance between many other qualities you want your framework to have (ATAM) D
102. Why you don’t read manuals ??? You know how to drive your car All cars work basically the same way Your rental car is a car Therefore, you can drive your rental car That is… The power of sameness D
103. Static Analysis Tool http://en.wikipedia.org/wiki/List_of_tools_for_static_code_analysis D
105. Branches and Integrations- Feature Crew http://www.codeplex.com/BranchingGuidance/Wiki/View.aspx?title=Feature%20Crews%3a%20How%20Microsoft%20Does%20It V
110. Milestone Quality (MQ) Initiatives that are hard to do in regular milestones Large productivity and efficiency improvements Infrastructure changes For example, a new source control system Refactoring of fragile subsystems Internal implementation documentation Bugs backlog V
111. Summary Dounderstand how organizational structure, culture, and decision making processes impact your product. Avoidpeanut-butter in Scenario Based Application. Domanage your dependencies. Dobalance advances with compatibility. Avoidduplication and overlap. Do design APIs by first writing code samples for the main scenarios and then defining the object model to support the code samples. Do treat simplicity as a feature. Domeasure, measure, and measure! Avoidintegrating unfinished features. Do pay your debt.
112. Resources Krzysztof Cwalina, Brad Abrams Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries http://channel9.msdn.com/pdc2008/PC58/ http://www.gotdotnet.com/team/fxcop
113. Resources Douglas C. Schmidt (PLoP Editor, POSA 2, 4 Writter) JAWS: An Application Framework for High Performance Web System http://citeseer.ist.psu.edu/81775.html (En) http://www.devpia.com/net2/EvaCast/Lecture/?cu=view&r=11 (Kr) Ralph Johnson (GoF , Design Patterns) Evolving Frameworks http://st-www.cs.uiuc.edu/users/droberts/evolve.html (En) http://arload.wordpress.com/2008/09/15/evolvingframeworks/ (Kr)
114. Resources Robert C. Martin Principles of Package Architecture (Design Principles and Design Patterns) http://www.objectmentor.com/resources/articles/Principles_and_Patterns.pdf (En) http://www.devpia.com/net2/EvaCast/Lecture/?cu=view&r=108 (Kr) For Korean People.. Load to Architect http://www.arload.net EvaCast (Online Free Lecture) http://www.evacast.net
117. Question? 이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다. This work is licensed under Creative Commons Korea Attribution 2.0 License.