Resume

Objective

My goal is to bring experience, maturity, focus, knowledge, and a healthy amount of hubris to my job in order to tackle both technological and personal challenges.

I am passionate about doing things right and doing them quickly. These are not antithetical; a proper knowledge of principles, action in the face of ambiguity, and diplomacy to coax the best from all can nurture a self-organized software team.

Above all I want to invest in people I believe in and promote a company that I know represents my values.

Employment History

APPENDTO INC. | Architect/Project Lead, October 2012 – Present

In my current position at appendTo, I have worked on a number of customer projects for the Solutions Delivery department, as well as several projects for internal development.

Web application for managing bulk food donations (customer)

Technologies: HTML5, CSS3, JavaScript, jQuery, knockout, amplify, nonet, ventage, underscore, handlebars, node.js, strata

  • Functioned as technical lead for this project, and sole developer.
    • Deconstructed client needs into user stories.
    • Formulated and documented technical architecture, components, and strategies for mitigating technical challenges.
    • Worked closely with customer’s development team to identify APIs, define data schemas, and document workflows, business requirements, and domain knowledge.
  • Created a custom, single-page, responsive web application to replace a legacy line-of-business web application.
    • Application worked across mobile devices (primary use case) and modern desktop browsers.
    • If offline, application continued to function by combining ApplicationCache and offline storage.
    • Application aggressively cached certain HTTP responses so that if offline, those responses could be used as reference for future requests.
    • If users submitted delivery forms while offline, submissions were queued and application would process them when network became available.
    • Application supported multiple languages through custom localization implementation (included server responses).
  • Client implementation was a custom, SPA framework that utilized jQuery and knockout (all routing, data access, caching, etc., implemented as custom JavaScript code).
    • Data access layer implemented with an extensible, promise-based middleware layer to give customer granular control over what happens to requests and responses.
    • All data requests abstracted into resource modules.
    • Offline support, response caching, request interception, and API authentication error handling implemented as promise-based middleware.
    • Used a 5-fold approach to determining online/offline state that degraded across browsers.
    • Automatic cache cleanup after configured TTL.
    • Interfaced with camera on mobile devices to scan and decode QR codes.
  • Custom node.js proxy used to simulate API responses before client implementation was complete, and to proxy requests to finished client APIs, handling authentication, custom headers, virtual application root, etc.
  • Build process minified and concatenated all application resources, generated manifest.appcache, and organized assets to be deployed seamlessly on the customer’s IIS web server.

Android Cordova application for taking bulk food donation inventory (customer)

Technologies: Cordova, AngularJS, HTML5, CSS3, JavaScript, lodash, node.js, mach

  • Developed hybrid mobile application with Apache Cordova that can run natively on android devices with the option expand to iOS, Kindle Fire, Blackberry, etc.
  • Used AngularJS as the development framework to build a single-page application.
  • Application functions with or without network access, caching reference data locally in SQLite data store and queuing posted data for future delivery
  • Created virtual, HTML-based keypad for user input when Bluetooth laser scanner is paired with Android device (the scanner takes over as the sole source of input, preventing the native Android keyboard from being used).
  • Created multi-lingual build configuration so globalized versions of the application can be built and deployed.

Social web application for entrepreneurs (customer)

