Next.js Blog Theme

Jay Doe


# Overview

I've always planned my finances in a spreadsheet, which works extremely awesomely (because spreadsheets rule) 
until it doesn't, and it becomes unworkable to update and 'branch' with different options.  I've done lots of
fits and starts and making a software package to do the same and this is the next one.

# What the software should do 
My spreadsheet normally works like this:

First column is a running month/year column, with a row for each month. Each subsequent column has running totals for these months

## Net Worth
A section of columns for net worth.. total net worth, then broken down by (Property, Liquid, Retirement, Debt)

## Income

A section of columns for income, my takehome, my wife's takehome, and other income rolled up

## Spend allocation
A break down of how that takehome gets allocated:

1. A configured 'discretionary' spend - this is basically a lump value for month budget not including 'non-discretionary' spend, i.e. debt servicing, required mortgage payments, etc
2. A total 'non-discretionary' spend - this is the sum of all the non-discretionary spend, which is broken down in other sections

## Surplus allocation  
A breakdown of surplus allocation according to some strategy I have encoded, for example I've had schemes such as:

    - Prioritize paying off my HELOC (variable APR) up to some maximum amount per month, then put everything in taxable brokerage 
    - Prioritize paying into my 529 for 6 months, then back to paying off HELOC, then put everything into taxable brokerage from then on

## Example Scenarios
Here are some scenarios I have used this for
- Simple check in on whether our family budget is going to lead us to our goals
- Consider big financial decisions such as job changes, 429 investments, decide on things like prepaying a mortgage vs investing in a taxable account, how much to put in tax deferred retirement accounts
- Using net worth at target dates along with target retirement dates and target retirement spend to see how things go

## What didn't work well
- Adding new accounts - e.g. what if we bought a second property
- Visibility into where the money was going without reading and holding all formulas in your head
- Debugging errors
- Explaining the results to my wife
- No modeling of taxes, makes that hard to compare
- Inflation sort of washed out, not sure that is valid


# So here's what I want 
A projection system that lets me configured my current accounts, mortgages, investments, etc, then projects network at different times in the future.  I want to be able to make different projections where one is a copy of the other but with some changes, and see the different outcomes easily (graphically)

# User-Facing Conceptual Model

## Accounts

### Income Accounts
- Represents different sources of income

#### Named Monthly Income
- Have a set amount
- Start and stop on different days,
- Have a growth function
    - constant rate 
    - based on a defined time curve (later functionality)

### Spend Accounts
- Represent accounts of spending such as discretionary budgets, mortgages,
current lines of credit 

#### Named Monthly Spend
- Have a set amount
- Start and stop on different days,
- Have a growth function
    - constant rate 
    - based on a defined time curve (later functionality)

### Asset Accounts
- Values contribute positively to Net Worth
- May appreciate or not

### Liability Accounts
- All liability account balances count negative to Net Worth
- Can have a Lien on an Asset

#### Lien
- A lien is an attachment of a liability to an asset that requires the liability
to be paid off when the asset is liquidated

#### Mortgage
- Debt Balance
- Interest Rate 

# Game Loop

## Generate Income 

## Generate Spend

## Allocate Excess Spend
TODO How??
Ideas..

### Idea 1
"SpendAllocationConfig" - list of &#123; account, constraints &#125; in order of priority?

constraints are like MaxAmount, MinAmount, for network

Allocate min amounts first, by order priority, then allocate to accounts in order of list, respecting max amount





# Thoughts

Both asset accounts and liability accounts can be drawable, e.g.
- A HELOC can be drawn on
- A Checking/brokerage account







# Model Architecture

A system to project finances, layering different accounts, constraints and strategies

Financial Planner


This will be the first in my project to build a wide variety of common distributed infrastructure platforms, 
more or less from scratch, and explore what is needed to make them scale to small, large, super large, crazy large, and 
[web-scale](https://www.youtube.com/watch?v=b2F-DItXtZs).

# Problem Statement

We want to build a distributed key-value cache which can serve as the backing cache for a large
number of upstream clients, e.g. a cluster of application services. A Key-value cache meaning given a key, 
we return a value. For simplicity, let's start with the idea that the key and value are both strings. Therefore we simply need a service which supports the
following APIs:

`POST /<key>` with a body containing the value

`GET /<key>` returns the value stored by the above call or 404

## Non-Functional Priorities

1) **Fast Reads** - the primary feature for the service is to return responses 
for reads as fast as possible. Write speed is important but a second priority to fast returns. 
2) **Highly Available** - the service should be highly available. Ultimately a cache is
technically optional, however in practice a cache going down can result in cascading
problems that bring down the authoritative system. Therefore availability is a top concern.  
3) **Highly Scalable** - the service should support the ability to scale up to a very large
number of clients as mentioned in the problem statement. It should also scale up
to a large number of keys.. how large? TBD.

