Twelve days before Christmas 2017, Otto LLC, a company that wanted to produce smart locks, shut down with little notice. Employees were given no severance and contractors were left with tens or hundreds of thousands of dollars in unpaid invoices. This incident was widely covered in the press, and one board member has since quit the venture capital industry.

Otto has sold all of their assets to a company that specializes in liquidation and is now going through an "assignment for benefit of creditors."

I am not a lawyer and this is not legal advice, but that said, here is how this works at a high level. Everyone submits their claims to the Assignee. These claims have different levels of priority; people who lent money to the company have one priority, people who are owed money for services have a different priority, people who own shares in the company have a different priority. Generally, all of the claims at one priority are paid out before proceeding to the next class.

The Assignee is required to post notice in a newspaper, that's it - they don't have a requirement to notify you personally. I found the address for submitting claims, though. If Otto owes you money, go here to submit your claim: https://fileaclaim.info/Otto-ABC. You have until November 2, 2018.

Yes, that is the real URL.

I wish you the best of luck, however, I fear that there is not very much money left to pay claims, so you might not get very much. Still, a little bit is better than nothing.

If there are any questions I can answer for you, or if there's anything I can help you do to find a new position, please get in touch.

Liked what you read? I am available for hire.

Belmont is finalizing plans to build affordable housing on two parcels it owns across from the Caltrain station along El Camino Real. The proposal from the developer, LINC Housing, would construct around 20 large-family affordable units (2 and 3 bedrooms) and 20 senior housing units (one bedroom).

Belmont reduced the parking requirements for new construction last year as part of the Village Specific Plan update. The large-family units would require 1.5 parking spaces each, and the senior units would require 1 parking space each, for a total of around 50 units. It is likely this parking would have to go underground. At a cost of $60,000 per below-ground parking space, it would cost around $3 million to build all of the required parking below ground, or about 15% of the total cost of the project.

Changing transportation technology and services are already starting to cut into parking demand in some places (see this story from San Diego).

In the event that the below-ground parking becomes redundant, it will be difficult to repurpose for a more productive use. You can’t build apartments underground, and it’s unattractive space for businesses. So it would be prudent for the city to consider alternatives to building more parking than it may need.

Quite a lot of parking already exists in close proximity to the proposed sites, north of the Caltrain station across the street. A June 2017 Caltrain parking analysis indicated that just 2% of the spaces were occupied on the given weekday.

I snapped these photos of the lot at 1pm in April 2018.

What if Belmont were to enter into a parking sharing agreement with Caltrain? Caltrain could issue permits to residents of the proposed new development. Even 50 permits would not result in the lot being full, and the extra cars would mostly use the lot at night, when commuters are gone and the Caltrain lot is empty.

There is a precedent here. Caltrain and the City of Mountain View developed a shared parking agreement with a townhouse developer near the San Antonio station, as part of the San Antonio Station Precise Plan.

Using the parking lot across the street would free up about $3 million. What could Belmont do with that money? For $200,000, the city could build a HAWK pedestrian crossing at Hill St, shaving 4 minutes off the walk to the train station and the northbound ECR bus stop. This crossing is proposed in the Belmont Pedestrian Master Plan.

Further, lifting the on-site parking requirement might make it feasible to develop Site C (780 El Camino Real), which is owned by the city. LINC Housing's proposal did not include development for this site. A sloped, funky-shaped lot would be a lot easier to develop if it didn't require a parking ramp and additional driveway.

What do you think? Send your thoughts to the Belmont City Council (CityCouncil@belmont.gov), as well as the city’s project lead, Jennifer Rose (jrose@belmont.gov) and community director, Carlos de Melo (cdemelo@belmont.gov).

Liked what you read? I am available for hire.

In the middle of a housing crisis, cities up and down the Peninsula are moving forward with plans to add a ton of new office space and no new housing. These plans will add many more new commuters, without any corresponding housing for them.

• Last year the Apple Park launched in Cupertino. 2.8 million sq ft of office space (room for 18,000 workers), no new housing.

• Brisbane just put a plan for the Baylands on the 2018 ballot. 4 million sq ft of office space (room for 26,000 workers), 2200 housing units.

• South San Francisco is moving forward with Oyster Point development. 1.5 million sq ft of office space (room for 10,000 workers), 1200 housing units.

• San Francisco is moving forward with the Central SOMA Plan. 6 million sq ft of office space (room for 40,000 workers), only 7000 housing units.

• Facebook wants to add 35,000 employees in Menlo Park, with only 1500 housing units to match.

Where are all of those commuters supposed to live? No one is planning on adding housing to match the new office space being added.

We have seen this story play out already. Those rich new workers are going to want apartments near their offices, so they'll bid up the price of existing housing. This will lead to gentrification and displacement. Everyone who can't afford to do that will commute from Pleasanton, Gilroy and Stockton. This will clog 101 and the San Mateo Bridge, leading to even worse traffic.

It cracks me up when folks say "Why doesn't Google just build their next office in Bakersfield?" Your own City Councils are rolling out the red carpet to host their next office, so they can get that sweet revenue, and don't care/don't want to add any housing to match. This is what "local control" has gotten us and the results have been ruinous.

