Wednesday, July 5, 2017

Why guess when you can measure?

Think of this as a draft.  I'm trying to test out and discover my thoughts here on guessing versus measurement:

I think that your profession can affect the way that you think and interact with people in your every day life.

For example, my mother was trained in analytical chemistry and did a fair amount of work for her doctorate as a C++ coder.  Conversing with her was (and still is) always fun.  But there was one pattern kept popping up in our conversation that took me some time to adapt to: if I ever asked my mother to guess at something, she would refuse to do it.  Why guess at a quantity?  The appropriate response to an empirical question is to make a measurement or look up a previous measurement.

Of course, I then went into physics where the art of guessing is honed and celebrated.  I learned to use dimensional analysis and to do back-of-the-envelope calculations.  I learned to calculate lower bounds and upper bounds.  I learned to estimate my probable error in terms of factors of 2 or 10.  This training made the difference between my mother's refusal to estimate and my love of estimating stronger.

But while I was completing my doctorate and then during my post doctorate and as a full scientist, two things happened.  First, I started to move from theoretical physics to applied physics.  I started working on material science problems.  Just as importantly, I began to spend more and more time coding. 

 In our material science applications, guessing was worth while.  But it was always based on simplifying assumptions.  So guessing was just a first stab.  Truth would reveal itself as we actually performed experiments.

If you were guessing, you might guess that programming would be one place where theory and practice are the same.  The computer does what you tell it to do, no?

In practice, programming is an experimental science.  You write code and then you check to make sure that it does what you hoped it would.  You make a guess, and then you check that guess.  If it was wrong, you tweak things and try again.

In other words, a programmer is constantly applying the scientific method.  They form a hypothesis.  Then they check that hypothesis.  They form a new hypothesis and test that one.

So both scientists and coders are professional practitioners of the scientific method.  The difference is that coders perform many iterations of the method per hour.  Scientists, because they're interacting more closely with nature, are often forced to iterate much, much more slowly.

But the power of both science and programming is that they tell you when you're wrong.  And you find out that you're wrong, or at least missing part of the picture, often.  In programming it might be 100 times a day or more.  If learning that you're wrong 100 times a day and then going back to fix the issue doesn't teach you mental humility, what does?

I actually still believe in guessing, but not as the right way to answer questions.  Guessing is powerful as a way to measure your current state of knowledge.  If you make a measurement without a guess, then you can't be wrong.  And being wrong helps you learn.  So oddly I believe in guessing as a way to find out if you're wrong.

Fine.  But what does being wrong all the time have to do with BrightHike?

BrightHike is built upon the assumption that we can and will be wrong.  It's built on the idea that assumptions need to be checked.

In other words, rather than assume that a person is at a certain point in their understanding, test that.  Rather than assume that a video helps someone understand a particular concept, test its effectiveness.  Every interaction gives us information about our system and about where the user is.  Every interaction can be used to check our assumptions and improve our process.  Rather than assume that a best practice is a best practice, find out. 

Monday, July 3, 2017

The end user is your real customer

I've just been listening to Aaron Levie of Box.com speak about how his team has been approaching working with enterprise software.  One element stuck out to me in the context of building educational products.  He said that his team has had a rule that if there's ever a choice to be made between meeting enterprise requirements and pleasing the end user, they've prioritized the end user, even if it meant turning down millions of dollars:

http://www.youtube.com/watch?v=qRt7mFuKwQY&t=39m49s

This addresses one of my biggest concerns with the idea of working with schools or governments as opposed to individual families.  If you optimize for someone who isn't the end user, you end up gradually with a crummy product that focuses on the wrong thing.  But with a web-based system, you naturally have a direct connection with the end user.  You can see how engaged they are.  You can see what they're spending time on and what's working and not.  So maybe now it's possible to make an end run around optimizing your product for the wrong thing will still selling at an enterprise level.


Thursday, June 29, 2017

The hardest thing about going it alone

is that there's no one to report to.

So I think it's time to get some real customers.  Maybe I can report to them.

Wednesday, June 28, 2017

The BrightHike Stack 2017-06-28: heroku > python/django/graphene > react/redux

I started working on BrightHike, a machine learning enhanced math education plateform, on March 1st, 2017.  My last project was a Heroku/Django/Angular combination, which left me with a desire to explore a bit on the front end :-D.

Here's what the BrightHike stack currently looks like, back to front.

The back end service is Heroku, where I have a Python 3.6/Django1.11 setup that uses Heroku's built in Postgres service for persistance.  I use the Django Rest Framework for authentication, but rather than a Rest API, I use Graphene, a python implementation of GraphQL for most API querries.

Using GraphQL instead of a Rest API has been a change, but a great one.  It has allowed me to adjust the granularity and scope of a given request on the fly.  In that way it's saved a lot of code on the Python side.

There are two different front end apps, a web app and a mobile app.

I run the web app as a static app that reaches out to the back end for dynamic behavior.  The up side for this is that it makes it simple to cache the front end.  the down side is that it leaves out server side rendering.  It's possible to do some static rendering for React apps, but I haven't worried about that yet.

The web app is a standard React app, not yet even ejected from the create-react-app environment.  I'm using Redux for state management and my own twist on Ducks for organization.

The mobile app is still an unejected create-react-native-app app, which is nice for fast iterations.

The biggest changes to my setup recently have been to incorporate prettier for automatic formatting on save, and styled-components for nice in-javascript CSS handling.  I'm enjoying both a lot although I'm still working on getting my CSS architecture settled.


Tuesday, June 27, 2017

Doing and talking are friends

Doing and talking are friends.


Doing without talking is weak because you don't share with or learn from other people.

Talking without doing is weak because it cannot give you a detailed or realistic understanding of the problem space that you are entering.  It also lacks the credibility that only comes from doing.

When you actually work on a problem that you are talking about, or when you actually talk about a problem that you are working on, then doing can ground talking and talking can inform doing.  It's a powerful combination.

I've been silent for too long

I began working full time on BrightHike, a math education App, since March 1st, so for almost four months and I've shared almost nothing about it.  I've gradually realized that this approach is insane for that's important to me.

So here's to talking.  Until tomorrow!

Absorb as much of the customer's risk in giving you a chance as possible

Nice advice from Hacker News today: MasterScrat 2 hours ago [-] I am working on a ...