How can I leverage my knowledge and skills to have the biggest impact on advancing the treatment and cure for the millions suffering with cancer.

Create an artificial intelligence that uses machine learning to teach itself the signs, statistics, fundamentals and genomics of cancer.

This was a personal project for me. In my initial concepts, I recognized the physical limitations of human perception and understanding of large amounts of unstructured data. I also recognized the technical limitations of singular computations in today's CPUs. After some discovery, I also recognized I couldn't leverage any third-party technology. I would have to build my own, specific to health-care. I would also need to provide undisputable results to acquire buy-in from my colleagues and the leadership team. I created Malaya to address all these obstacles and deliver market leading results. I consider it my greatest achievement in Computer Science thus far. At the core, it is two parts. One consisting of Artificial Intelligence and the other of Machine Learning. Many people misunderstand and think these two fields are the same but they're not. You can think of A.I. as an agent that communicates and appears to think like a human. M.L. on the other hand, is the ability to “learn” without having to be explicitly programed. Malaya uses a “Supervised Learning” technique. Since I have access to the data of patients that have been diagnosed with cancer, I use that data to “Train” Malaya. I created a Super Vector algorithm that builds the model it uses as a classification system. Malaya uses this model to predict “unknown or undiagnosed” medical data with a 97% accuracy and it can do it in milliseconds. The training sessions can be quite lengthy though. The model must consist of “all” cancer diagnosed data. This is where the singular computation problem I spoke of earlier comes in. To accommodate this, I created a Neural Network that consist of web API nodes that use an F7 to distribute the workload over many machines. All my layers scale well and I made sure the structure and technology I created was ambiguous.

The ability to utilize my talents to help people and potentially save lives is always rewarding... but doing that while learning new tech and sharing that knowledge with my team too? Priceless.

The business needs to be able to validate medical records. If the record is invalid for a specific type of cancer, the end user needs to be able to identify the problem, correct the issue and document. If the record is valid the data needs to be moved into another system, application and database.

Create an MVC / Web API application with Entity Framework and use our existing core architecture for auditing, email notifications and work-flow. Recording every step of the process to meet the business requirements.

I got a lot of input from the end users and the business which drove what data I needed to retain and the UI work-flow. Its straight forward until I get to the back end where there is heavy lifting with existing structures, applications and databases. This was a team effort.

Doctors, Physicist, Nurses, Navigators and Researchers need a way to look up a patient, their records, documents and doctor/hospital visits in real time.

Leveraging NLP technology we could quickly target patient data for specifics like lung nodule or tumors. We could gather the data, format and normalize it for better access. Then create a MVC application that would serve the data to other internal application and the CPL MVC site itself. This would automate processes and make the information device/platform agnostic.

Patient data and records have a simple data structure requirement that is too flexible to really make any meaning of the content. Medical organizations use all types of different data servers. What you end up with is huge blobs of data that has to be processed into a usable, readable structure. Volume is an issue as well. I spent a lot of time designing structures and creating processes that had to jump over different domains. Security was a big issue not only with storage but serving the information as well. Since we had other applications making request through CPL, we relied on AD (Active Directory) and powerful encryption techniques. I built ASP.net 4.5+ MVC controllers to handle request and return information. This is scalable and works really well because I could expose the API to not only the CPL web applications but to other applications as well, saving on cost and time. I created a custom attribute for security and permissions. The attribute is placed on all actions in each controller. I also created HTML Helpers that allowed me to overload methods, serving the information in many different types of formats like HTML, JSON, XML, etc...

The complexity and volume of the data allowed me to use new tools and technology that I hadn't worked with before- NLP & Hadoop (Cloudera) specifically. Hadoop does not replace SQL, you'll still need it for transactional request. Hadoop does the heavy lifting of big data. Between Hadoop and Android, I've been using Java quite a bit lately. At the time of me writing this, I've released 2 builds in a small feedback beta group, with great feedback - a luxury I don't always have. The CPL framework and web application, along with Cloudera will be released in the second quarter.

The Company needed a video solution to communicate with all departments and clients about products that were currently in development, especially after each sprint. This communication line needed to be technical enough to keep the attention of engineers but not so technical that it's go over the heads of clients and non-technical staff. Many of the employees are off site, complicating distribution and security. You have to keep in mind that these products are not released yet.

I developed a scalable, secure, MVC web application and Cloud storage that would meet the requirements.

The web app required a company email address for registration and validation. I hosted the videos in storage blobs in Azure containers that I set to private. The only way to access the videos is through a URL I dynamically generate in a controller from the MVC site. The URL contains a Shared Access Policy that contains an expiration date/time. For even more security I created a cloud library project in Visual Studio that restricts it's assembly visibility to the MVC 's assembly. Then I replicated the Azure containers across the country with load balancing (at the time, Microsoft had not yet built out their CDN). The MVC pattern itself offers scalability when structured correctly and with a few lines of code I can scale Azure by adding a streaming media server to consume and distribute the videos in the containers. This offers a complete scalable solution for years and years to come. All that was left was to create the videos. Gathering information from agile product owners and my own agile stories I coded, I was able to deliver both technical and non-technical communications is the form of videos. I used HTML 5 video tags with mp4 containers for cross browser support. I also used SignalR to simulate broadcasting by starting the videos once everyone was connected. I also used SignalR as a chat relay for questions or comments during the presentations. Using my own rendering engine (EGO Studio), I added particles and 3D objects for the motion graphics to the package.

This project was a lot of fun because I was given more creative freedom than usual but this also meant I had to wear many hats and create some tools from scratch. This affected deliverable frequency. Initially, it was a bumpy road but as things started to take shape, everyone was on board and I made a few fans and some new technology we could use in the process. I wish I could actually share some of the amazing videos we created. They show off all the hard work my colleagues and I have done but due to contractual obligations they are property of SSI Group Inc.