My brother and sister have already left the Bay Area. My best friend grew up 300 yards from me and now is raising his family in Savannah, GA. I'm worried I'm going to be next. All of these new developments are the world's slowest moving steamroller, driving up rent and housing prices. $3m for a home and $4,000 median rents are in our near future.

How can we turn these traffic and displacement bombs around?

• Call your Senator and Assemblymember to support SB 827, which could actually add enough new housing near transit to reverse our traffic problems and slow the explosive growth of rents.

• Support new housing in your town. The State is adding bonuses for adding new housing units, but developers are choosing not to use them, for fear of community backlash. Tonight, for example, there's a meeting about 935 homes at Concar Drive at San Mateo City Hall at 7pm, and another at Millbrae City Hall about the Serra Station project adjacent to Millbrae BART. These could use voices in support.

• If you're someone who does not benefit from a fixed rate mortgage and Prop 13, or if you are and you're worried about where your kids are going to live, consider running for City Council or applying for Planning Commission in your town. Sign up for mailing lists to get notified about new events happening: I run one (kev@inburke.com) or yimbyaction.org/sanmateo.

Liked what you read? I am available for hire.

Writing middleware in Go seems pretty easy at first, but there are several easy ways to trip up. Let's walk through some examples.

Reading the Request

All of the middlewares in our examples will accept an http.Handler as an argument, and return an http.Handler. This makes it easy to chain middlewares. The basic pattern for all of our middlewares will be something like this:

func X(h http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Something here...
        h.ServeHTTP(w, r)
    })
}

Let's say we want to redirect all requests with a trailing slash - say, /messages/, to their non-trailing-slash equivalent, say /messages. We could write something like this:

func TrailingSlashRedirect(h http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/" && r.URL.Path[len(r.URL.Path)-1] == '/' {
			http.Redirect(w, r, r.URL.Path[:len(r.URL.Path)-1], http.StatusMovedPermanently)
			return
		}
		h.ServeHTTP(w, r)
	})
}

Easy enough.

Modifying the Request

Let's say we want to add a header to the request, or otherwise modify it. The docs for a http.Handler say:

Except for reading the body, handlers should not modify the provided Request.

The Go standard library copies http.Request objects before passing them down the response chain, and we should as well. Let's say we want to set a Request-Id header on every request, for internal tracing. Create a shallow copy of the *Request and modify the header before proxying.

func RequestID(h http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		r2 := new(http.Request)
		*r2 = *r
		r2.Header.Set("X-Request-Id", uuid.NewV4().String())
		h.ServeHTTP(w, r2)
	})
}

Writing Response Headers

If you want to set response headers, you can just write them and then proxy the request.

func Server(h http.Handler, servername string) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Server", servername)
		h.ServeHTTP(w, r)
	})
}

Last Write Wins

The problem with the above is if the inner Handler also sets the Server header, your header will get overwritten. This can be problematic if you do not want to expose the Server header for internal software, or if you want to strip headers before sending a response to the client.

To do this, we have to implement the ResponseWriter interface ourselves. Most of the time we'll just proxy through to the underlying ResponseWriter, but if the user tries to write a response we'll sneak in and add our header.

type serverWriter struct {
	w            http.ResponseWriter
	name         string
	wroteHeaders bool
}

func (s *serverWriter) Header() http.Header {
	return s.w.Header()
}

func (s *serverWriter) WriteHeader(code int) http.Header {
	if s.wroteHeader == false {
		s.w.Header().Set("Server", s.name)
		s.wroteHeader = true
	}
	s.w.WriteHeader(code)
}

func (s *serverWriter) Write(b []byte) (int, error) {
	if s.wroteHeader == false {
		// We hit this case if user never calls WriteHeader (default 200)
		s.w.Header().Set("Server", s.name)
		s.wroteHeader = true
	}
	return s.w.Write(b)
}

To use this in our middleware, we'd write:

func Server(h http.Handler, servername string) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		sw := &serverWriter{
			w:    w,
			name: servername,
		}
		h.ServeHTTP(sw, r)
	})
}

What if user never calls Write or WriteHeader?

If the user doesn't call Write or WriteHeader - for example, a 200 with an empty body, or a response to an OPTIONS request - neither of our intercept functions will run. So we should add one more check after the ServeHTTP call for that case.

func Server(h http.Handler, servername string) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		sw := &serverWriter{
			w:    w,
			name: servername,
		}
		h.ServeHTTP(sw, r)
		if sw.wroteHeaders == false {
			s.w.Header().Set("Server", s.name)
			s.wroteHeader = true
		}
	})
}

Other ResponseWriter interfaces

The ResponseWriter interface is only required to have three methods. But in practice, it can respond to other interfaces as well, for example http.Pusher. Your middleware might accidentally disable HTTP/2 support, which would not be good.

// Push implements the http.Pusher interface.
func (s *serverWriter) Push(target string, opts *http.PushOptions) error {
	if pusher, ok := s.w.(http.Pusher); ok {
		return pusher.Push(target, opts)
	}
	return http.ErrNotSupported
}

// Flush implements the http.Flusher interface.
func (s *serverWriter) Flush() {
	f, ok := s.w.(http.Flusher)
	if ok {
		f.Flush()
	}
}

That's it

Best of luck! What middlewares have you written, and how did it go?

Liked what you read? I am available for hire.