Technologies: HTML5, CSS3, JavaScript, jQuery, knockout, require.js, node.js, express, mongo, mongoose.js, redis, grunt, sass, dotCloud, Ubuntu Linux

  • Functioned as technical lead for this project.
    • Performed initial technical discovery on customer needs.
    • Deconstructed customer requirements into user stories and documented technical architecture.
    • Coordinated JavaScript engineers and Visual Design engineers, allocating user stories and conducting code reviews to maintain code quality and meet customer expectations.
    • Managed all project artifacts and kept notes on all meetings and customer interactions for reference.
    • Assessed risks and made decisions in cases of ambiguity, keeping team on-task and progressing while balancing potential retrogressions and accounting for potential misdirection.
  • Created a scalable, social network web portal for budding entrepreneurs.
    • Multi-page web application that tracks personal and professional information of entrepreneurs from all over the U.S.
    • User information is combined with a suite of business rules to suggest potential partners for entrepreneurial ventures.
    • Members can submit written business articles which is then disseminated to third-party syndication sources.
    • Members may find other members in close proximity by using geolocation matching based on zip code and/or latitude and longitude.
  • Application client implemented as a multi-page, responsive solution with knockout and jQuery.
    • Heavy use of knockout view models for separation of UI, data, and logic concerns.
    • Full responsive functionality available across devices and desktop browsers.
    • UI enhancements (animations, WYSIWYG editors, form control widgets, etc.) implemented where necessary.
  • Application backend implemented as node.js express application server.
    • User authentication through customer OAuth2 server using passport.
    • Member data stored in mongo replication set, migrated from WordPress MySQL instance.
    • Integration with Infusionsoft CRM system via node wrapper around web APIs.
    • MongoDB geolocation API leveraged for user proximity lookups.
    • Chat servers created with node.js using redis for message routing, but never deployed to production.
  • Application server deployed on custom dotCloud instance.
    • Custom build and deploy scripts required due to specific custom application requirements.
    • Mongo instance deployed to mongolabs.
  • Custom migration system developed to transform, clean, merge, and export existing data from both WordPress and Infusionsoft to mongodb.

Web application to connect former military personnel with employers (customer)

Technologies: HTML5, CSS3, JavaScript, angular.js, lodash, grunt, sass

  • Deconstructed high-level application description and wireframes into workable user stories.
    • Identified actors, actions, and goals for each story.
    • Broke stories down into logical tasks and identified technical requirements for each task.
    • Linked all stories back to customer project management system for traceability and acceptance criteria.
    • Worked with customer’s development team to understand and define common data and components.
  • Created a custom single-page web application that connects former military personnel with potential employment opportunities.
    • Members could search for jobs offered by various companies based on keywords, company size, industry, etc.
    • Members could contact recruiters for companies about specific jobs, or link to external applications.
    • Members could favorite specific jobs to visit later.
    • Recruiters could track applicants and send messages to potential employment prospects.
    • Recruiters could join scheduled job fairs in which members would shop around for employment opportunities.
  • Application implemented as a single-page, angular.js client.
    • URL routing handled by UI state router, allowing us to divide the application into logical modules (templates and controllers), each of which would be instantiated when its route was invoked.
    • Mocked extensive data sets while ioStudio prepared live APIs with specified data schemas.
    • Tested all application controllers extensively with mocha/chai and angular’s built-in testing facilities.
    • Created custom directives for re-usable components (multi-field form elements, background file uploads, etc.).
    • Leveraged angular resources for all data access, encapsulating URLs and standardizing data access interfaces.
    • Made extensive use of promises for application control flow.

Social web application for teachers and students in academic settings (customer)

Technologies: HTML5, CSS3, JavaScript, jQuery, Backbone, node.js, postal.js, machina.js, socket.io, express, handlebars, mongo, mongoose.js, redis

  • Primarily added features to and extended the functionality of the Manhattan social networking platform with modules that spanned client and server.
    • Students and participated in virtual “classes”.
    • Each user dashboard maintained real-time list of updates (streams) from friends and teachers.
    • Real-time changes to user profile information reflected immediately for friends viewing their information.
    • Real-time class membership reflected immediately when users were added/removed from a class.
    • Users could post a variety of information (text, images, videos) to personal “streams” that would then be added to followers’ streams.
    • Users with accessibility screen reader requirements supported via aria tags and attributes.
  • Application implemented as a single-page Backbone app with a custom data layer that used an in-memory message bus (postal.js) for data requests and application events.
  • Finite state machines (machina.js) used to detect network and application state and cache requests and events until states changed.
  • node.js used to proxy requests to eCollege Java web services, as well as store application preferences and state data in distributed mongo instances.
  • redis used to route event data between application instances. Application servers (node.js) forwarded redis events to browser clients via socket.io.
  • Stream functionality exposed to third-party JavaScript apps (3PJS) as widgets using postal-xframe to overcome cross-domain concerns.

