imagining the futureZola2026-03-17T00:00:00+00:00https://www.livinginthepast.org/atom.xmlNo tea no shade2026-03-17T00:00:00+00:002026-03-17T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/no-tea-no-shade/<div class="bevy-embed" style="aspect-ratio: 2.35 / 1; background: linear-gradient(rgba(255,255,255,0.85), rgba(255,255,255,0.85)), url('/2026/hillside-980x.png') center / cover">
<canvas id="hillside-canvas" style="pointer-events: none;"></canvas>
<div class="webgpu-warning">
<p>This visualization requires WebGPU.</p>
</div>
</div>
<script type="module">
if (!navigator.gpu) {
document.querySelector(".webgpu-warning").style.display = "flex";
} else {
document.querySelector(".webgpu-warning").style.display = "none";
const init = (await import("/2026/hillside.js")).default;
await init("/2026/hillside_bg.wasm");
}
</script>
<p>I've been playing around with the <a rel="external" href="https://bevy.org/">Bevy</a> game engine off and on since
I was first introduced to it. My experiences over the years have been both extremely
positive and extremely frustrating, in equal measure, but in past attempts I've gotten
bogged down in problems (of my own design) such that I was not able to get very far into
development of actual game play.</p>
<p>This time around, I'm tackling a much more ambitious game scope, but with less ambiguous
game mechanics. This post won't go too deeply into the technical details, or even the
game itself, but will be an overview of my experiences as well as why it's going better
this time around.</p>Agentic software is just software2025-06-04T00:00:00+00:002025-06-04T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/agents/<p>Friends of mine hear a bit of snark from me when it comes to the recent explosion of hype
regarding AI, how it will solve all of the world's problems (while <em>definitely</em>
not causing any new ones), and how it's revolutionizing software development. This post is
an attempt at something other than snark; it's an attempt to get to the heart of the
snark, to a thing that has been clear to me whenever anyone talks about the next wave
of AI: agentic AI.</p>
<p>Agentic AI is not new. Agentic software is just a new term to describe an old concept
that we used to call: software.</p>Fast FreeBSD with ZFS on Vultr2025-05-29T00:00:00+00:002025-05-29T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/vultr-freebsd-bootstrap/<p>For the past year I've been running several Postgres databases in FreeBSD VPS's hosted in
<a rel="external" href="https://www.vultr.com">Vultr</a>. I run Postgres in jails, FreeBSD's abstraction for OS-level
virtualization. Jails work very well when paired with ZFS, so I prefer to run my hosts
using ZFS for the root file system.</p>
<p>Unfortunately, although Vultr provides FreeBSD images, those images use UFS on root instead
of ZFS. Because of that, I've been setting up my VPS's by creating them from a custom bootonly
ISO, and then installing FreeBSD from scratch. This has worked relatively well, except for the
fact that for some reason the boot process would pause for about 30-60 seconds. When creating
a VPS from Vultr's FreeBSD images, the boot was fast.</p>
<p>This made me very concerned about rebooting my hosts. No more! Today I discovered the problem.</p>
<p><em>tldr; Create your VPS from the Vultr-provided FreeBSD image, then attach a bootonly ISO and
reinstall the OS from scatch.</em></p>Acceptable Upgrades2025-03-10T00:00:00+00:002025-03-10T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/acceptable-upgrades/<p>Last week I had the opportunity to speak at Code BEAM America 2025 in San Francisco. I find Code BEAM to be
one of the best conferences for connecting with people in my industry working in Elixir and Erlang—not only
socially, but in terms of the cutting edge.</p>
<p>I spoke about introducing tests to an application with an existing and challenging database schema. 25
minutes is challenging when putting together a talk—on the project that inspired this talk, I learned a
lot about using Ecto for legacy schemas that just couldn't fit into time. That said, the challenge
caused me to distill some code organization rules that I like to use into what the core principles behind
them. I believe that applying these rules will result in faster development and fewer bugs, but even if
you don't want to apply them directly, perhaps the thinking behind them will be useful to you!</p>
<p>Take a look at the slides below.</p>Test Your Seeds2024-05-17T00:00:00+00:002024-05-17T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/test-your-seeds/<p>When building products with <code>Phoenix</code> and <code>Ecto</code>, a common practice is to include
development seeds in a file named <code>priv/repo/seeds.exs</code>. By default, it's expected
that this file will include a list of actions to run procedurally upon loading the
file. With a few changes, we can instead make a testable module, so that we will know
when our refactors will break the seeds for ourselves and for others.</p>
<img src='/2024/lukasz-rawa-NDro8tjU4e0-unsplash.jpg' alt='Łukasz Rawa @ Unsplash : https://unsplash.com/photos/brown-and-black-dried-leaves-NDro8tjU4e0' />I did a thing! aka Test Reflector2024-04-29T00:00:00+00:002024-04-29T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/test-reflector/<p>tldr; <a rel="external" href="https://www.testreflector.app">Test Reflector</a>.</p>
<p>Over the past two years I've written or helped to write
<a rel="external" href="https://github.com/synchronal">a lot of open source software</a>. I would say that
the last two years have been the most productive in my life, in terms of sheer
amount of productive and useful lines of code that I have created. While I don't
believe that lines of code are necessarily the best success metric, in terms of
that code being useful to me, helping me to develop applications
faster, and having confidence in the quality of code that I have shipped in
production apps over that time… the last two years have been pretty good.</p>Gogalixir2024-02-20T00:00:00+00:002024-02-20T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/gogalixir-intro/<p>For a long time I've wanted there to be a single-track conference in the Bay Area
focused on Elixir and Erlang, in the vein of <a rel="external" href="https://github.com/gogaruco">gogaruco</a>.
I love <a rel="external" href="https://codebeamamerica.com">Code BEAM</a> (and am attending this year!), but
there's something to be said for smaller, locally-organized conferences where you
get to meet people in your regional programming community—where you don't have to
decide between conference talks, but have a single shared experience among all
attendees.</p>
<p>My friend and business partner <a rel="external" href="https://eahanson.com">Erik Hanson</a> and I have been
talking about this conference for years. We were excited enough about it that we
even <a rel="external" href="https://gogalixir.com">bought a domain</a>. What we didn't have was any experience
in planning or organizing a large event.</p>
<p>This winter, we decided that we could solve the problem of not knowing what we're
doing by starting smaller. Thus was the <a rel="external" href="https://gogalixir.com">Golden Gate Elixir Meetup</a>
born.</p>Migrating Databases with Ecto2022-11-25T00:00:00+00:002022-11-25T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/migrating-data-with-ecto/<p>On a new project I'm working to migrate data between Azure SQL (aka MSSQL) and
PostgreSQL, and to migrate a business's software from Visual Basic and C# to Elixir.
In the first few weeks of development I've discovered some features of Ecto that
I was previously unaware of. Combining these features will allow us to ship a resilient,
well-tested application while constraining the possibility of accidentally
altering data in production.</p>
<pre class="giallo" style="color: #E6EDF3; background-color: #0D1117;"><code data-lang="elixir"><span class="giallo-l"><span style="color: #FF7B72;">defmodule</span><span style="color: #79C0FF;"> Test</span><span>.</span><span style="color: #79C0FF;">Integration</span><span>.</span><span style="color: #FFA657;">CrossRepoTransactions</span><span style="color: #FF7B72;"> do</span></span>
<span class="giallo-l"><span style="color: #FF7B72;"> use</span><span style="color: #FFA657;"> Test</span><span>.</span><span style="color: #FFA657;">DataCase</span><span>,</span><span style="color: #79C0FF;"> async: true</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span> test </span><span style="color: #A5D6FF;">"sharing database connections"</span><span style="color: #FF7B72;"> do</span></span>
<span class="giallo-l"><span> {</span><span style="color: #79C0FF;">:ok</span><span>, alice}</span><span style="color: #FF7B72;"> =</span></span>
<span class="giallo-l"><span style="color: #FFA657;"> Test</span><span>.</span><span style="color: #FFA657;">Fixtures</span><span>.</span><span style="color: #D2A8FF;">azure_person</span><span>(</span><span style="color: #79C0FF;">:alice</span><span>)</span></span>
<span class="giallo-l"><span style="color: #FF7B72;"> |></span><span style="color: #FFA657;"> Azure</span><span>.</span><span style="color: #FFA657;">Person</span><span>.</span><span style="color: #D2A8FF;">changeset</span><span>()</span></span>
<span class="giallo-l"><span style="color: #FF7B72;"> |></span><span style="color: #FFA657;"> Azure</span><span>.</span><span style="color: #FFA657;">WriteableRepo</span><span>.</span><span style="color: #D2A8FF;">insert!</span><span>()</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span> assert {</span><span style="color: #79C0FF;">:ok</span><span>,</span><span style="color: #8B949E;"> _</span><span>}</span><span style="color: #FF7B72;"> =</span><span style="color: #FFA657;"> Azure</span><span>.</span><span style="color: #FFA657;">ReadOnlyRepo</span><span>.</span><span style="color: #D2A8FF;">get</span><span>(</span><span style="color: #FFA657;">Azure</span><span>.</span><span style="color: #FFA657;">Person</span><span>, alice.id)</span></span>
<span class="giallo-l"><span style="color: #FF7B72;"> end</span></span>
<span class="giallo-l"><span style="color: #FF7B72;">end</span></span></code></pre>ExUnit Patterns for Ease of Mind2022-09-12T00:00:00+00:002022-09-12T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/exunit-tags-test-setup/<p>In recent months I have been working on a number of projects with my primary collaborator
of recent years, <a rel="external" href="https://github.com/eahanson">Erik Hanson</a>. Some of those projects
have led to a number of <a rel="external" href="http://github.com/synchronal">open source Elixir libraries</a>.
Others may be eventually be open sourced, but are currently private.</p>
<p>In this post, I'd like to share a set of patterns that work together to ease test setup
and organization. The examples shown will be for <a rel="external" href="https://hexdocs.pm/ex_unit/ExUnit.html">ExUnit</a>
and <a rel="external" href="https://phoenixframework.org">Phoenix</a>, but could be adapted to other languages and
frameworks.</p>
<pre class="giallo" style="color: #E6EDF3; background-color: #0D1117;"><code data-lang="elixir"><span class="giallo-l"><span style="color: #FF7B72;">defmodule</span><span style="color: #79C0FF;"> Web</span><span>.</span><span style="color: #FFA657;">ProfileLiveTest</span><span style="color: #FF7B72;"> do</span></span>
<span class="giallo-l"><span style="color: #FF7B72;"> use</span><span style="color: #FFA657;"> Test</span><span>.</span><span style="color: #FFA657;">ConnCase</span><span>,</span><span style="color: #79C0FF;"> async: true</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span> @tag</span><span style="color: #79C0FF;"> page: :alice</span><span>,</span><span style="color: #79C0FF;"> profile:</span><span> [</span><span style="color: #79C0FF;">:alice</span><span>]</span></span>
<span class="giallo-l"><span> test </span><span style="color: #A5D6FF;">"shows profile info"</span><span>, %{</span><span style="color: #79C0FF;">pages:</span><span> %{</span><span style="color: #79C0FF;">alice:</span><span> page},</span><span style="color: #79C0FF;"> profiles:</span><span> %{</span><span style="color: #79C0FF;">alice:</span><span> alice}}</span><span style="color: #FF7B72;"> do</span></span>
<span class="giallo-l"><span> page</span></span>
<span class="giallo-l"><span style="color: #FF7B72;"> |></span><span style="color: #FFA657;"> Test</span><span>.</span><span style="color: #FFA657;">Pages</span><span>.</span><span style="color: #FFA657;">ProfilePage</span><span>.</span><span style="color: #D2A8FF;">visit</span><span>()</span></span>
<span class="giallo-l"><span style="color: #FF7B72;"> |></span><span style="color: #FFA657;"> Test</span><span>.</span><span style="color: #FFA657;">Pages</span><span>.</span><span style="color: #FFA657;">ProfilePage</span><span>.</span><span style="color: #D2A8FF;">assert_here</span><span>()</span></span>
<span class="giallo-l"><span style="color: #FF7B72;"> |></span><span style="color: #FFA657;"> Test</span><span>.</span><span style="color: #FFA657;">Pages</span><span>.</span><span style="color: #FFA657;">ProfilePage</span><span>.</span><span style="color: #D2A8FF;">assert_profile_info</span><span>(alice.name, alice.email)</span></span>
<span class="giallo-l"><span style="color: #FF7B72;"> end</span></span>
<span class="giallo-l"><span style="color: #FF7B72;">end</span></span></code></pre>CodeBEAM V America 20212021-06-21T00:00:00+00:002021-06-21T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/codebeam-v-america-2021/<p>Back in March I gave a talk at <a rel="external" href="https://codesync.global/conferences/code-beam-v-america-2021/">CodeBEAM V America</a>
about some of the work that I did at Geometer in 2020. I started work at Geometer
the same week that the SF Bay Area began its lockdown for Covid-19—while the purpose
of Geometer was to be a startup incubator, on my first day there was an all-hands where
Rob, the founder, said that for the forseeable future we would devote our efforts to
pandemic relief.</p>
<p>While working on these projects, I saw parts of the US health system that I knew
existed, but had no idea just how discouraging they would be. I also met (virtually)
health care workers and departments of health officials who were throwing themselves
into work to help save lives, sometimes in spite of the technology that should have
been solving their problems, but instead caused other greater problems.</p>
<h3 id="tldr">TLDR;</h3>
<ul>
<li>Before deploying a <a rel="external" href="https://hexdocs.pm/broadway/Broadway.html">Broadway</a> pipeline
to production, really try to understand <a rel="external" href="https://hexdocs.pm/gen_stage/GenStage.html">GenStage</a>.</li>
<li>AWS promotes Lambda as a general purpose data processing tool for high scale
workloads. I found Lambda to be incredibly difficult to monitor or debug, with
quirks in the runtime that were only testable through trial and error.</li>
<li>Broadway/Oban/Flow could easily handle much greater scale than we were solving
for, in a resilient runtime that was much easier to inspect and debug.</li>
<li>Be thoughtful about naming.
<ul>
<li>I started by grouping data pipelines into high-level domains specific to ETL.
Pipelines pulling data into our system were grouped into <code>Extract</code>.
Pipelines putting data into an external system were grouped into <code>Load</code>. While
technically true, this was the opposite of what new teammates expected when
seeing the word “load.”</li>
<li>A more clear vocabulary might have been that used by
<a rel="external" href="https://www.membraneframework.org">Membrane Framework</a>, ie <code>source</code>, <code>filter</code>,
and <code>sink</code>.</li>
</ul>
</li>
</ul>Freshening Up2021-06-17T00:00:00+00:002021-06-17T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/freshening-up/<p>It being 2021, I have decided to air out the website and tune it up. With a working development
and deployment pipeline, my intention is to start doing regular updates.</p>
<ul>
<li>Site updates</li>
<li>What's been going on?</li>
<li>Elixir</li>
</ul>Decoupling Ruby with RabbitMQ at SF.rb2016-04-30T00:00:00+00:002016-04-30T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/sf-dot-rb-rabbitmq/<p>On Tuesday I spoke at the SF.rb meetup at InstaCart HQ in San Francisco. Here are the slides that I presented from:</p>
<div class="embed">
<script async class="speakerdeck-embed" data-id="73ef21f416d642d6a2a4d130921b72e8" data-ratio="1.77777777777778" src="//speakerdeck.com/assets/embed.js"></script>
</div>
<p>Other great talks were from Pam Nangan about the technology gap faced by nonprofit organizations, and by Lillie Chilen on the benefits of having a well-run
internship program (and stories of good and bad experiences leading to a well-run program). This is a fantastic meetup, with a focus on diversity of speaker
backgrounds and experience. Thank you so much for having me talk!</p>Sharding into big integers2016-02-24T00:00:00+00:002016-02-24T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/sharding-into-bigints/<p>One day you wake up, you grab your laptop, you open your email, you see a strange alert, and you open up your exception tracking service. There you see the following text.</p>
<pre class="giallo" style="color: #E6EDF3; background-color: #0D1117;"><code data-lang="plain"><span class="giallo-l"><span>ActiveRecord::StatementInvalid: PG::NumericValueOutOfRange:</span></span>
<span class="giallo-l"><span>ERROR: integer out of range</span></span></code></pre>
<p>You then close your laptop and climb back into bed. If anyone asks later, you never saw that message. What even is computer?</p>
<p>By default when Rails migrations create id columns in Postgres, it uses the <code>serial primary field</code> native type, an <code>integer</code>. When reference columns are specified, Rails uses an <code>integer</code>. The range of numbers covered by the integer numeric type in Postgres is:</p>
<pre class="giallo" style="color: #E6EDF3; background-color: #0D1117;"><code data-lang="plain"><span class="giallo-l"><span>-2147483648 to +2147483647</span></span></code></pre>
<p>The range of numbers for bigints is:</p>
<pre class="giallo" style="color: #E6EDF3; background-color: #0D1117;"><code data-lang="plain"><span class="giallo-l"><span>-9223372036854775808 to 9223372036854775807</span></span></code></pre>
<p>For most datasets, integers are more than enough for the id space of most tables. In the lifetime of a company, the upper bound of integers might never be reached in any database. Unfortunately (or fortunately), we have run into this problem several times now. The first was caused by a bug, where data synchronized between two of our applications unintentionally deleted and recreated the data on a daily basis. A moderate-sized dataset of a few hundred million rows had overflowed the integer space of its ids. Whoops!</p>
<p>This turned out to be a very insidious and unexpected bug, which was particularly interesting to me because of where we have <strong>not</strong> run into integer overflows in the past. We have services with more than three billion records in a single table space. In those applications we have sharded the data heavily, using thousands of Postgres schemas as logical shards across a set of database zones. Because of the nature of that data, however, we were able to generate unique identifiers for each row based on the data in the row, in the form of base62 encoded strings. Doing so allowed us to shard data without having to worry about unique identifier generation—as a side effect, it completely obviated the possibility of integer overflow errors.</p>
<p>The second case where we have had to migrate from integers to bigints was another scalability project. In order to scale writes to one of our internal Rails applications, we decided to split the entire database into multiple shards. The upside was that this was quite easy to do using the Multidb gem; Multidb does not natively do everything we need, but the code is extremely simple, readable, and the missing bits were easy for us to fill in ourselves. The downside was that in order to do this sharding, we needed to generate unique ids across shards.</p>Decoupling Distributed Ruby applications with RabbitMQ2016-02-16T00:00:00+00:002016-02-16T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/decoupling-distributed-ruby-applications-with-rabbitmq/<p><strong>Note that this is a repost of an article written for the <a rel="external" href="http://building.wanelo.com">Wanelo blog</a>. Take a look there
for other great content.</strong></p>
<p>A lot of people might be surprised to hear how long it took us to stand up our message bus infrastructure at Wanelo.
One of the downsides of focusing on iteration is that fundamental architecture changes can seem extremely intimidating.
Embracing iteration means embracing the philosophy that features should be developed with small changes released in small
deployments. The idea of spinning up unfamiliar technology, with its necessary Chef code, changing our applications to
communicate in a new way, then production-izing the deployment through all the attendant failures and misunderstandings
seems... dangerous.</p>
<p>Fortunately "Danger" is our middle name at Wanelo. (Actually, our middle name is "Action." Wanelo Action Jackson).
Having now developed using a messaging infrastructure for almost a year and a half, I would no longer develop
applications in any other way.</p>Code for replication delay2014-06-11T00:00:00+00:002014-06-11T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/code-for-replication-delay/<p><strong>Note that this is a repost of an article written for the <a rel="external" href="http://building.wanelo.com">Wanelo blog</a>. Take a look there
for other great content.</strong></p>
<p>After some recent changes to autovacuum settings on our main PostgreSQL databases, we’ve encountered regular significant replication delay on our four streaming replicas. Why this is happening is an interesting subject for another blog post, but it reminded me of some assumptions built into our codebase, as well as some interesting complications of API design.</p>One SMF to Rule Them All2013-11-27T00:00:00+00:002013-11-27T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/one-smf-to-rule-them-all/<p>Over the past few years I've become a big fan of
<a rel="external" href="http://smartos.org">SmartOS</a>, a distribution of
<a rel="external" href="http://wiki.illumos.org/display/illumos/illumos+Home">Illumos</a> built
specifically with cloud IaaS in mind. One of the features it
inherits from Solaris is the <a rel="external" href="http://en.wikipedia.org/wiki/Service_Management_Facility">Service Management
Facility</a>,
SMF. For various reasons, SMF is my service management framework of
choice—one reason we prefer deployment on SmartOS at
<a rel="external" href="http://wanelo.com">Wanelo</a> is the feature-richness and stability of
daemon management under SMF.</p>
<p>One complaint that we had was the management of service families,
however. Recently, we started using service dependencies to help manage
groups of services, particularly in emergency situations when we need to
stop or restart many services at once.</p>Threads in a GIL2013-11-25T00:00:00+00:002013-11-25T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/threads-in-a-gil/<p>MRI Ruby has a <a rel="external" href="http://en.wikipedia.org/wiki/Global_Interpreter_Lock">global interpreter
lock</a> (GIL),
meaning that even when writing multi-threaded Ruby only a single thread
can be on-CPU at any given point in time. Other distributions of Ruby
have done away with the GIL, but even in MRI threads can be useful. The
Sidekiq background worker gem takes advantage of this, running multiple
workers in separate threads within a single process.</p>
<p>If the workload of a job blocks on I/O, Ruby can context-switch to other
threads and do other work until the I/O finishes. This could happen when
the workload reaches out to an external API, shells out to another command,
or is accessing the file system. Depending on how a job is written, writes
to external storage like an NFS server could block on I/O.</p>
<p>If the workload of a process does not block on I/O, it will not benefit
from thread switching under a GIL, as it will be, instead, CPU-bound. In
this case, multiple processes will be more efficient, and will be able to
take better advantage of multi-core systems.</p>
<p>So… why not skip threads and just deal with processes? A number of
reasons.</p>Today we went to the bad place…2013-11-24T00:00:00+00:002013-11-24T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/today-we-went-to-the-bad-place/<p>You know the Bad Place. It starts with the words “How hard could it be?”
and ends with me in the shower, fully clothed under a stream of hot
water, crying. You think you’re in for a nice, quick, pleasant plane
ride, but suddenly Brian Blessed is dressed like this and waving a
pointy stick at you and you can never go home again…</p>
<img src='/2013/brian-blessed-is-fucking-awesome.jpg' alt='I think this is how Brian Blessed dresses every day' />
<p>This Bad Place involved the migration from Selenium running via Capybara
in Minitest to capybara-webkit running in RSpec. We have various reasons
for preferring this at my work, many of them subjective and based on the
collected positive experiences of several people working in this
codebase. We believe that the end result will make us happier in the
long run.</p>
<p>We’re not yet all the way to the other side, but I thought I would share
some learnings. Some of them were more obvious than others, but
hopefully others can learn from today’s strange coding journey.</p>
<ul>
<li>We will run javascript specs and unit tests in the same spec runner.
The database cleaning configuration required to make this work and run
quickly is non-obvious.</li>
<li>Some of our testing gems have not been updated since the launch of
this project. Some gems conflict with newer versions of other testing
gems, blocking upgrade.</li>
<li>Some of our Selenium tests do not require Javascript execution or CSS
rendering in order to pass</li>
<li>Some of our Selenium tests depend on stubbing at the server</li>
<li>We over-use <code>Thing.any_instance.stub</code></li>
</ul>New Job at Wanelo2012-09-20T00:00:00+00:002012-09-20T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/new-job-at-wanelo/<p>I have made the move. Starting Monday I'm going to be working at
<a rel="external" href="http://wanelo.com">Wanelo</a>,
a social media startup working on connecting people with e-commerce.
It's an interesting change for me, as two years ago I promised myself I
would never work for a social network company. A lot has changed in the
last two years, however, and I thought I would take some time to put it
down in words (for my own benefit as well as yours, illustrious reader).</p>
<p>For the past two years I have worked at
<a rel="external" href="http://www.modcloth.com">ModCloth</a>,
an e-commerce fashion
company that works with small-medium sized fashion designers to sell
vintage-inspired clothing. In the course of my time there, I worked on
various features including Be the Buyer, a program to crowd-source
product acquisition and merchandizing. I led a team to re-architect the
product categories to be based on search indexes, not only making the
process by which new products appear on the site more automated
and robust (before, every product was manually added and sorted in
every category by hand), but allowing us to implement faceted drill-down
on almost every category—customers can easily find in-stock dresses that
are their color, size and price range. In the end, I worked on systems
automation to build new servers in an automated and quick fashion. Hopefully
I had some influence in the long term strategy of organizing code into
separate applications and services.</p>New Blog2012-09-18T00:00:00+00:002012-09-18T00:00:00+00:00
Eric Saxby
https://www.livinginthepast.org/blog/new-blog/<p>Well, it's time. While the old blog had some relevant data (at least to me),
it's time to shuck off the old and begin with the new. As such, I'm
going to rely on the <a rel="external" href="http://web.archive.org/web/20110201094856/http://ericsaxby.com/blog/">Internet Archive</a>
to provide historical content.</p>
<p>The analytics of my previous blog and the random connections it would attract
were interesting, but there are a few deciding factors to guide this
along:</p>
<ul>
<li>I have not updated it in about 2 1/2 years</li>
<li>Most of the content is technologically dated</li>
<li>Since last writing, I have switched jobs twice (more on that in a
later post)</li>
</ul>