## Non-Functional Tradeoffs
1) **Consistency** - the service should be somewhat consistent, but not at the expense of speed. 
As a result it will not be *strongly* consistent, meaning it will be possible for a PUT
followed by a GET to return the old value of a key.  
2) **Durability** - Similar to the consistency issue, there are failure modes
where data may be lost when unreplicated data exists in a cache and the node
fails.

# Single Node Architecture
//single process that serves as cache
//periodic flush-to-disk for durability
//Questions to answer
// what makes it fast?
//  - in-memory caching
//  - write-back policy reduces write latency
// what makes it available? 
// what makes it scalable?
// how fast is it, how does that change 
// for different levels of request scale?

// what is the limiting factor for concurrent request scale?
// what is the limiting factor for key scale?
// what is the limiting factor for single-request speed?
    // how does that change for multiple requests?
// how much does this cost?




The first installment of the Let's Build series - a distributed key-value cache

Let's Build A Distributed Cache


Something has always existed. According to physics, there can never be true physical nothingness—though there can be times when existence resembles nothing, such as a vacuum (the state of minimum possible energy) (Phys.org). Creating a space where there are no quantum fluctuations requires an enormous amount of energy, and there would be a remnant of that energy in that space afterwards if the fluctuations were flushed out, plus an unstable environment (1veritasium). Even on computers, deleted data is not actually tossed away, by rather written over.

# h1 Heading

## h2 Heading

### h3 Heading

#### h4 Heading

##### h5 Heading

###### h6 Heading

## Horizontal Rules

---


## Emphasis

**This is bold text**

**This is bold text**

_This is italic text_

_This is italic text_

~~Strikethrough~~

## Blockquotes

> Blockquotes can also be nested...
>
> > ...by using additional greater-than signs right next to each other...
> >
> > > ...or with spaces between arrows.

## Lists

Unordered

- Create a list by starting a line with `+`, `-`, or `*`
- Sub-lists are made by indenting 2 spaces:
  - Marker character change forces new list start:
    - Ac tristique libero volutpat at
    * Facilisis in pretium nisl aliquet
    - Nulla volutpat aliquam velit
- Very easy!

Ordered

1. Lorem ipsum dolor sit amet
2. Consectetur adipiscing elit
3. Integer molestie lorem at massa

4. You can use sequential numbers...
5. ...or keep all the numbers as `1.`

Start numbering with offset:

57. foo
1. bar

## Code

Inline `code`

Indented code

    // Some comments
    line 1 of code
    line 2 of code
    line 3 of code

Block code "fences"

```
Sample text here...
```

Syntax highlighting

```js
var foo = function (bar) {
  return bar++;
};

console.log(foo(5));
```

## Tables

| Option | Description                                                               |
| ------ | ------------------------------------------------------------------------- |
| data   | path to data files to supply the data that will be passed into templates. |
| engine | engine to be used for processing templates. Handlebars is the default.    |
| ext    | extension to be used for dest files.                                      |

Right aligned columns

| Option |                                                               Description |
| -----: | ------------------------------------------------------------------------: |
|   data | path to data files to supply the data that will be passed into templates. |
| engine |    engine to be used for processing templates. Handlebars is the default. |
|    ext |                                      extension to be used for dest files. |

## Links

[link text](http://dev.nodeca.com)

[link with title](http://nodeca.github.io/pica/demo/ "title text!")

Autoconverted link https://github.com/nodeca/pica (enable linkify to see)


Something has always existed. According to physics, there can never be true physical nothingness—though there can be times when existence resembles nothing, such as a vacuum (the state of minimum possible energy) (Phys.org). Creating a space where there are no quantum.

Next.js Blog Theme

Financial Planner

Let's Build A Distributed Cache

How to create SVG-ready icon symbols in Sketch PART 2