Tech on Nyghtowl

Finally Diving into AI Model Evals

Sat, 19 Sep 2026 09:00:00 +0000

I’ve been asked in the past how we evaluate our AI models at Fight Health Insurance (FHI), and frankly, it was pretty bare bones, and from what other startup founders have told me, they weren’t far off from that either. We didn’t have the time or resources to dive in, and the models in 2025 weren’t at a point where they could help us out the way we needed. At the end of August I finally had the time and resources to go down the eval path.

What Does an AI Agent Need to Remember?

Thu, 03 Sep 2026 17:02:58 +0000

TL;DR: We use “memory” as a catch-all, but an AI agent needs different information for different jobs. Context gives the model what it needs for the current decision. Memory brings useful information forward. State tells the application what is true and where the work stands. Understanding those roles matters more as the agent capabilities grow and work stretches across model calls, tool calls, waits on humans and failures. The separation is a tool for clarity. You could call all of it memory; the point is that each piece needs to be handled differently, and handling them well is what makes the agent more capable.

Durable, flexible multi-agent systems

Thu, 06 Aug 2026 00:00:00 +0000

An agent system is a distributed system. You get to choose the framework and how much durability and human oversight the case demands; the tradeoffs are the part you don’t get to avoid.

For the last few months, I’ve been building one system to make that concrete: the same multi-agent fleet on Google ADK, on LangGraph, and on both at once, with Temporal as a layer underneath.

Where this started

Ziggy’s is the playful imaginary ice cream shop I cooked up to show what it looks like when a multi-agent system handles fleet delivery around Las Vegas. We announced our ADK integration and wanted a demo for Google Cloud Next. The first version showed a multi-agent team assigning deliveries and dealing with an agent or driver disconnecting mid-route. For the AI Engineer World’s Fair, the fleet relocated to San Francisco, picked up LangGraph as a second framework, and got reframed around a harder version of “recover from a disconnect”: keeping a human in the loop. Disconnecting an agent is a machine failing. Waiting on a human is a machine succeeding at doing nothing, correctly, for as long as it takes. A human isn’t a function that returns in 200 milliseconds. They answer in minutes, hours, or after you’ve already redeployed twice.

Swapping Models in the Agent House

Sat, 25 Jul 2026 17:13:21 +0000

The grief for GPT-4o was surprising and fascinating when it was removed and retired and this is not isolated to that model. It’s something that has happened with other models and there is still some sadness on when they change but maybe we are at a stage where it’s less impactful and more understood (or we are just jaded). Someone else changes the weights, and users wake up to an AI that’s suddenly a different character.

The Disagreement Was the Feature

Sun, 05 Jul 2026 16:17:08 +0000

For the last year, I’ve had a very manual AI “ensemble” ritual: ask Claude something, paste the answer into ChatGPT or Gemini, compare what changed, then carry the useful bits back by hand. I knew I could code up something better. I also kept not doing it, because laziness is real, the tooling was moving fast, and I do not always want three models involved.

For the past year, I’ve been playing around with “ensemble” model conversations, and it’s been manual pasting between chat interfaces CLIs, or switching the selected model in my IDE. I knew I could code up something better. I also kept not doing it, because laziness is real, the tooling was moving fast, and I do not always want three models involved.

A Saturday Night, Two AIs, and a Framework Nobody Planned

Wed, 08 Apr 2026 19:30:40 +0000

It was a good Saturday. Nyghtowl had a friend over, and we were picking a place for takeout, debating Thai versus Vietnamese, scrolling menus. I was pulling up restaurants nearby, comparing reviews, doing the thing where an evening starts to take shape without anyone deciding it should. We landed on a modern Thai spot in the Mission. We cycled through three shows and none of them stuck. Low effort, high flavor. Exactly the kind of night you don’t expect anything from.

AI reliability is a decade-old problem. And we’re still only solving half of it

Thu, 02 Apr 2026 12:59:04 +0000

I recently contributed this piece to Temporal’s blog and wanted to share it, too.

The AI agents being deployed today can reason through complex tasks, chain together dozens of tool calls, and operate autonomously for hours. What most of them can’t do is survive something going wrong halfway through.

Even if an agent were 85% reliable at each step, a 10-step workflow would succeed end-to-end only about 20% of the time. Scale that to the longer workflows that production agents actually run, and even strong step-level performance produces cascading failure. Not because the model got something wrong, but because the system had no way to checkpoint progress, recover from a partial failure, or resume where it left off.

