Table of Contents

Executive Summary 3

Mission Statement 3

Problem Definition 4

Solution Statement 4

Scope 6

Environment 6

Source Control 8

User Stories 9

Functional & Technical Requirements 9

Data Mapping 11

Sequence Diagram 15

Implementation 16

Bootstrap 16

Angular 17

jQuery, AJAX, JSON 17

RESTful Web Service Interface 18

RESTful Web Service Implementation 18

Unit Test 36

Wireframes 43

 

Open Source Code available on

Manage Extensibility Framework is a C#.Net Framework used for design Testable code via Interfaces and Dependency Injection. 

 

From May 26th, 2016 to August 18th, 2016, I interned at EVO Merchant Services and was under the direct mentorship of Phillip W. Bossardet. That summer, Phil walked me through the step by step processes and responsibilities of DevOps, Test-Driven Development and the value and significance of writing test friendly code.

 

Windows Presentation Foundation (WPF)

The core of WPF is a resolution-independent and vector-based rendering engine that is built to take advantage of modern graphics hardware.

 

WPF extends the core with a comprehensive set of application-development features that include Extensible Application Markup Language (XAML), controls, data binding, layout, 2-D and 3-D graphics, animation, styles, templates, documents, media, text, and typography.

 

WPF is included in the .NET Framework, so you can build applications that incorporate other elements of the .NET Framework class library.

Managed Extensibility Framework (MEF)

MEF is a Dependency Injection Framework that enables developers to create modular, plug-in based applications that allow for designing extensible code by a third party.

 

Developers can discover and use extensions with no configuration as well as enabling the developer to encapsulate code and avoid fragile hard dependencies. Dependencies can be loaded from anywhere and run anytime. The MEF library allows developers to write business logic separate from constructors, thereby isolating functionality and substantially reducing obstacles for unit testing.

 

MEF allows clean, modular code to be written in a way that dependencies are injected by implemented interfaces into the invoking classes.

 



Microsoft Prism 4.5

Prism is a library that provides guidance designed to help you more easily design and build rich, flexible, and easy-to-maintain Windows Presentation Foundation (WPF) desktop applications.

 

Using design patterns such as Model-View-ViewModel (MVVM), Composite View, and Event Aggregator that embody important architectural design principles helps you create a modular application—using loosely coupled components that can evolve independently.

Test Driven Development Life Cycle

Each developer involved in DevOps was responsible for either writing, rewriting code, manually testing, writing automated unit test, deploying, quality assurance,and/or reporting feedback . In the short life cycle the spans from writing to testing, if the code is tested fails the test, before it could .

 

Responsibilities

In my duration at EVO, I was responsible for designing and implementing a User Interface Host Framework. This User Interface was to consist of a Title bar, Menu Bar, and two main regions that implemented the core requirements of the application :
      1. Modules Sidebar

2. Module Execution Frame

Modules Sidebar

This region is responsible for loading available modules in the form of .dll files. If a .dll module is available, the module will be loaded and will appear on  the side bar. For example, if there is a Calculator Module available, when loaded, the sidebar will indicate the module is available and ready to use

Module Execution Frame

 

So when the user hits open ( in the menu bar ) user may be able to find the .dll for calculator module in the designated directory, load it on the sidebar and, when clicked, it will load in the Module Execution Frame to be used for calculating values.

 

OO Design for Testability

The common misconception about testing is that it should be left to QA or Test Engineers. However, that kind of mindset – if it is not already – should be frowned upon in industry and best practices. Good and effective testing starts at the developer stage. It will always be up to us, Programmers, Developers and Software Engineers, to pave the way for a smooth development life cycle from start to finish. As software developers, it’s our job to decide what are the best tools to use in order to write clean and efficient code that is also friendly to everyone else in DevOps.

 

Here are some things to consider to avoid writing untestable code:

 

1. Location of new operator
2. Work in Constructor
3. Global State
4. Law of Demeter Violation

 