Existing Job application is written on old Fox Pro technology that is no longer supported and cannot take advantage of multi-threaded, modern hardware.

Rewrite in C# and structure for multi-threading. Build a Windows Service that can open a pool of Jobs.

A multi-threaded C# console application distributed over a large scaled server farm, the Job Engine loads jobs dynamically by creating objects by name using attributes. Most of the jobs process medical claims for hospitals and physicians. Using the Entity framework with over 4000 SQL databases. This application processes over 600 million transactions totaling in excess of $800 billion in billed electronic claims revenue for care providers annually. The job engine was built from the ground up with scalability in mind. I wanted to make it flexible, scalable, easy to develop jobs for and easy to support. Internal logging records every major step of the process as well as a serialized snapshot of all the properties and objects. These items can be downloaded from the database and loaded into a test environment for debugging in the Visual Studio 2012-2013 IDE. The solution comes with a service that uses a dispatch pattern to distribute the jobs over Windows Communication Foundation. This allows for scalability and flexibility over the network by allowing the dispatcher to be paired with the engine on one server or a one to many server setup, depending on network traffic. The dispatcher service can also be configured to assign specific job types to specific job engines. The job engine logs stats about how long a job takes to complete, CPU usage and memory usage. These stats drive the configuration and distribution model over the network. The engine can handle multiple jobs at one time on different threads, creating an application pool environment similar to IIS. Lifetime variables can be configured in engine, controlled through dispatch or the engine can learn for itself over time. Because developers needed to be able to customize jobs for specific clients, I broke part of the solution out into 3 separate libraries- shared, parts and the jobs themselves. This allows me to dynamically load customized jobs through late binding. The shared library consist of interfaces and abstract classes that force types and methods between the engine and the jobs. The parts library contains atomic code with virtual methods. This class can be inherited as a base class thus allowing the atomic code methods to be overridden for job customization. The atomic library also minimizes duplicate code since all jobs reference it.

I developed jobs.exe using the visitor pattern. Under Agile and the Scrum framework, I continue to work on the engine and jobs. Jobs.exe was developed to replace older technology and take advantage of multi-threaded chip-sets in modern high performance servers.

The Company's Support team needed to combine 3 different application's functionality in one application. They also needed a way to communicate with each other through a chat system and a knowledge-base that was searchable. Managers needed a way to measure performance and recognize troubled clients in real-time.

I developed SCOMM, a Client Support desktop application. Seamlessly integrated with Microsoft Exchange, the phone system and SQL. I created data transfers using SSIS packages, importing and cleaning data from old flat file systems into the new SQL Client Database I created for JCMT. I also created a chat relay server and a telephone remote as a windows services.

Support reps track time and work client issues- communicating via the phone system, email or the website. Tools include client details, asset management, support level management, knowledge-base, ticket work-flow, escalation and assignment. Instant report access gives management the ability to recognize strengths of personnel delivering optimum utilization. Harnessing .net technology and history tracking data in SQL to not only manage the clients but give all teams in the business the ability to target specific goals and enforce business strategies. The heart of this support solution is the communications processing that happens in the background. If a client calls in with a critical issue, every department is notified. This eliminates sales teams blindly selling to clients with existing issues. This application features a network authentication/permissions hierarchy and an auto update feature for update deployment.

Because Client Service Developers could create .net custom libraries, I used Abstract Classes to force complete implementation. Base classes with virtual methods could be overridden to offer flexibility while maintaining the Proxy structural pattern.

The company needed an electronic way to complete sales transactions. Data needed to be recorded to measure performance and length of sale process.

I developed JOES (Juris Order Entry System) an ASP.net, data driven web application that automated many processes. Reducing sales closing and shipping time.

The Juris sales channel was driven by a team that entered the orders into an application that only encapsulated the final process, the financial transaction. I saw an opportunity to leverage .net technology and SQL to record the entire process. This would give us a better idea of how long an order took to complete from start to finish. I knew that I could also store the proposals in SQL and give the sales team a dynamic template to work with that would ensure our message to the client was the same no matter who delivered it. JOES gave the sales force a one stop shop for everything they needed. They could select the products and services and a proposal was automatically created. They could then export the proposal to PDF or Word. All they had to focus on was selling. In the final steps of the sales procedure, credit cards could be processed and upon approval, the site automatically created invoices, billing imports for A/R, queue the items to be shipped and then automatically set up the new client. JOES streamlined the work-flow and ensured accuracy giving us a wealth of knowledge on our sales process. We were able to break down a sales order to the module level. Even shipping cost could be monitored via SQL Reporting Subscriptions.

This project's release was very rewarding for me because it gave me an opportunity to help a large amount of people and their day to day work experience and flow. This was the year I won the President's Award.

The company's Marketing team needs a way to bulk email specific users at the firm.

Create a Windows Application that lets Marketing generate an email list by identifying user's roles at the firm.

JEmail is a bulk email application that allows users to target email communications by product, software, services, contract types, positions, location, size and many other pieces of the client's profile data. The email communication can be loaded from HTML, word, text, and image files. Exchange profiles are used to differentiate the "FROM" address. Permissions on the client contacts table in the database determine the types of communications the client would like to receive. JEmail works with Exchange to deliver the communication. This application features a network authentication/permissions hierarchy and an auto update feature for update deployment.

This application was my first opportunity to take advantage of .net 2.0's multi-threading capabilities. I used delegate signatures to communicate between threads and the form's Win32 message pump. This allowed me to update the windows UI and the task's status. I also used the Thread Pool and ManualResetEvent objects to signal thread completion. Mutexed Wait-handles helped in raising events and managing multiple threads.