# Lisp Mortgage Calculator Proto with JSON

I’ve finally found a house! Like many Googlers from Cambridge I will be moving to Belmont MA. With that being said, I have to get a mortgage. My wife noticed we don’t know much about mortgages, so she decided to do some research. I, being a mathematician and a programmer, decided to make a basic mortgage calculator that will tell you how much you will pay on your mortgage per month, and give you an approximate amortization schedule. Due to rounding it’s impossible to give an exact amortization schedule for every bank.

This post should explain three things:

1. How to calculate your monthly payment given a fixed rate loan.
2. How to create an amortization schedule.
3. How to create an easy acceptor in Hunchentoot that takes either application/json or application/octet-stream.

## Mathematical Finance

The actual formulas here come from the Pre Calculus for Economic Students course my wife teaches. The book is:

Applied Mathematics for the Managerial, Life, and Social Sciences, Soo T. Tan, Cengage Learning, Jan 1, 2015 – Mathematics – 1024 pages

With that out of the way we come to the Periodic Payment formula. We will assume you pay monthly and the interest rate is quoted for the year but calculated monthly.

Example:
Interest rate of 3%
Loan Amount 100,000$First Month Interest =$100,000*(.03/12) = $100,000*.0025=$250.

$MonthlyPayment = \frac{LoanAmount * \frac{InterestRate}{12}} {1 - (1 + \frac{InterestRate}{12})^{NumberOfMonths}}$

I am not going to prove this, though the proof is not hard. I refer to the cited book section 4.3.

With this we can compute the amortization schedule iteratively. The interest paid for the first month is:

$I_{1} = LoanAmount * \frac{InterestRate}{12}$

The payment toward principal for the first month is:

$PTP_{1} = MonthlyPayment - I_{1}$

The interest paid for month j is:

$I_{j} = \frac{InterestRate}{12}*(LoanAmount - \sum_{i=1}^{j-1}PTP_{i})$

The payment toward principal for month j is:

$PTP_{j} = MonthlyPayment - I_{j}$

Since $I_{j}$ relies on only the $PTP(i)$ for$0 and $PTP_{1}$ is defined, we can compute them for any value we wish!

## Creating the Mortgage Calculator

We will be creating a Huntchentoot server that will receive either JSON or octet-stream Protocol Buffer messages and return either JSON or octet-stream Protocol Buffer messages. My previous posts discussed creating Hunchentoot Acceptors and integrating Protocol Buffer Messages into a Lisp application. For a refresher please visit my Proto Over HTTPS.

### mortgage.proto

When defining a system that sends and receives protocol buffers you must tell your consumers what those messages will be. We expect requests to be in the form of the  mortgage_information_request message and we will respond with mortgage_information message.

Note: With the cl-protobufs.json package we can send JSON requests that look like the protocol buffer message. So sending in:

{
"interest":"3",
"loan_amount":"380000",
"num_periods":"300"
}

We can parse a mortgage_information. We will show how to do this shortly.

### Server Code:

There are two main portions of this file, the server creation section and the mortgage calculator section. We will start by discussing the server creation section by looking at the define-easy-handler macro.

We get the post body by calling (raw-post-data). This can either be in JSON or serialized protocol buffer format so we inspect the content-type http header with

If this header is “application/json” we turn the body into a string and call cl-protobufs.json:parse-json:

(let ((string-request
(flexi-streams:octets-to-string request)))
(cl-protobufs.json:parse-json
'mf:mortgage-information-request
:stream (make-string-input-stream
string-request)))

Otherwise we assume it’s a serialized protocol buffer message and we call cl-protobufs:deserialize-from-stream.

The application code is the same either way; we will briefly discuss this later.

Finally, if we received a JSON object we return a JSON object. This can be done by calling cl-protobufs.json:print-json on the response object:

(setf (hunchentoot:content-type*) "application/json")
(let ((out-stream (make-string-output-stream)))
(cl-protobufs.json:print-json response
:stream out-stream)
(get-output-stream-string out-stream))

Otherwise we return the response serialized to an octet vector using cl-protobufs:serialize-to-bytes.

## Application Code:

For the most part, the application code is just the formulas described in the mathematical finance section but written in Lisp. The only problem is that representing currency as double-precision floating point is terrible. We make two simplifying assumptions:

1. The currency uses two digits after the decimal.
2. We floor to two digits after the decimal.

When we make our final amortization line we pay off the remaining principal. This means the repayment may not be the repayment amount for every other month, but it removes rounding errors. We may want to make a currency message for users to send us which specifies its own rounding and decimal places, or we could use the Google one that is not a well known type here. The ins-and-outs of currency programming wasn’t part of this blog post so please pardon the crudeness.

We create the mortgage_info message with the call to populate-mortgage-info:

(let (...
(response (populate-mortgage-info
(mf:loan-amount request)
(mf:interest request)
(mf:num-periods request)))) …)

We showed in the previous section how we convert JSON text or the serialized protocol buffer message into a protocol buffer message in lisp memory. This message was stored in the request variable. We also showed in the last section how the response variable will be returned to the caller as either a JSON string or a serialized protocol buffer message.

The author would like to thanks Ron Gut, Carl Gay, and Ben Kuehnert.

## 5 thoughts on “Lisp Mortgage Calculator Proto with JSON”

1. Out of curiosity, what’s your planned use-case for the server?

Like

1. It’s just a proof of concept to explain cl-protobufs.

Like

2. Joshua Kordani says:

What do you use on the frontend to send protobufs to this? protobufs in javascript and you host a webpage? Or a cli that builds and sends protobufs?

Like

1. I have no front end atm. I test with Postman for javascript and i use drakma to make a cli utility for lisp.

Like