From Gatekeeping to Gateway: AI and the Open Source Learning Curve

Fri, 13 Mar 2026 01:08:59 +0000

Contributing to open source has never been as open as the name suggests. Every project has its own architecture, unwritten rules, and context that lives in maintainers’ heads. Submitting your first PR is intimidating especially if you’re already underrepresented in the space. Research consistently shows women make up less 10% of open source code contributors, and participation data for many other groups remains sparse. Maintainers are often overextended and unpaid. Feedback is slow. And all of this is intensifying as open source goes global. GitHub reported approximately 36 million new developers joined the platform in 2025 alone.

Opening Night: Launching a Fine‑Tuned LLM to Production

Tue, 30 Dec 2025 20:53:57 +0000

Video & Podcast

Your fine‑tuned model is ready. Evals look good. Now you need to actually deploy it.

This is the part most guides skip: how do you take a checkpoint and turn it into a service that real users can hit? What infrastructure decisions matter? What boundaries do you set? What happens when the GPU runs out of memory on New Year’s Eve?

Think of it like opening a restaurant. Your recipes work great in the test kitchen. But opening night means: multiple orders arriving simultaneously, ingredients running low, equipment breaking, customers ordering things you never tested together, and kitchen staff who’ve never worked a real dinner rush.

Your Fine-Tuned LLM Model Isn’t Ready Yet: Here’s How to Evaluate It

Wed, 17 Dec 2025 16:57:45 +0000

Video & Podcast

Fine-tuning large language models has become dramatically easier. With techniques like QLoRA, teams can adapt billion‑parameter models on relatively modest hardware and get impressive results quickly. But this ease hides a trap: a model that finished training is not the same thing as a model that’s ready for production.

Many teams run a few spot checks, feel good about the outputs, deploy, and only discover weeks later that the model has drifted, slowed down, hallucinated, or lost user trust. The gap between “it trained successfully” and “it’s safe to ship” is wide, and closing it requires a testing mindset different from traditional software QA.

So You Want to Fine-Tune a Model (and You Finally Got a GPU!)

Thu, 11 Dec 2025 00:20:18 +0000

Podcast

You managed to get access to an H100 or A100 instance - great! Now comes the part no one really talks about: setting up the server so you can actually use it for fine-tuning. Cloud GPU setups have their quirks no matter where you run them, and having a clean, reliable configuration makes the difference between training tonight and debugging until sunrise.

If you’re spinning up an H100 or A100 VM for training, welcome = ) you’re about to do something fun, powerful, and occasionally puzzling. Every cloud provider has its own configuration rituals, and Azure is no exception. These notes capture what I wish Past Me had in front of her regarding the key steps.

How to Run Big Models on Small GPUs | All about Quantization

Wed, 26 Nov 2025 17:33:54 +0000

Video | Podcast

You’ve trained or fine-tuned a powerful LLM. It’s smart, it works, and it’s 51 GB. Now you need to deploy it on a 24GB GPU, or distribute it to users who don’t have data center hardware. Suddenly, that beautiful model doesn’t fit anywhere useful. This is the quantization problem, and it’s increasingly unavoidable.

Quantization is how we make big models fit on small GPUs. It’s like image compression for neural networks: a RAW photo might be 50MB, but compress it to JPEG and it’s 5MB. You lose detail, but to most people, it looks the same. A 50GB model becomes 13GB. A model that needed 80GB of VRAM (A100 territory) now runs on 24GB (like an RTX 3090 or 4090).

🧠 Building with LLMs: From Chat to Custom AI

Mon, 17 Nov 2025 17:58:54 +0000

Video & Podcast

Large Language Models (LLMs) can feel like magic to newcomers or maddeningly complex to veterans. Whether you’re automating workflows, building AI products, or just curious about the tech reshaping every industry, understanding how to use LLMs (and their multimodal cousins, MLLMs) is what we are here to discuss.

What’s an LLM, really? If you don’t know anything about LLMs, you can start by thinking of them as a really good at predicting language almost like autocomplete but that’s only a tiny piece of the picture. Realistically they’re much closer to a reasoning engine that’s trained on massive datasets that learns the structure of language and how ideas connect. An MLLM operates on multiple data types (thus multimodal): audio, video, images, and text. Example: upload a chart and ask for the trend.

LLM Fine-Tuning Optimization Part 2: Achieving Stability