Web application for members to share annotations on classic texts (customer)

Technologies: HTML5, CSS3, JavaScript, rangy

  • Analyzed customer issue and performed code review to form initial strategy.
    • Documented all bugs, potential risks, and potential solutions.
    • Kept tight feedback cycle with client, delivering fixes quickly to meet client deadlines.
  • Modified an existing application to solve severe performance problems:
    • hundreds to thousands of text ranges created in a document on page load;
    • one tooltip per annotation appended to DOM, further causing performance degradation;
    • user unable to scroll or interact with the page while annotations loading.
  • Determined that ranges were being created using start of document as offset point; dividing the document into logical sections and offsetting ranges from each section improved performance dramatically.
  • Interrupted range creation during mouse/keyboard events to make page responsive to the user.

Web application for executing project test suites across browsers (internal)

Technologies: HTML5, CSS3, JavaScript, strider

  • Fixed bugs and issues in base strider code (open source project on which BrowserSwarm was built) to meet a looming deadline.
  • Executed well under pressure, fixed all known bugs and issues, and identified potential future problems.
  • Project launched successfully due to significant last-minute team effort.

Miscellaneous (internal)

  • Wrote several technical articles for appendTo blog.
  • Assisted training director during JavaScript presentation to Amazon hardware team.
  • Led initiative to create a “Modern Web” eBook composed of chapters by appendTo employees
  • Contributed several open source projects to a2labs.
  • Mentored other developers through one-on-one video chats.

ELSEVIER | Senior Developer, January 2012 – October 2012

Technologies: JavaScript, node.js, strata, express, require.js, jQuery, HTML5, CSS3, mocha, chai, jake, underscore.js, postal.js, less, stylus, git, riak, redis, mongodb, OSX, Ubuntu Linux

  • For each application developed I worked closely with business sponsors and team leaders to generate requirements, user stories, and technical designs.
  • I created an application to display our generated API documentation in a searchable format. Our build process used an AST parser to generate a large JSON file that contained API information and documentation for every module in our system. I wrote modules to load, convert, and dynamically display API information in a single page application so that developers would have instant access to the latest documentation. All client modules were written in regular JavaScript, and jQuery was used to generate DOM elements as needed, and to perform filtering operations when the user searched for specific API information.
  • During our iteration demos we would present small slide shows to business sponsors. Originally this was done in PowerPoint, but I created a slide show application that ran on our platform to dynamically load and display slides written in either HTML or Markdown format. If the slides were written with Markdown, the express route handler would convert slide content to HTML before returning it to the browser. I used CSS3 animations for slide transitions, and media queries to scale down to mobile devices. Input control was handled in JavaScript, and the user had the option of either using keyboard navigation, mouse clicks, on-screen direction indicators, or (on mobile devices) touch gestures to transition back and forth in the slide show.
  • Some of our UIs made use of Twitter Bootstrap, so I developed an open-source, reusable tree control that could consume arbitrary JSON objects and turn them into a navigable UI. Custom tree events could then be handled in external code as the tree was manipulated. I used this to create a prototype for a proof-of-concept web IDE, where a JSON object with file references would be loaded into the tree, and when a user interacted with each file reference it would load the file from the platform into a tabbed text editor.
  • I created a custom piece of strata middleware that intercepted upstream requests and determined which data source should be used to fulfill the request based on the path information that strata provided. This allowed the platform to dynamically “mount” data stores to URL segments as needed, and gave calling code a uniform API for data (instead of having to know about each data store independently).
  • I conducted extensive research and gave presentations on topics of import to the project, such as UI libraries, cross-domain iframe communication and browser sandboxing, user experience recommendations about how and when to save data in a user interface, etc.
  • Performed project maintenance tasks such as building automated jake tasks, managing and updating NPM packages, rebuilding binary dependencies, filling out unit test suites (mocha/chai), breaking up large node modules into smaller modules for maintainability, creating README files for modules and apps, adding documentation to the wiki, etc.

