A 3D entanglement

Our product arises in the 3D modelling community from the need of its professionals to have a reliable place to network and showcase their work.

Table of Contents

Team

Vision

Mesh’s responsibility is to provide 3D modelers everywhere with the definitive platform to showcase their best works and collaborate with their peers. Our vision is to provide a networking infrastructure for like-minded professionals and potential customers or employers. We intend on achieving this with a modern, fast and simple to use website, with the latest technologies in online 3D model management and with a full-fledged set of social tools.

Domain Analysis

Concepts and Terms

Competitors

Currently, our main competitor is Sketchfab.

Despite being a well-polished infrastructure, it lacks some of our main aspects, like:

• Strong user networking, both within the website and by interaction with services like LinkedIn;

• User cooperation and community building;

• 3D model exportation capabilities.

Major Features

We intend on offering a full-fledged experience without damaging the design, performance or usability of our platform. As such, we will offer a simple to user, fast, responsive website with the following main characteristics:

• 3D rendering of models both on desktop and mobile devices
• Comprehensive profiles showcasing the professionals' work
• Portfolio sharing to well-known networking platforms such as LinkedIn
• Intuitive model exporting to third-party services like Dropbox
• All the functionality of a social networking platform

Architecture

The application architecture follows a client-server model:

Technologies

Client

AngularJS - JavaScript MVVM Framework

Instead of a set of static HTML pages, our client application is an AngularJS single page application.

The adoption of this framework has several design goals:

• Decouple DOM manipulation from application logic. This substantially reduces boilerplate code and improves modularity and testability.
• Decouple the client side of the application from the server side. This reduces much of the burden on the backend and allows development work to progress in parallel with minor hiccups.
• Provide an incremental and iterative development process for the client, from the UI design to the writing of the business logic.

Karma - AngularJS Test Runner

This running environment is used for the unit testing of small "units" of code, such as isolated views, controllers and services.

Karma is a tool which spawns a web server that executes source code against test code for each of the browsers connected.

Each time a test is run, Karma records its status and then tallies up which browsers have failed for each test and which ones passed and timed out. This makes each test work 100% natively in each browser without the need to test individually.

Protractor - AngularJS E2E test framework

Karma provides a bundled AngularJS Scenario Runner, however, it was deprecated in favor of a more robust end-to-end testing platform: Protractor. End-to-end tests are equivalent to acceptance tests.

By translating the formal tests to a Protractor testing suite, we are ensuring that the application respects the specification requirements. It does not replace the traditional deployment of the application to the end user for testing, but it does help in the development process as an additional insurance.

Bower - A package manager for the web

Bower is a front-end package manager that simplifies the installation of third party frameworks, libraries and assets.

Grunt - A JavaScript Task Runner

Grunt is a Javascript automation tool for source code minification and obfuscation. It is also used for the automation of the testing environment.

Server

node.js - Platform for easily building fast, scalable network applications

There were several reasons that led us to choose Node.js over other alternatives for the back-end.

• Node.js really excels at I/O bound operations. In our application, data streaming and database accesses are the most common operations. There are barely any CPU intensive tasks that would block the main loop.
• The node package manager (NPM) has evolved into an extremely rich registry of modules that are ready to use.
• The fact that both the client and the server are written in JavaScript promotes some code reuse between the client and the server.

Hapi.js - A framework for building web services

ExpressJs is currently the most popular web application framework for Node.js. Several companies are using this framework in production, why did we chose Hapi.js instead?

Hapi.js is a Node.js framework created by Walmart. It supports all of the Walmart mobile infrastructure. We chose this framework in particular because:

• It is designed for Walmart scale.
• It is maintained by a full-time dedicated team.
• It provides a wide range of plugins for documentation, authentication, testing, caching and others. Full list of plugins.
• It promotes configuration over code.

Neo4j - The World's Leading Graph Database

We imagine our families as trees, or our friends as graphs; most of us don’t imagine personal relationships as self-referential datatypes. For certain classes of problems, like social networks, Neo4j is an obvious choice.

Our domain model is perfectly suited for a graph database.

Redis - Key-value cache and data store

Redis is an in-memory datastore with optional persistence. Since all of the data is available in RAM memory, the data reads and writes are extremely fast.

The Redis database instance will have the following use cases:

• Server side caching of the latest database queries.
• Storage of the registered users activation tokens. When a user first registers in the platform, an email will be sent to his account with an activation token. These activation tokens have an expiration date. Keys in redis may have an expiration date (details), if that is the case, those keys will be automatically deleted without the need for additional scripts or cron jobs.

MongoDB - Document oriented database

MongoDB will be used in the following use cases:

• Storage of the user personal messages;
• Storage of the user notifications.

User roles

Themes, epics and user stories

User stories were grouped according to user roles. User stories and epics are described in Pivotal Tracker.

Scenarios

Scenarios for each user story are linked in the description of each US and available here.

User Interface Prototype

• login - http://meshdev.ddns.net/proto/#/login
• register - http://meshdev.ddns.net/proto/#/register
• model - http://meshdev.ddns.net/proto/#/model/1
• profile - http://meshdev.ddns.net/proto/#/profile/johndoe
• messages - http://meshdev.ddns.net/proto/#/messages
• group - http://meshdev.ddns.net/proto/#/group
• search - http://meshdev.ddns.net/proto/#/search?q=3d

Vertical Functional Prototype

http://meshdev.ddns.net/proto

Continuous Integration

Development branch

Deployment:

Travis:

Production branch

Deployment:

Travis:

Uptime Tracking

17 November 2014 - 17 December 2014

Iterations Post-Mortem

Iteration 1

Did well

• The technologies chosen are appropriate for the project
• Project structure is well defined, modularized and scalable
• Team is following the same coding standards
• Continuous integration

Do differently

• Properly divide user stories in tasks to allow easier (parallel) work
• We must create user stories for tasks that we are working on that aren’t in the backlog (such as adjusting the nav-bar to top bar), i.e document everything that has been done.
• Mention user stories in the commits (whenever possible, if no user story is linked to the commit, refer to point above)
• Update documentation as changes are made to the project

Puzzles

• Will Neo4j meet performance expectations?
• How to integrate Socket.io in our proposed chat feature?
• How to handle model uploads? (update estimate for user story?)

Iteration 2

Did well

• Team is following the same coding standards
• Continuous integration
• The project structure has been properly maintained
• The project documentation has been updated with the development of the project

Do differently

• Document bugs for features that were considered "accepted"
• Use unit testing for validating bug fixes and other changes to previously accepted stories

Puzzles

• Dropzone.js (file upload) was used but it did not offer Angular support and integration, making it hard to accurately predict how much more work was needed.

Iteration 3

Did well

• Team is following the same coding standards
• Continuous integration
• The project structure and documentation have been properly maintained
• Added unit tests and automated the testing process

Do differently

• Unit tests have been added to the project but we should do even more

Puzzles

• How will the high number of exterior projects affect the group’s efficiency?
• There’s a big backlog of user stories, the scope of the project will have to be reavaluated, what will be sliced from the final product?

Iteration 4

Did well

• Team is following the same coding standards
• Continuous integration
• The project structure and documentation have been properly maintained
• Current product state promises a successful release

Do differently

• Improve task distribution among the team
• Be more careful prioritizing user stories

Puzzles

• What remaining features to focus on for the final delivery?

Connecting the dots: A personal post-mortem about the project

by Ruben Cordeiro

There’s a famous quote by Steve Jobs that says “You can't connect the dots looking forward; you can only connect them looking backwards.”, this statement is a good reminder for project management.

When we planned the iterations, we planned for the best case scenario: maximum productivity, no bugs, no setbacks.

What ultimately happened was that the number of setbacks was much higher than the expected: four members have enrolled in part time jobs and the scrum master was hospitalized for three weeks.

When scheduling and planning projects, we have to start thinking about possible setbacks, and most importantly, we have to start managing our expectations more tightly.

Ditching the traditional SQL for Neo4j and other mature frameworks in favour of NodeJS with HapiJS for the server and AngularJS for the client was a bold move. We believe that it will pay off in terms of scalability and responsivity for the client, but the truth is that the end user won’t notice some of our efforts. What he will notice however is the lack of features.

We are at a tipping point: the scope of the project has to be reavaluated and some features will have to be sliced from the final product. We are only connecting the dots now and we have learned important lessons in the process.

Links

• This Wiki
• Git Repository
• Pivotal Tracker
• Website
• Promotional Page