Tue, 04 Nov 2025 15:13:38 +0000

Video & Podcast

In the LLM Fine-Tuning and the Performance Tug-of-War post, we explored the constant balancing act between quality, speed, and memory when fine-tuning large language models that align with your goals and constraints. Fine-tuning is the process of teaching an existing model (e.g. GPT-NeoX, Llama, Gemma, etc.) new knowledge or behaviors, transforming a general-purpose LLM into one that is a domain specialist.

The previous post introduced the core levers of sequence length, optimizers, attention type, and LoRA, which define how a model learns, generalizes, and scales. This post expands on your optimization toolkit by introducing four more essential levers: batch size, mixed precision, quantization, and gradient checkpointing.

When AI Models Start Talking to Each Other

Mon, 27 Oct 2025 16:06:53 +0000

For a while now, I’ve been using LLMs in a way that feels a bit like hosting a party for AIs. What happens when you don’t just prompt a single model but let multiple models talk to each other? To explore that question, and being inspired by the holiday, I built two demos that make the idea both technical and fun:

🧛 Monster Mash Chatroom: A FastAPI app where different LLMs wear costumes as classic Halloween monsters, chatting in real time.

What Is LLM Fine-Tuning?

Fri, 24 Oct 2025 16:07:25 +0000

Podcast & Video

When I wrote the LLM Fine Tuning & Performance Post, a good question that came up was: what exactly is fine-tuning and how does it work? This post can’t fully cover the topic, but I want to give some solid context around how fine tuning works for LLMs and MLLMs (the billion-parameter models that come from Anthropic, OpenAI, Mistral, Meta, DeepSeek, etc.).

Large language models are incredibly capable. They can write essays, debug code, or summarize medical records. But out of the box, they’re trained to handle everything in a general way, and they have limits based on the data they have access to. Granted, they continue to grow and improve in their capability and breadth of expertise so this is continually changing.

LLM Fine-Tuning & Performance Tug-of-War

Tue, 14 Oct 2025 18:40:03 +0000

Podcast

This year has been a crash course in large language model (LLM) development, marked by long training runs, GPU juggling, and a constant cycle of trial and error. While there is a lot of excitement around building custom LLMs, you probably know you shouldn’t start from scratch. Fine-tuning is the process of teaching an existing model (e.g. GPT-NeoX, Llama, Gemma, etc.) new knowledge or behaviors which transforms a general-purpose LLM into one that is a domain specialist. It bridges the gap between broad capability and domain-specific precision, allowing teams to achieve superior results without the immense cost of training from scratch.

JWT (JSON Web Tokens) Errors | Invalid JWT Signature

Thu, 18 Mar 2021 17:56:10 +0000

Errors are the best especially when they are written in a way where you become a decipherer. I remember the good old days when all the error codes I got were only numbers and maybe letters mixed in and there wasn’t any online searching to easly get interpretations.

I’ve been working with Google Cloud products and connecting to services from my laptop like Storage and BigQuery. Over the last several months, I’ve hit up against a JWT error, invalid_grant:Invalid JWT Signature, a couple times, and below provides an overview of how I resolved it, which was basically updating the expired service account key.

Pull & Push to Someone else’s Upstream GitHub PR

Thu, 19 Nov 2020 18:26:21 +0000

Pull & Push to Someone else’s Upstream GitHub PR

Another brief ‘how to’ for those who need to pull and push to someone else’s upstream GitHub pull request (PR).

I was working on a teammate’s GitHub pull request for Project OCEAN (a current focus of mine) to help close it out. Since her pull request came from her own personal account, there were key commands I needed in order to pull and push directly to it.

Golang | Copy to GCS & Check Bucket

Mon, 14 Sep 2020 23:44:13 +0000

Golang | Copy to GCS & Check Bucket

Are you trying to use Go to get files into Google Cloud Storage without pulling them onto the computer that is running the code or open them and read the contents into a new file? If yes, so was I not long ago. Here is a quick PSA to share the code I put together to solve this.

Copy Files to GCS

The following code example can get files from one url location into GCS without downloading it on the server running the code.

How to End User OAuth for GCP

Fri, 17 Jul 2020 22:05:26 +0000

How to End User OAuth for GCP

Let’s talk about end user authentication. I’ve been digging into the authentication space a bit and have some takeaways to share.

When you access a GCP service, there is authentication to determine who you are, authorization to determine what you can do and auditing that logs what you did. IAM is where you setup roles for authorization in regards what you can do in a project.