FPWEB.NET | Senior .NET Developer, December 2010 – January 2012

Technologies: C#, .NET 4.0, ASP.NET MVC 3, ASP.NET WebForms 4, Ruby, Rake, HTML5, CSS3, Sass, JavaScript, jQuery, Chrome extensions, SQL Server 2008, SQL Server CE 4, Entity Framework 4, NHibernate 3, Linq2SQL, PowerShell, nUnit, TeamCity, AgileZen

  • In an effort to save time for the engineering team, reduce the cost of setting up a shared SharePoint instance, and provide customers with much quicker service, I consolidate the shared hosting site setup functionality and automated the basic setup process. Engineers would typically use a number of PowerShell scripts that would be executed manually in response to a customer order. I deconstructed the scripts and divided them into functional parts, then used the .NET PowerShell libraries to automate their execution in response to orders placed on our public website. My solution was highly extensible: each step in the provisioning process was encapsulated and placed in an execution pipeline, the inputs of which were the outputs of the preceding steps. The solution was designed so that additional provisioning functionality could be inserted into the pipeline by extending existing classes.
  • I was also responsible for handling specific portions of the data migration strategy, specifically being able to synchronize product price changes made in local systems to our billing provider remotely, in bulk. This allowed management to bypass the inherent limitations of the billing provider’s user interface and edit the prices of multiple items at once. Also, because our products were informally categorized in hierarchical relationships (informal because the billing provider’s system did not support such relationships), it was necessary to propagate price changes through a hierarchy of products, allowing management to change the price of the “topmost” product–a change that would be replicated throughout the tree. I created a command line utility that would perform these operations based on price changes that management would specify.
  • To eliminate the rigidity of our existing billing system (an IBM AS400), and to give management the flexibility to define products and services in ways that allow us to accommodate a variety of customers and their specific hosting needs, our team migrated all existing billing information from our legacy system to a cloud billing provider. I was primarily responsible for creating a data sync solution that would pull data from the cloud billing provider and store it in an on-site data store for disaster recovery purposes, reporting, and to be accessed by internal applications. My solution used the WSDL endpoints provided by the billing provider, as well as their CSV-based reporting interface to consolidate data from the billing system, and write it to our internal data store. The synchronization service used several threads to run different synchronization schedules (an incremental synchronization every fifteen minutes, and a full synchronization once a day). Each thread communicated its status to the other so that two synchronizations would never happen simultaneously. The software was installed as a Windows service, but could also be run ad-hoc as a command line executable. It was also responsible for failing gracefully if particular errors occurred (e.g., unable to communicate with the remote service), and to issue email warnings if it failed for unknown reasons. This service is now indispensable for the company CFO who uses the local data store to generate financial reports that he cannot obtain from the billing provider’s user interface.
  • Our company standardized early on the Chrome browser, specifically because of its advanced HTML5 support, but also because it has a robust plugin system that we wanted to leverage. Company employees typically use a variety of systems, some internal, some external. While we do not directly control external systems, we were able to leverage Chrome’s plugin support to “add” features to external systems that otherwise would not be there. I was directly responsible for implementing a universal feedback form on all sites that employees use in their daily work. I created an HTML5 interface and a JSON service that would consume data submitted by the form, then added scripts to our Chrome plugin that would inject the form into specific internal and external web applications. As a result, company employees can now submit bugs or requests to the development team from any web application they use. This feedback is piped to our task management software (AgileZen) via web services, and we are able to review all requests from employees quickly and effectively. This has become a very popular feature.
  • Several of the company’s internal web applications were a mixture of classic ASP and .NET WebForms technologies. We decided that, to increase our productivity and decrease the feature release time, we would re-platform these applications and use ASP.NET MVC going forward. To minimize the interruptive impact on the business, we began releasing new features, or replacement functionality, in very small increments, and made it easy for employees to navigate between the old and new system with ease. To give our customer care team a more accurate view of a customer’s account at-a-glance, we decided to create a “feed” of events on each customer’s account that would consolidate data from many different sources (notes, invoices, payments, subscriptions, etc.) and present it as a unified timeline of account activity. All data retrieval was handled by jQuery client-side, and we used Handlebars templates to create each item in the feed–with its own unique look and characteristics–as data was dynamically loaded. I was responsible for writing most of the client-side JavaScript to perform these tasks, and worked closely with our team designer to make sure the user interface was snappy.
  • I was also responsible for performing maintenance work on all internal applications and our public website. This usually consisted of bug fixes or small feature requests, or integration with other systems so that data could be shared or viewed by specific employees. I also contributed a significant amount of Wiki documentation to our team’s internal knowledge base so that other team members could quickly digest and be productive with code that I had written if they needed to change or enhance it.