MEF Replaces excessive dependencies with test friendly classes that control instantiation of objects. In all this, MEF is considering the Law of Demeter which minimizes coupling between classes by implementing interfaces that inject the dependencies in them. By using interface to get in between excessive dependencies, MEF is isolating each class so that, not only the structure of the code is cleaner and runs more efficiently, but also becomes very easy to test.

With MEF, we are able to write classes separately. In doing this, we are sorting the classes in a way that are test friendly. You can write a unit test to test classes that are specifically designated to object instantiation and passing objects ,and test a separate class that are specifically designated to business logic or functions that invoke the objects or dependencies. MEF provides a design that easily lets the developer know what code is exactly doing – where and why it’s doing it – so that when something goes wrong, it’s obvious what and where the bug is to be fixed. Therefore, it’s obvious what tests need to be written

Unit Testing

In this Simple Plugin Project the test I wrote had to test where it can find an available .dll module like Calculator. I needed a unit test would test if the function in the Modules Sidebar Regions were being created. So I made sure to write a separate class, using prism, to write the region constructors.

 

I needed Classes invokes the dependency the implements the interface for calculator.

 

So in hindsight, the unit tests in this solution are written to test the isolated dependency classes.

 

The unit tests in this solution are written to test the isolated dependency classes’ separate respective invoking classes.

 

The unit tests in this solution are written to test the isolated dependency classes’ separate respective implemented interfaces.

 

This way we can verify the specific function of each isolated class and interface, thereby, reducing defect rates and improving accuracy of pinpointing errors.

EXAMPLE
======================================================C# Code=================

//Uses imported testing framework provided by microsoft and makes a reference to the namespace carrying the class for which method I’m testing ( in this case its the method that runs invokes the web service Read (CRUD) function to get all classes 

using lpconcept;
using Microsoft.VisualStudio.TestTools.UnitTesting;

//Testing Namespace

namespace LetsTest
{
[TestClass]
public class GetCourse
{
private CourseDataService _service;

[TestMethod]
public void Get_Course_Test()
{

//AAA – Common Testing Structure used to , first, instantiate the target object from the READ method of the web service, second, loads object to the function that gets all courses, and lastly, vverify if the function was executed properly. 
//Arrange 
_service = new CourseDataService();

//Act
_service.GetCourses();

//Assert

Equals(_service.GetCourses());

}
}
}

 

=================================================/end C# code====================

 

Separate unit test can be written for separate methods in any/every class in any solution, thereby, accurately assuring quality of application/solution on a class level.

Windows Server Update Services (WSUS)

 

https://msdn.microsoft.com/en-us/library/ff647981.aspx

As an engineering student first year, me and a classmate were having a physics cram sesh and , there was is a lot of material to cover. On top of that, our other two buddies forgot and didn’t show up. So we figured that there had to this solution to alleviate this common engineering student struggle.

The whole physics lecture was about  100 students. What if they all came to our cram sesh and offered some of their inputs and notes they took and combined, we’d have a super note that would comb over any detail the average student may miss.

 

 

So we built notebook using MEAN Stack.

Its designed as an AI word processing app like, integrated with Wolfram alpha and Google freebase API. Users are able to write notes on a doc, then suggestions would be generated from the written text and cross reference related links, articles and notes written by other students, ultimately modifying and supplementing notes of an individual student.

 

 

 

 

 

I entered​ , with my team, Difference Maker Pitch Contest and was awarded 2nd place $1500 seed funding and most innovative tech solution award.

 

 

 

Then, I realized how powerful IT can be especially when applied to harnessing small details and organizing into solutions for real world issues, enterprise and business needs.

So I decided to further my pursuit of passion and swtched my major.

I entered the IST program in Summer 2014. I classes all year long – spring summer and fall, – until I graduated with a Bachelors of Science in Information Science & Technology: Integration Application in Fall 2016.

In those 2 years, I’ve gained a wide variety of skills and best practices –  both technically and managerially – through my work and coursework and project experiences.