Docker with Cloud SDK & Environment Variables

Wed, 08 Jul 2020 18:33:39 +0000

Hello again. I am sharing a couple things I learned when working with Docker recently. Main points are how to pass in environment variables, setup Google Cloud SDK in Docker and turn on debugging.

Since I haven’t written about Docker before, I’ve provided a brief overview of Docker to give context and a grounding on my pointers. I recommend doing more digging to learn more elsewhere especially considering there are many other resources out there like this Docker overview.

Setup and Invoke Cloud Functions using Python

Tue, 23 Jun 2020 17:21:13 +0000

Setup and Invoke Cloud Functions using Python

Oh the fun I’ve had learning Cloud Functions. It has actually be fun while also frustrating and definitely enlightening to explore serverless services that are supposed to make things easy. Granted I’ve been around long enough to know there is always ramp up, even when it is simple.

Cloud Functions is a service that allows you to run code on Google Cloud servers without needing to deal with server configuration or scaling. It is a pay as you go approach that means you pay for what you use and that can help optimize costs. I’ve started using it for a couple functions that I need to run multiple times and that is where it can be very valuable. There was a learning curve especially when connecting different services and this post covers key learnings on these subjects.

BigQuery Dataset Metadata Queries

Mon, 08 Jun 2020 17:49:33 +0000

BigQuery Dataset Metadata Queries

When working with tables in BigQuery, you need an understanding of a dataset structure whether it is public or you set it up and you want to review. This is a quick bit to share queries you can use to pull metadata on your datasets and tables.

In the following examples, I’m using the BigQuery public Stack Overflow database to demonstrate these commands. Change out the names as needed for the dataset and tables you are working with.

Setup and Switch Between Google Cloud Projects in the SDK

Wed, 27 May 2020 17:21:16 +0000

Setup and Switch Between Google Cloud Projects in the SDK

Providing a quick overview on how to setup and switch between Google Cloud projects with the SDK on a single machine. This is helpful when working with multiple projects (especially when collaborating) and you are using Cloud SDK.

Setup & Authenticate

The following steps are needed whether creating a project for the first time or a project already exists and you are logging into it off a computer where you will do local development. This assumes you will run all commands from a terminal.

Comparing AI Platform Machine Types using YouTube-8M

Tue, 19 May 2020 18:01:52 +0000

When training a neural net model, time is of the essence. This is why different machine configurations including GPUs, TPUs and multiple servers are utilized.

I’ve been exploring the YouTube-8M project for the last couple months and there are previous posts about the project, the video dataset, the algorithms and how to run them in Cloud. For this post, I trained the two algorithms from the getting started code on different AI Platform standard machine configurations to see how they compared. AI Platform provides a number of scale tiers that are established configurations of different machine types and number of machines to run jobs.

YouTube-8M on AI Platform

Fri, 08 May 2020 00:18:34 +0000

YouTube-8M on AI Platform

Continuing the YouTube-8M exploration and blog series, this post walks through how to use AI Platform to train, evaluate and run predictions for the this dataset. Not surprising, it sets up servers faster than the server I manually configured.

The posts prior to this one provide an overview of the YouTube-8M project, data and computer vision modeling. This research has been used to further computer vision in relation to video datasets over the last several years.

YouTube-8M Training & Inference

Thu, 30 Apr 2020 04:51:54 +0000

Computer Vision | Video Understanding

Continuing on the previous YouTube-8M Dataset post, this one covers model training using what is provided in the getting started section of the GitHub repo. The goal of the models that are covered are to search for a specific moment within a video, which is called temporal concept localization.

In the past, metadata was used to search for videos. These newer models enable classifying specific segments in the video at a specific timestamp where those topics appear. For example the models can help identify in the video all the points where there is chocolate, someone is sleeping or someone is ice skating.

YouTube-8M Dataset

Wed, 11 Mar 2020 20:36:18 +0000

Computer Vision | Video Understanding

YouTube-8M is a project that was developed by Google AI/Research in 2016 to drive innovations and advancement in computer vision, representation learning and video modeling architectures at a large scale.

I’ve been exploring this dataset and example code for a couple weeks and this post summarizes the dataset origin, structure and where to find it. I also share initial exploratory steps that are posted in many places on Kaggle.

Cloud Storage with Gsutils & Python Client Library

Sat, 29 Feb 2020 01:05:19 +0000