LIPPER (THOMPSON REUTERS) | Web Services Developer, July 2010 – November 2010

Technologies: C#, .NET 4.0, Windows Communication Foundation, SOAP, Oracle 10g, Subversion, CruiseControl.NET, MSTest, Bugzilla, Fiddler

  • Developed publicly exposed, secure WCF services to fulfill the feature requirements of the Lipper Investment Management desktop application product. Standard XML serialization was used for message contracts to fulfill SOAP 1.1 conformance requirements.
  • Worked with Oracle development team and desktop application development team to design services that were efficient, met performance requirements, and adequately encapsulated business rules. Web services also encapsulated communication with other company systems, such as the financial analytics cluster. Because financial data is time-sensitive, stringent performance requirements were followed, and often required services to execute logic that would acquire data on separate threads, consolidate it on the service thread for caching, and then deliver it to the client.
  • Designed, implemented, and documented a multi-threaded task registry that could be initialized with any number of “tasks” at application pool startup and run each of them concurrently until the application pool terminated, or the specified timeout for a given task occurred. I created an initial task implementation that would check the analytics cluster endpoints for connectivity, appropriately marking given endpoints as available or unavailable. Services that required connectivity to the analytics cluster would then request available endpoints from the task, and connect as needed. This guaranteed that unavailable endpoints were never accessed.
  • Designed, implemented, and documented an XML-based health check monitoring subsystem which would check service connection dependencies and determine if a service was available or offline. Each dependency that implemented the health check contract would, in turn, check its dependencies, and a consolidated report would be returned to the user from the public facing service method.
  • Helped maintain a suite of unit/integration tests which were used to verify the performance level of active services, as well as the accuracy of data returned from them. Created new tests when adding new services or significantly altering existing service functionality.

INTELISPEND | Senior Developer, January 2010 – July 2010

Technologies: C#, .NET 2.0, ASP.NET WebForms, .NET Remoting, Subversion, CruiseControl.NET, NUnit, SQL Server 2005

  • Worked with a team of developers to upgrade an existing ASP.NET business web application for a critical 2010 release. The delivery deadline was six months, divided into three week iterations. Planned velocity was exceeded every iteration until release to meet product owner needs. Developers participated in every phase of an Agile lifecycle, including iteration planning, daily stand-up meetings, iteration review, etc.
  • Added significant usability enhancements to legacy pages using dynamic HTML and the jQuery JavaScript framework. UI enhancements included drag-n-drop DOM elements, tree views, specialized validation, etc. Created several new modules from new business requirements which involved new user interfaces, entity objects, data access code, etc.
    Successfully converted legacy prototype JavaScript framework code to jQuery in all existing web pages and assembly-embedded JavaScript files.
  • Contributed to the standardization of CSS layout rules. Converted many legacy table-based pages to CSS layouts to eliminate excessive markup, promote style reusability, and achieve cross-browser consistency.
  • Tested all new and converted web pages in IE6, IE7, and IE8 in order to meet client expectations and needs.
  • Created new and updated existing ASP.NET template-based server controls that were used in various places throughout the application.
  • Updated the data access layer when needed. Created and modified SQL DDL scripts, stored procedures, functions and pre- and post- deployment scripts.

USFIDELIS | Senior Developer, May 2008 – January 2010

