Code crafted with care.
We Love Building Software
...so if you have great ideas, let's make them happen!
FREE introductory audit of your project's codebase & architecture!
Audits may cover:
- Code Quality
- Automated Testing
- User Experience
- Full Platform Support
- Throughput & Scalability
- Data Integrity
Our clients work onsite in New York City or remotely. Here at Evaluates2 we can provide a full development team or individual engineers!
During our initial consultantions we will work with you to determine the optimal number of Evaluates2 engineers to have on your team based on your current team and the project scope, timeline, and budget.
When Evaluates2 engineers are integrated into other teams they can lead by example and improve the code from every other engineer.
By instilling expert-level practices in things such as automated testing and deployment strategies, Evlauates2 engineers can act as an unbiased third-party to keep engineering teams honest and disciplined in their development practices.
We're a test-obsessed team of polyglot engineers who strive to always use the best tools for the job. We specialize in functional programming, building beatifully interactive UIs, and putting up lean, lightning fast microservices all with an outside-in TDD approach.
Below we have a list of our favorite programming languages, a short description of where each one shines, a snippet of code that solves the Fizzbuzzify String challenge, and some nice unit test cases for the function!
- Clojure / ClojureScript
- Go Lang
(Please hover over or select a choice below)
We'll Use The Right Tech For YOUR Business.
Choose Your Own Tech Stack Trio!
The tech stack for any of our software projects generally includes a front-end, back-end, and a database. There are many options from which to choose, and if you are at all unsure we can help you decide which combination should fit best for your team and product. Of course these are not fully exhaustive lists of all possible front-ends, backends, and databases, but these are the core competencies of the current Evaluates2 team!
- Angular (TypeScript)
- Reagent (ClojureScript)
- Rocket (Rust)
- Native Ios (Swift)
- Native Android (Kotlin)
- Ruby on Rails
- NodeJS (Express + TypeScript)
- NodeJS (Websockets)
- TypeScript (Express + TypeScript)
- TypeScript (Websockets)
- JVM Clojure (Pedastal or Ring)
- JVM Clojure (Serverless)
- ClojureScript (Serverless)
- ClojureScript (Websockets)
- Go (Revel)
- Go (Serverless)
- Go (Websockets)
- Java (Spring / Spark)
- Java (Serverless Java)
- Java (Websocket Streams)
- Python (Python Flask / Django)
- Python (Serverless Python)
- C# (with NancyFx)
- C# (Serverless C#)
- Google BigTable
- Amazon Aurora
Continuous Integration & Multiple Environments
The Use of Continuous Integration and Multiple Environments
Each time an engineer makes a substantial change he or she will commit this change to GitHub (or the repository hosting service of your choice). Here at Evaluates2 we prefer to employ automated continuous delivery processes whereby any changes in GitHub (to specially designated branches) are detected at which point all builds are done, various automated tests are run, etc. If any step fails, all developers are notified immediately so that a fix can be made. After all commands exit successfully the continuous delivery system will then deploy these new changes directly to the staging environment.
Here at Evaluates2 we prefer to maintain three environments when building applications: development, staging, and production. Development is connected to automated continuous deployment and should be rapidly changing. Staging is the "pre-release" environment where we a human can give a final check over of things before pushing to prod. Production is the live user-facing application environment! Code will finally be deployed here if all automted tests are passing and a QA engineer has given the "ok" for the new features / bugfixes in staging environment.
Test Driven Development
The Importance of Test Driven Development (TDD)
Here at Evaluate2 we have several core values that we insist on when working with a client, and one of those core values is the use of test-driven development. Test Driven Development, or "TDD" for short, is a software development process that builds up a suite of automated tests alongside the software source code. These tests run continuously to quickly ensure proper functionality and to reduce the presence of bugs.
In our opinion, testing is paramount for the future success of your project, and your future success is our main priority. By working in small red-green-refactor cycles we can be confident that our tests are passing only when they should be passing, and depending on the project we utilize a wide variety of automated tests including unit testing, end-to-end testing, UI testing, Behavior-driven testing, load testing, and smoke testing. We also prefer to take an outside-in approach where we begin with cucumber bdd tests whose step definition are mapped to UI tests (or end-to-end tests calling our routes for beckend REST server projects). We then try to make these tests pass by writing the implementation code with unit tests in a TDD fashion.
Keeping a Project Robust & Fresh
Third-party libraries are great to use, but there are a few considerations that must be carefully considered. Our engineers can help guide decision making in library selection and provide support for upgrading old libraries to newer versions.
After years of development most large project will have significat amounts of technical tebt. Maybe the engineers just couldn't get those automated tests to work so they abandoned the pracice, or maybe the project works but there are tons of annoying warnings in the console. With the expertise from an Evaluates2 engineers these kinds of problems can be quickly addressed, the necessary modifications can be made, and your project can be reborn and as one that is a joy for users and developers alike.