Cloud Storage with Gsutils & Python Client Library

BLOB (binary large object) storage is aptly named. Google Cloud Storage is a BLOB storage solution that stores unstructured data. It’s like the closet you can shove a bunch of stuff into and don’t have to organize the information before putting it inside. It’s insanely flexible in size meaning it can hold anything and doesn’t need any special processing to store it.

SSH Agent Forwarding & Remote Upstream with GitHub & GCE

Thu, 20 Feb 2020 23:13:05 +0000

SSH Agent Forwarding & Remote Upstream with GitHub & GCE

When working with a cloud-based distributed version-control system during software development like GitHub, there are a couple key configurations that will enable you to collaborate on a project and work on a remote server like GCE (Google Compute Engine). You need to provide credentials to push and pull content from GitHub which SSH agent forwarding will help you accomplish. If you are working on a forked GitHub repo (repository) then you will want to setup remote upstream to keep it up to date.

Jupyter Notebook on Compute Engine with HTTPS

Wed, 19 Feb 2020 05:51:23 +0000

Jupyter Notebook on Compute Engine with HTTPS

I wanted to run/serve Jupyter Notebook from my remote GCE instance and access it through my laptop’s browser to test and visualize Python code snippets. I’ve done this before in a previous post I wrote a few years ago but a few things have changed in the setup. For this setup, I wanted to use https to access the notebook URL which required SSL certificate setup. As stated in the title, this post steps through how I setup Jupyter Notebook to run on my GCE using HTTPS.

Setup Compute Engine with Python ML Libraries

Sat, 15 Feb 2020 01:43:42 +0000

Below I will step through how I setup a Virtual Machine on Google Compute Engine with standard requirements as well as Python and related packages. In a previous post, I went through how to setup a VM and access to it from my laptop CLI.

As mentioned, I like accessing the remote server through the CLI and below I walk through commands to setup the remote instance with basic packages for Linux instance and common Python machine learning packages. Also, the instance I worked with was based on the Debian/GNU Linux 9 image. If you use a different instance, the commands may change but the general steps are similar.

Setup Local Terminal Access to Compute Engine

Mon, 10 Feb 2020 18:53:32 +0000

Setup Local Terminal Access to Compute Engine

I’ve been playing around with the Google Cloud Platform again in a way I haven’t done for a while. It is a strange sense of deja vu and scratches that addictive learning itch. Below are the steps I took on this latest project to setup a VM (virtual machine) on GCP and login to it from my laptop terminal (CLI).

This assumes an existing GCP account. If not then sign up to follow along.

Cyber Security for the Previous Generation

Mon, 29 Oct 2018 23:08:53 +0000

Cyber Security for Previous Generation

After being tech support for my mom, sorting out my parents affairs when my father got cancer and my mom got Alzheimers, I’ve gathered some insights on the vulnerability of the previous generation to cyber threats like phishing, spoofing and identity theft.

This is my security perspective and it will be different for each person. Take what works and adapt. The goal is to raise awareness that helping the previous gen stay safe is as important for them as much as it can help keep you safe. And yes these tips can be applied to every generation.

How to run any ML package on GCP | The Models

Tue, 18 Jul 2017 14:03:51 +0000

How to run any ML package on GCP | The Models

In the previous post, I showed you how to setup a virtual machine (VM) on Google Cloud Platform (GCP) so you can get started running your machine learning package of choice. Examples shared in this post are from different top frameworks in the ML space with a Python focused. Any programming language can be used as well as any package because you are just using a remote computer that you can shape as needed.

How to run any ML package on GCP | The Setup

Tue, 18 Jul 2017 14:03:02 +0000

How to run any ML package on GCP | The Setup

Recently, I joined Google to work on machine learning and Cloud. The first questions on my mind were how would I use Google Cloud Platform (GCP) like I’ve used other platforms to run whatever machine learning (ML) software that I want to use. This post is sharing a few things I’ve picked up over the last couple months with the intent to help others looking at GCP.

PyCon 2015: Neural Nets for Newbies

Sun, 12 Apr 2015 14:16:42 +0000

The ideas and methods in neural nets (NNs) have been around for a long time, but in the last decade plus, we are finally starting to reap significant benefits, and this is just the beginning. This post provides an overview of my recent PyCon talk in Montreal which is a neural net primer of sorts. The video is below, my slides are on SpeakerDeck, and I have a repo on Github named Neural Nets for Newbies.

Targeting Email with Random Forest at Change.org