Technologies: C#, .NET 3.5, ASP.NET WebForms, ASP.NET MVC, Windows Communication Foundation, Windows Presentation Foundation, LINQ to SQL, Entity Framework, SQL Server 2005/2008, IIS 7, Visual Studio 2008 Team System, Team Foundation Server 2008, Subversion, Team City, MSTest, NUnit, RhinoMocks

As part of the company’s growth strategy, I split the existing corporate website into three distinct websites and augmented the functionality of each. All websites were written leveraging the .NET 3.5 framework.

  • I implemented two static mock-ups in ASP.NET MVC and worked with the design team to make sure web standards were followed. Functionality from the primary corporate site was migrated to each secondary site, respectively.
  • For a rich-internet experience, I leveraged the jQuery JavaScript library and ASP.NET MVC JSON support to retrieve data from the browser without executing postbacks.
  • I wrote numerous Windows Communication Foundation web services to form an application tier which masked the underlying application data model. Each website consumed WCF services directly.
  • I created a data model for each website in TSQL and used LINQ to SQL as the object-relational-mapping tool to interact with the data store.
  • I added NUnit unit tests to each secondary site and used RhinoMocks to simulate application dependency functionality in each unit test. A Team City build server was deployed for continuous integration, and unit tests were executed for every source control checkin.
  • To bring additional revenue to the company, I finished the re-design and implementation of the primary corporate site and worked with marketing on several web traffic campaigns using Google Web Analytics and Frontline Analytics. I also ensured that all regulatory compliance tasks were implemented in a timely manner.
  • I re-factored the primary corporate site to eliminate code duplication, break up dependencies, and ease the maintenance process.
  • I worked closely with the application administrator to clean up old environments and implement a standardized promotion process whereby each website was thoroughly tested in internal and external environments before being released. Each environment (development, staging, and production) consisted of a single IIS 7 web server, load balanced IIS 7 web service application servers, and a replicated SQL Server 2008 instance.
  • To promote consistent release schedules, I worked with the project manager to re-factor Team Foundation Server source control and develop a change management process. We decided to use a semi-agile approach with small iterations and quick feedback.

In order to mitigate the technological risks of re-engineering the existing line-of-business application, I was assigned to research, prototype, and make recommendations about chosen core technologies.

  • Windows Communication Foundation (WCF) – I demonstrated that WCF proxies could be constructed dynamically by wrapping WCF’s ChannelFactory.Create() call in a custom class that acquired all endpoint settings from a custom data store. I also documented all WCF binding settings that directly affected our environment(s) for quick reference. In addition, I was tasked to demonstrate how clients could receive WCF messages on parallel threads and marshal those messages to the UI thread when UI updates were required.
  • LINQ to Entities – After evaluating LINQ to Entities 3.5 and concluding that lack of POCO support, customizable entities, and self-tracking entities (in a disconnected state) were severe hindrances to our project, I began evaluating LINQ to Entities 4.0 beta. I created a proof-of-concept project that demonstrated the new T4 entity templating engine with customized entity templates, and self-tracking entities across a WCF service boundary. Problems with entity object graphs and maintaining entity state after database writes led me to conclude that additional ORM research was warranted because LINQ to Entities is not sufficiently mature.
  • Windows Presentation Foundation (WPF) – I evaluated several possible design approaches for WPF user interface views, including Model-View-ViewModel (MVVM) and the Prism framework. We decided to use Prism due to its compatibility with Silverlight, it’s robust EventAggregator messaging system, it’s use of Microsoft’s Unity Application Block for dependency injection, and it’s support for reusable UI regions. I also demonstrated that WPF can enforce action-level security through its commanding system and control-level security through its visual and logical tree helpers.
  • log4net – I demonstrated the robust logging capabilities of log4net by creating a custom WCF appender class that sent log messages to a WCF service asynchronously. Since our client applications live in a disconnected state, this will provide a tremendous benefit to developers who will no longer need to ask users to provide physical log files for debugging purposes.
  • ININ ICELib – I evaluated ININ’s .NET API for their VOIP telephony system in order to determine if we could integrate call center functionality into our applications without using ININ’s standard client. I was able to connect to the server and perform all basic telephony tasks from within a WPF test harness.

