Todo-Backend
a shared example to showcase backend tech stacks
The Todo-Backend project defines a simple web API spec - for managing a todo list. Contributors implement that spec using various tech stacks. Those implementations are cataloged below. A spec runner verifies that each contribution implements the exact same API, by running an automated test suite which defines the API.
The Todo-Backend project was inspired by the TodoMVC project, and some code
(specifically the todo client app) was borrowed directly from TodoMVC.
Created and curated by Pete Hodgson.
.NET 6 / Clean Architecture
This is an implementation of the todobackend to demonstrate (or even use as a template) for .NET Clean Architecture projects.
Perl / Catalyst
todo backend implemented with perl and Catalyst. Backed with a plain file on disk.
Perl / Mojolicious
todo backend implemented with perl and mojolicious. Backed with a plain file on disk.
Perl / PEF::Front
todo backend implemented with perl and PEF::Front. web framework, saving todos to a Postgres DB.
Ruby / Sinatra
A simple ruby implementation using the lightweight Sinatra web framework, saving todos to a Postgres DB.
Ruby / Grape
A Ruby implementation using Grape.
Rust / Iron
A Rust implementation using Iron with a thread-safe in-memory repository
Rust / Rocket
A Rust implementation using Rocket.
Node.js / Azure Functions / Azure SQL
Todo backend implemented with Node and Azure Functions. Database is Azure SQL.
Node.js / Express
Node.js + Express, saving to Postgres. Courtesy of Daniel Tao.
Node.js / Express / JS-CSP
Node.js + Express + JS-CSP (an alternative to Promises and callbacks), saving to Postgres. Courtesy of Andrew Kiellor.
Node.js / Express / Knex.js
Node.js + Express + Knex (query builder configured to save to Postgres). Implementation uses async/await. Courtesty of Tony Cheang.
TypeScript / Node.js / Hapi.js
Node.js example using the Hapi framework and saving to memory.
Node.js / Micro / Postgres
Node.js example using the Micro framework.
Python / web.py
A simple Python implementation using web.py. This implementation "cheats" by just storing todos in memory in a Dictionary globalton.
Python / Django
A database-backed Django implementation courtesy of Mihir Khatwani.
Vanilla Rails
A simple Rails implementation courtesy of Derek Hammer.
Java 8 with Spring 4 Boot
A version using Spring 4 Boot + Java 8 from Jefferson Santos.
Java 7 and Spring MVC
Java 7 and Spring MVC implementation using the Java 1.7 and Spring MVC. Deployed to Heroku using a Tomcat runner.
Jersey2 with RDF for data storage
A version using Jersey2 with Sesame RDF for data storage from Michael Leuthold.
Golang / Gin
A Golang implementation using the Gin web framework, courtesy of Matt Ho.
Scala / Lift
A Scala implementation using the Lift framework. This implementation uses a thread-safe in-memory store. Courtesy of Riccardo Sirigu.
Scala / Finatra
A Scala implementation using Twitter's Finatra web framework. Courtesy of the prolific Matt Ho.
Kotlin / Http4k
Kotlin + http4k with typesafe lenses, saving in-memory.
Kotlin / Ktor / Koin
Implementation using Kotlin, Ktor and Koin, saving in-memory.
SWI-Prolog
SWI-Prolog 7 implementation using the Prolog database with persistency. Extensively documented.
F# - Freya (OWIN)
F# with Freya implementation using the Freya F# OWIN wrapper and an in-memory store built with an F# `MailboxProcessor`.
Java Spring 4.0 and MongoLab DbaaS
Java Spring MongoLab DbaaS implementation using the Java 1.7, Spring 4.0 and MongoDB using MongoLab's database as a service.
Vert.x 3 and Redis backend
A Java implementation using Vert.x with Redis backend. Deployed on OpenShift. By Eric Zhao
F# - Frank
F# with Frank implementation using Frank, a minimal combinator library built on top of System.Net.Http
types in F#, hosted via OWIN, and using an in-memory store built with an F# `MailboxProcessor`.
Java with Dropwizard
Simple implementation with Java + Dropwizard from Dan Siwiec.
Golang / stdlib
A Golang implementation using only the standard libraries
Golang / stdlib / Makefile
A Golang implementation using only the standard libraries
F# - Suave
A simple implementation using Suave
Scala - Play!
Scala implementation on the Play framework backed by Postgres
Elixir - Phoenix / Postgres
Elixir implementation using the Phoenix Framework backed by Postgres. Deployed to Heroku using the Elixir buildpack. Courtesy of Jeff Weiss
Java - Axon + Spring Boot
Implementation using Axon, a Java CQRS framework, + Spring Boot. This version "cheats" by storing todos in an in-memory repository. By Ryan Oglesby
Python / Flask
Implementation written in Python with Flask.
Haskell - Scotty / Persistent
Haskell implementation using Scotty.
Haskell - Servant / Persistent
Haskell implementation using Servant.
Haskell - Snap / Persistent
Haskell implementation using Snap.
Haskell - Spock / Persistent
Haskell implementation using Spock.
Haskell - Yesod / Persistent
Haskell implementation using Yesod.
Rust / Rustful
Rust implementation using Rustful.
PHP / Symfony2
PHP implementation with Symfony2.
Slim 3 / Spot
PHP implementation with Slim 3 and Spot.
Scala / Finch
A Scala implementation using Finch for web and Circe for JSON.
Scala / endpoints4s / Swagger
A Scala implementation using endpoints4s to also describe the API with Swagger UI.
Under the hood: http4s and doobie.
Swift / Kitura / CouchDB
A Swift implementation using Kitura for web.
Swift / Vapor
A Swift implementation using Vapor for web.
Scala - Play 2.5 / Postgres
A Scala implementation using Play 2.5 with persistance in Postgres using Anorm. By Jorge Lee.
Spincast Framework ~ In memory
In memory implementation using Spincast.
Crystal / Kemal ~ In memory
A Crystal implementation using Kemal.
Scala / http4s (in-memory)
A Scala and http4s implementation with an in-memory store
Rails 5 API-only
A Rails 5 API-only implementation with MongoDB Backend.
Java 8 / Ratpack
A Java 8 implementation using the Ratpack framework, using H2 for persistance
Jooby / In memory
Jooby implementation using with an in-memory store
Java 8 / Spark / JDBI
A Java 8 implementation using the Spark framework. Persistance to Postgres using JDBI.
C# - ASP.NET Core
A C# implementation using ASP.NET Core with Docker support and in-memory or SqlServer persistence. Implements CQS using the Brighter and Darker frameworks.
PHP / Lagan
PHP implementation with Lagan.
Azure Functions - C#, F# and JavaScript
Azure Functions implementation with functions written in C#, F# and JavaScript. Uses Azure Table Storage for persistence.
Ruby / LittleBoxes
A Ruby implementation using LittleBoxes.
mangoo I/O / jOOQ / H2
A Java 8 implementation using the Mangoo I/O framework, jOOQ for database access and H2 in-memory database.
Ceylon / gyokuro
A Ceylon implementation using the gyokuro framework.
Kotlin / Spring Boot 2 reactive with annotation
Simple implementation using Spring Boot 2 (reactive web) and with Kotlin, saving todos in-memory.
Kotlin / Spring Boot 2 reactive with router
Simple implementation using Spring Boot 2 (reactive web) and with Kotlin, saving todos in-memory. Setup is done via the router API
Kotlin / Spring Boot 2 reactive with mongodb
Implementation using Spring Boot 2 (reactive web) and Kotlin. Data source is mongo
Kotlin / Spring Boot
Implementation using Kotlin and Spring Boot. Items are stored in memory.
Kotlin / Javalin
Implementation using Kotlin and Javalin. Items are stored in memory.
Kotlin / Ktor
Implementation using Kotlin and Ktor. Items are stored in memory.
C# - ASP.NET Core 2.0
A simple C# implementation using ASP.NET Core 2.0 with a Docker image and in-memory persistence. Only depends on the standard Microsoft.AspNetCore.All package.
PHP / Laravel
PHP implementation using Laravel and a MySQL database
Java / Jodd
Java 8 implementation using Jodd 4.
XCST - ASP.NET
An XCST implementation for ASP.NET. Items are stored in memory.
Java with NutzBoot
Implementation using Nutz Boot by wendal. Items are stored in memory.
F# - Giraffe
Implementation using Giraffe in F# by mabe. Items are stored in memory.
Java 8 with Java EE 8
Java 8 implementation running on the Java EE 8 compatible Payara Micro as a microservice. ToDos are in-memory.
Ruby / Hanami
A Ruby implementation using Hanami.
Java 11 / Spark / JDBI / no annotations
A Java 11 implementation using the Spark framework. Persistence to Postgres using JDBI. No Java annotations.
Scala / ZIO, http4s
Todo-Backend (https://www.todobackend.com/) implementation using ZIO, http4s and circe
Pharo / Seaside
Implementation for the todo backend using Pharo and Seaside.
Java / Micronaut
Implementation using Micronaut. Items are stored in memory H2.
PHP / CakePHP 4
PHP implementation with CakePHP 4.
Kotlin / Hexagon, MongoDb
Implementation using Kotlin and Hexagon saving items to a mongoDb database
ASP.NET Core 3.1 / Couchbase
A todo backend written in C# with ASP.NET Core 3.1 and Couchbase Server 6.5 as a backend.
R / Plumber
A todo backend written in R with Plumber.
Javalin / Java 11
A Java 11 implementation using the lightweight and fast Javalin framework.
Quarkus
A Quarkus implementation using the Quarkus framework. RESTEasy/JAX-RS and JSON-B extensions and Persistence to Postgres using Hibernate ORM with Panache extension PANACHE.
Node.js / NeDB / Express
Nodejs using embbeded database NeDB. Feel free to follow Mauricio Lobo.
Erlang / Cowboy
Erlang implementation using cowboy framework and mnesia for storing data
Golang / Go kit / GORM
An example implementation with Go kit, GORM and PostgreSQL.
Clojure / Reitit / next-jdbc
A simple Clojure implementation storing to Posgres DB via next.jdbc courtesy of Mike Salihi.
Golang / mux / buntdb
A Go implementation using mux and BuntDB.
{YOUR IMPLEMENTATION HERE}
It's very simple to build your own Todo-Backend implementation. It shouldn't take more than a few hours. Read more.