Tue, 17 Feb 2015 09:49:19 +0000

Last fall, a couple of my colleagues (Kristiane Skiolmen, Scott Lau) and I presented Change’s machine learning email optimization approach as a lecture in Stanford’s Human Computer Interaction Seminar for CS grad students.

The video gives an overview of how Change.org uses email to drive petition engagement from the business and social perspective to the specific technical optimization we made. It starts with an overview of Change and examples of petitions that have literally improved and saved lives.

Graphlab & ODBC

Sun, 25 Jan 2015 22:33:27 +0000

For those out there working with Dato(Graphlab) and trying to setup an ODBC connection to just pull all the data straight into the SFrame, here are some tips I’ve learned from troubleshooting.

What is ODBC?
Open Database Connectivity which is a middleware API to help standardize and simplify access to database management systems.

**Connection Pointers:**There are a number of links on odbc setup but it was a little tricky to get it to work with Graphlab, Linux and OSX and Graphlab’s documentation is a little sparse in that area right now.

MapReduce, MRJob & AWS EMR Pointers

Mon, 07 Jul 2014 22:45:32 +0000

Over the last couple weeks, I’ve been playing around with MapReduce, MRJob and AWS to answer some questions about event data. Granted this is definitely more data engineering focused than data science, but using these tools can be very beneficial if you are analyzing a ton of data (esp. event log data).

This is more of an overview with a few lessons learned on how to setup a MapReduce job using MRJob and AWS EMR. This post focuses more on process and less about the script logic.

PyCon 2014 – How to get started with Machine Learning

Sun, 13 Apr 2014 23:14:26 +0000

Following up on the talk I just gave at PyCon 2014 in Montreal, I’ve explained parts of my presentation and provided a few additional clarifications. You can catch the talk at Pyvideo.org, my github repo PyCon2014 holds the sample code, and the slides are on SpeakerDeck.

Machine Learning (ML) Overview

Arthur Samuel defined machine learning as, “Field of study that gives computers the ability to learn without being explicitly programmed”. Its about applying algorithm(s) in a program to solve the problem you are faced with and address the type of data that you have. You create a model that will help conduct pattern matching and/or predict results. Then evaluate the model and iterate on it as needed to create the right type of solution for the problem.

Jeeves is Talking!

Sun, 30 Mar 2014 14:57:47 +0000

Coolest moment this week was when I figured out that I just needed to add one line of code to my program to get my computer to talk in my Jeeves project (thus video above).

This past week was all about fixing stuff, fine tuning, iterating and putting together a presentation and peripheral stuff for demo day which will be Thurs. Of course there is always more I could and would do, but I’ve been continually shifting priorities based on time and end goal.

Deep Learning Surface

Sat, 22 Feb 2014 08:53:56 +0000

Deep Learning is a tool in the Machine Learning (ML) toolbelt which is a tool in AI and Data Science toolbets. Think of it as an algorithm subset of a larger picture of algorithms and it’s area of expertise is solving some of the more complex problems out there like natural language processing (NLP), computer vision and automatic speech recognition (ASR). Like when you talk to the customer service computer voice on the phone vs. push a button.

Silicon Chef Hackathon – Leaprobo Project (aka Gizgig goes for a walk)

Sun, 13 Oct 2013 09:22:30 +0000

Last weekend at Silicon Chef, the first all women hardware hackathon, there were over 100 participants and 20 projects demoed. My team built an Arduino on Parallax wheels controlled by a Leap Motion (3D programmable motion sensor). Check out the video to see our robot car.

Leaprobo Project IdeaI bought the Parallax kit several months ago with the intent of attaching it to my Arduino because I think everything is better with wheels (almost everything). However, I was too busy with so many other projects and things to study that I didn’t get around to assembling it until now. When the hackathon came up, it seemed like the perfect motivator to break out the wheel kit. Plus, my team had heard about Leap Motion and controlling things with a sensor seemed like a fun. Thus, the idea for the Leaprobo project came together.

How Flask, Heroku & Alembic Play Together

Sun, 15 Sep 2013 01:24:02 +0000

I just spent a couple days getting up to speed on database migrations in general, how to make it work with Flask and Postgres and how to make them work on Heroku. There is some information out there but it took a little time hunting down what I needed; thus, I’ve summarized some of the main steps to help get others up and running with Flask, Heroku and Alembic.