As part of the project leadership team, I took the initiative and wrote several standards documents for the team to consume.

  • Coding Standards – Our coding standards document details mechanics of good variable naming conventions, commenting code, exception handling, etc., as well as best practice guidelines for refactoring, .NET Framework usage, event handling, etc. Coding standards were routinely invoked in code reviews to ensure that all developers were consistent in their practices.
  • Solution Structure and Namespacing – In order to enforce consistency in Visual Studio solution/project organization, I created this standards document with code organization guidelines. All new projects adhered to its general recommendations.
  • Source Control Structure and Branching Strategy – This document was developed in conjunction with our iteration plans to ensure that teams were working in appropriate source branches during development phases. All .NET library dependencies and database were moved into source control as well.
  • Performed maintenance work on an existing legacy line-of-business application in preparation for a critical re-write
  • Participated in numerous requirements gathering focus group sessions, as well as executive-level steering committee meetings to determine the shortfalls of the existing line of business application and triage feature requests
  • Prepared initial documentation for new application architecture, focusing on the business domain and key functional specifications (artifacts included UML diagrams, risk assessments, a vision document, an integration document, etc.)
  • Led a design patterns workgroup for existing developers to help educate and empower the development team in preparation for development on the new application
  • Contacted third-party data and service vendors and analyzed external APIs in preparation for application integration

BITMESA, LLC. | Partner, March 2008 – December 2010

Huntleigh USA (Client)

Technologies: C#, .NET 3.5, WinForms, Apache, MySQL 5, Subversion, Mantis

  • Developed a .NET desktop application to record and manage scheduled wheelchair assistance for over twenty airports in the United States. The application was written in .NET 3.5 WinForms with a custom MySQL data access layer that communicated across a company VPN.
  • I implemented an XML based caching module that saved data to a local machine if network connectivity was interrupted, or VPN access was unavailable.
  • Custom reports were created in PHP to track individual airport team statistics.

RinaWear.com (Client)

Technologies: C#, .NET 3.5/4.0, ASP.NET, SQL Server 2008, NHibernate, jQuery

  • Designed a custom e-commerce retail website for selling apparel online
  • Designed a custom database schema for products, sales, customer management, etc.
  • Integrated with Authorize.net merchant solutions for e-commerce transactions
  • Initially designed the site in standard ASP.NET but migrated later to ASP.NET MVC with NHibernate to increase maintainability and flexibility

FAMILY TREE DNA | Lead Developer, September 2007 – May 2008

familytreedna.com

Technologies: C#, ASP.NET, SQL Server 2005, IIS 6, Mantis, Subversion

  • Assessed business needs that were unfulfilled by existing public-facing website
  • Documented existing business practices, and prepared suggestions detailing a software/hardware platform transition
  • Established a bug tracking system and trained customer service representatives to use it
  • Successfully resolved/fixed 217 of 293 reported bugs €“ roughly a 74% bug closure rate, averaging one bug closed every three hours, every business day from August to November
  • Mitigated two separate system intrusion incidents, preserving all data and creating a security solution to prevent further compromises
  • Delivered two iterations of upgrades to the site, coordinating with a remote team in China to integrate and deliver changes seamlessly; both upgrades were delivered on-time

dnatraits.com

Technologies: PHP5, symfony, MySQL 5, Apache, Linux, Mantis, Subversion

  • Developed data model, business logic, and user interface components according to business criteria
  • Determined priority of requirements and worked in iterative phases to meet deadlines.
  • Worked with scientific collaborators in New York, Israel, and the United Kingdom to acquire domain knowledge
  • Reviewed several PHP MVC frameworks and chose to develop the application using Symfony due to flexibility, community support, feature availability and documentation
  • Developed a secure, comprehensive administration portal that provided user-friendly access to product, customer, and sale data, as well as financial reports; used Javascript/AJAX where appropriate to enhance user experience
  • Developed an XML-based, Schema enforced data exchange with a partner lab in the United Kingdom to deliver order information, and receive testing results, on a regular basis
  • Made significant enhancements to the public-facing checkout system, including a dynamic, client-controlled discount and coupon scheme
  • Created dynamic PDF reports accessible via the customer portal to give customers access to their test results
  • Integrated a third-party appointment tracking system to allow customers to schedule phone calls with in-house genetic counselors

NATIONAL AUTO WARRANTY SERVICES (USFIDELIS) | Software Engineer, August 2006 – August 2007

Technologies: C#, .NET 3.x, WinForms, Windows Communication Foundation, Visual Studio 2005/2008 Team System, Team Foundation Server 2005/2008, Visual Source Safe

  • Worked with a team of ten developers on an extensive Lotus Notes legacy system re-platform
  • Gathered business rules and scenarios for several administrative departments to determine the appropriate functional and non-functional requirements for the replacement application
  • Prepared high level documentation for company business scenarios
  • Worked with the database administrator to form a data model consistent with the business model
  • Implemented a C# .NET smart client (WinForms and web services) architecture using Microsoft Windows Communication Foundation for a 300+ user call center
  • Designed and write a significant portion of the customer service and contract fulfillment portions of the application, as well as the underlying web service components
  • Designed and wrote administrative portions of the application used for entering automotive data, team information, and pricing configurations
  • Acted as a liaison between the primary application team and the accounting subsystem development team as a reference for the financial operations of the business
  • Led a refactoring initiative for core components of the application that underperformed due to fluid requirements

RIVER CITY INTERNET GROUP | Web Application Developer, November 2005 – August 2006

Technologies: PHP 5, Java, Apache, Apache Tomcat, Linux, MySQL 4, Bugzilla, Subversion, Zend Studio

  • Worked in collaborative software development environment on an enterprise scale ISP management system IntraISP
  • Acted as production support liaison between RCIG and clients by analyzing critical production bugs (both code and data), proposing solutions, and conducting follow-up meetings with clients
  • Designed and coded software solutions in accordance with client requirements
  • Performed bug analysis and implemented bug fixes for all parts of the IntraISP system, including customer registration and management, equipment activation, customer billing, financial reports, feature management, external/internal APIs, etc.
  • Wrote custom software modules to extend PHP front-end functionality and PHP APIs
  • Enhanced existing Java web services; performed troubleshooting for Java web service bugs
  • Wrote high level and functional documentation according to customer specifications, as well as release notes and test cases for all implemented solutions
  • Authored company-wide PHP coding standards document
  • Wrote an internal PHP application that tracked software release notes

DSDIRECT (USFIDELIS) | Web Application Developer, July 2005 – October 2005

Technologies: C#, VB.NET, IIS 6, SQL Server 2000, Visual Studio 2003

  • Performed requirements analysis for administration projects
  • Designed portions of intranet sales application for auto warranty salesmen using ASP.NET (both VB.NET and C# as code-behind languages), Microsoft IIS, and Microsoft SQL Server 2000
  • Wrote sales interface documentation

PROTECH NETWORK DESIGN | Web Developer, May 2004 – July 2005

Technologies: PHP 4/5, MySQL 4/5, Apache, Linux, FreeBSD, Zend Studio

  • Acted as project manager and web application architect for numerous small/medium-sized businesses clients and individuals
  • Performed requirements analysis, prepared sitemaps and cost quotes, and wrote documentation for web projects
  • Designed, coded, and maintained a variety of websites and web applications
  • Designed and coded internal web application that managed project information, customer information, purchase orders, credit card information, web hosting information, and generated a variety of reports
  • Developed several PHP classes (security implementation, calendar) that were re-used in a variety of PHP applications
  • Helped administrate a mixed network environment with Windows 2000 and FreeBSD servers
  • Performed network installs, cabling, and testing; performed PC troubleshooting, maintenance, and upgrades for client computers

References

Contact me for a list of references.

One thought on “Resume

Comments are closed.