Why migrate? Best practice is to avoid recreating your database(s). Usually you just want to make changes to the existing database(s) and track those changes. If at any time you need to go back to a previous version, the migration docs will help you easily revert to an old version / schema and then upgrade back to the most recent depending on your needs.

Deployment is not the Devil (Flask & Heroku Tips)

Sun, 01 Sep 2013 23:20:49 +0000

On a previous post I claimed deployment is the devil because after several successful (not always easy) deployments, pushing up my Sun Finder app proved elusive. I seriously wanted to scratch my eyes out at times with all the errors and issues. Still it was a good learning experience (one that I fought against but a good one all the same), and I did finally deploy as of last week! Check it out at sunfinder.io.

Flask Mega Tutorial, Sun Finder and SheCodes

Sat, 10 Aug 2013 16:28:13 +0000

It has been a busy several weeks and I’ve written just as lengthy of a blog post as last time from all of it. After deploying my Rails app, I switched gears to refocus on Sun Finder (through an indirect route). I signed up to present the app at SheCodes Conference on August 9th (yesterday) and I wanted to spiff it up a bit.

Flask Mega Tutorial (detour)

Before going back to Sun Finder, I spent a week finally going through the Flask Mega Tutorial which I had wanted to do since March. I highly recommend it because it goes from setting up a virtual environment through full stack development to a variety of deployment options. Going through that after the Rails tutorial was valuable because it solidified common concepts around web application structure (e.g. configuration, app instance setup, db setup and integration, where to delineate between view and controller). And of course it was helpful to contrast the differences to better understand how much Rails does for you behind the scenes.

Ruby on Rails & Python Trek

Sat, 20 Jul 2013 11:40:14 +0000

Wow its been a while since I last posted. Lots going on with interviews last month and then deciding to teach myself Ruby on Rails and being obsessed with Julython. I completed and launched my first Rails app (technically second after the sample app from the tutorial) at the beginning of this week. It is a simple thing that literally is just a button and I couldn’t be prouder.

What is Python Trek?
Python Trek is a mashup of Stark Trek and Monty Python scripts, quotes, etc. I built a program to generate random sentence or sentences using a Markov Chain algorithm and post those to the Twitter account @pythontrek. I used Ruby to build the program that generates the tweets and I applied Rails to set up a webpage where anyone can press a button that will generate the random tweet and post it.

What to Do When You are Hacked

Thu, 20 Jun 2013 12:42:29 +0000

I am someone who practices pretty decent technical security hygiene, but I had my Yahoo account hacked this week (despite using two factor identification). This post focuses on sharing what I did to deal with the attack, what I think went wrong and some steps and resources you can use for security.

Summary of attack…

The attacker logged in at 4:57PM PST and sent off 28 emails to about 5 recipients in each email from 4:58PM to 5:05PM. I learned about the attack from a friend at 5:08PM and logged in and changed my password at 5:10PM. The attacker appeared to pull email addresses from my account (I’m guessing from my contacts and sent file folders) to use in the spam emails.

Sun Finder – Where is it now?

Sun, 09 Jun 2013 08:52:20 +0000

For those following along, I have made very little progress on my Sun Finder application since Career Day about a month ago. Since hindsight is 20/20, I probably could have seen this coming, but I was living in a blissful imaginary world that said: “There will be all this time after I graduate to do all these things”. The reality is that all that time was about to be commandeered by interviews, practice & studying for interview and a bunch of life stuff that you can never plan for.

Hackathon Quick Bits for Beginners

Wed, 17 Apr 2013 16:49:00 +0000

I participated in my first hackathon a week ago, Gates & Facebook HackEd 2.0, with several of my fellow classmates. The hackathon’s focus was about building apps to improve education especially around college going, retention and social learning outside of school. There are others who were there that wrote some great overviews on the experience like KWu’s post.

I just have a couple quick bits to share about this experience and what I understand so far about hackathons.

Ode to .shutil.move() – ‘Oh how you frustrate me’

Tue, 12 Mar 2013 04:44:00 +0000

In Hackbright, we had a project from our first week that I was finishing this weekend, and it asked us to use the .shutil.move() function. Based on the reading for this function (linked above), it says “The destination directory must not already exist.” This threw me off for a while because you should have the directory already existing to move a file to it.

My experience with coding it and understanding at this point is that you need to create the directory before you reference it in the function and the quote I pulled is more to warn that if something already exists, it will be overwritten. If anyone has a different take on this function let me know and I’ll update the post.