RYMC

Forgejo index.js woes

Wed, 21 May 2025 00:00:00 +0000

I've run a few small git forges that've gone through the various fork paths over the years, from Gogs</a> to Gitea</a> to (now) Forgejo</a>. It all runs remarkably well and has been mostly set-and-forget for as long as I can remember, and easily trumps the few times I've had to deal with self hosting something like Gitlab. One weird issue would come and go over the years, though: on first load of a page for Gitea and Forgejo, I'd randomly get an alert about being unable to load the core JS file.</p>

If you just reloaded the page, things would work fine - and frankly that was simpler than bothering to debug it when it appeared. Presumably, the file was just getting cached somehow and subsequent loads would not have issues. I had a few minutes earlier this week to debug it and figured I'd note it down for anyone who's getting confused by it. In my case, this error was actually specific to nginx as a reverse proxy sitting in front of everything.</p>

The Fix</h2>

When nginx is proxying a response that's deemed too large, it attempts to buffer it in temporary file. For whatever reason, on my stock Debian 12 image nginx did not have the right permissions to do this. A simple chown</code> to the user that nginx runs under fixes this:</p>

</span>sudo chown -R www-data:www-data /var/cache/nginx
</span></span></code></pre>
This error as presented in the browser can be confusing; if you have http2</code> enabled on your host, Chrome & co will report it as an http2 specific issue. If you disable that, it correctly reports it as invalid chunking - i.e, the response is being interrupted due to nginx not being able to write when proxying.</p>


Connecting tokio-postgres over an SSH tunnel
Tue, 29 Apr 2025 00:00:00 +0000
I recently found myself writing a quick script to toggle some jobs on a remote server. The server itself runs a bog-standard PostgreSQL instance to store and manage the jobs, and the setup itself isn't so important that I wanted to spend the effort cobbling together an HTTP server and endpoint - just a quick call over SSH should be more than enough. Now, you could do this in any language, framework, or environment - but the overall project is written in Rust, and I like to keep things uniform where it makes sense to do so. After perusing some docs for a minute or two, it seemed relatively straightforward to do - but I realized I hadn't seen any good examples of this floating around, and so I figured I may as well throw one up here.</p>
This won't be as in-depth or complete as other posts on this site, but the general approach is correct and I'm confident that interested parties can glean what they need from here. It's expected that you know what/why you're reading here.</p>
Crates We Need</h2>
There's really only two or three crates that we need to be dealing with here.</p>

tokio (1.0.x)</a>: The async runtime that most things in Rust piggyback off of.</li>
tokio-postgres (0.7.x)</a>: A library for working with Postgres backed by a tokio</code> runtime.</li>
async-ssh2-tokio (0.8.x)</a>: An async SSH client library.</li>
</ul>
The latter two crates are key: how do we make tokio-postgres</code> call over SSH?</p>
Step 1: SSH</h2>
Let's get our SSH tunnel sorted. A few key variables we need up-front:</p>
</span>// Remember, this is an example - you don't typically want to shove these
</span></span>// (some or all) into your codebase. You probably want to load these 
</span></span>// from your environment, or however you typically handle sensitive keys.
</span></span>const </span>SERVER</span>: (</span>&</span>str</span>, </span>u16</span>) </span>= </span>(</span>"your.server.ip.address"</span>, </span>22</span>);
</span></span>const </span>USER</span>: </span>&</span>str </span>= </span>"your_ssh_username_here"</span>;
</span></span>const </span>KEY_PATH</span>: </span>&</span>str </span>= </span>"path_to_your_ssh_key_here"</span>;
</span></span>const </span>DB_SERVER</span>: (</span>&</span>str</span>, </span>u16</span>) </span>= </span>(</span>"127.0.0.1"</span>, </span>5432</span>);
</span></span>const </span>DB_USER</span>: </span>&</span>str </span>= </span>"your_postgres_username_here"</span>;
</span></span>const </span>DB_PASSWORD</span>: </span>&</span>str </span>= </span>"your_postgres_password_here"</span>;
</span></span>const </span>DB_NAME</span>: </span>&</span>str </span>= </span>"your_database_name_here"</span>;
</span></span></code></pre>
Next, we can go ahead and start the SSH tunnel. The flow is relatively straightforward: open the connection, connect to Postgres, and then pass the stream to tokio-postgres</code> to use. At time of writing, open_direct_tcpip_channel</code> has no documentation - but it's thankfully an explanatory enough method name that has the same idea as what you'd find in other languages and ecosystems.</p>
</span>use </span>async_ssh2_tokio</span>::</span>{</span>Client, AuthMethod, ServerCheckMethod</span>}</span>;
</span></span>
</span></span>let</span> key </span>= </span>AuthMethod</span>::</span>with_key_file(</span>KEY_PATH</span>, </span>None</span>);
</span></span>
</span></span>match </span>Client</span>::</span>connect(</span>SERVER</span>, </span>USER</span>, key, </span>ServerCheckMethod</span>::</span>NoCheck)</span>.</span>await </span>{
</span></span>    </span>Ok</span>(client) </span>=> match</span> client</span>.</span>open_direct_tcpip_channel</span>(</span>DB_SERVER</span>, </span>None</span>)</span>.</span>await </span>{
</span></span>        </span>Ok</span>(channel) </span>=> </span>{
</span></span>            </span>if </span>let </span>Err</span>(error) </span>= </span>do_pg_stuff</span>(channel</span>.</span>into_stream</span>())</span>.</span>await </span>{
</span></span>                </span>eprintln!(</span>"Failed to do PG stuff: {:?}"</span>, error);
</span></span>            </span>}
</span></span>        </span>}</span>,
</span></span>
</span></span>        </span>Err</span>(error) </span>=> </span>{
</span></span>            </span>eprintln!(</span>"Unable to open TCP/IP channel: {:?}"</span>, error);
</span></span>        </span>}
</span></span>    </span>}</span>,
</span></span>
</span></span>    </span>Err</span>(error) </span>=> </span>{
</span></span>        </span>eprintln!(</span>"Unable to connect via SSH: {:?}"</span>, error);
</span></span>    </span>}
</span></span>}
</span></span></code></pre>Step 2: Postgres</h2>
With a successful tunnel going, we can complete our Postgres client and execute a simple select to make sure things work. The key part is calling connect_raw</code>, which accepts a stream interface. Rather than deal with type hell, we're going to just take the easy route and let the compiler infer things for us through our parameter S</code>.</p>
</span>use </span>std</span>::</span>marker</span>::</span>Unpin;
</span></span>
</span></span>use </span>tokio</span>::</span>io</span>::</span>{</span>AsyncRead, AsyncWrite</span>}</span>;
</span></span>use </span>tokio_postgres</span>::</span>{</span>Config, Error, NoTls</span>}</span>;
</span></span>
</span></span>async </span>fn </span>do_pg_stuff</span><S>(</span>stream</span>: S) </span>-> Result<(), Error>
</span></span>where
</span></span>    </span>S: AsyncRead + AsyncWrite + Unpin + Send + </span>'static</span>,
</span></span>{
</span></span>    </span>let </span>mut</span> config </span>= </span>Config</span>::</span>new();
</span></span>    </span>config</span>.</span>user</span>(</span>DB_USER</span>);
</span></span>    </span>config</span>.</span>password</span>(</span>DB_PASSWORD</span>);
</span></span>    </span>config</span>.</span>dbname</span>(</span>DB_NAME</span>);
</span></span>
</span></span>    </span>let </span>(client, connection) </span>=</span> config</span>.</span>connect_raw</span>(stream, NoTls)</span>.</span>await</span>?</span>;
</span></span>    </span>
</span></span>    </span>tokio</span>::</span>spawn(async </span>move </span>{
</span></span>        </span>if </span>let </span>Err</span>(error) </span>=</span> connection</span>.</span>await </span>{
</span></span>            </span>eprintln!(</span>"Connection error: {:?}"</span>, error);
</span></span>        </span>}
</span></span>    </span>}</span>);
</span></span>
</span></span>    </span>let</span> rows </span>=</span> client
</span></span>        </span>.</span>query</span>(</span>"SELECT $1::TEXT"</span>, </span>&</span>[</span>&</span>"hello world"</span>])
</span></span>        </span>.</span>await</span>?</span>;
</span></span>
</span></span>    </span>let</span> value: </span>&</span>str </span>=</span> rows[</span>0</span>]</span>.</span>get</span>(</span>0</span>);
</span></span>    </span>println!(</span>"</span>{}</span>"</span>, value);
</span></span>
</span></span>    </span>Ok</span>(())
</span></span>}
</span></span></code></pre>
Put it all together, and you have a Postgres client in Rust over an SSH tunnel. This is definitely simpler with tokio-postgres</code>; if you find yourself wanting to do this with diesel</code> or sqlx</code>, you'll likely need to do some extra legwork with their respective Connection</code> traits to ferry things back and forth.</p>


UUIDv7 TypeIDs in Diesel
Wed, 10 Jul 2024 00:00:00 +0000
In a project I'm putting together, I made the choice to utilize UUIDs as identifiers early on. PostgreSQL has strong support for them, and if you're using UUIDv7, you avoid some of the issues that existed with earlier versions regarding indexing and sortability. In representing these IDs, it's common nowadays to want to utilize "Stripe-style" identifiers, something akin to:</p>
</span>// {slug}_{base32encodedUUID}
</span></span>user_1j2d6y6h2f29awcs1fz7axq8s
</span></span></code></pre>

On the Postgres side, as of writing this you'll need to add and load an extension for generating UUIDv7 identifiers - or you can search around for a (potentially slower) PSQL creation function.</p>
</blockquote>
TypeIDs in Diesel</h2>
When representing these identifiers in diesel</a> backed types, I wanted a type that wrapped uuid::Uuid</code> and was specific to the type and necessary {slug}_</code> prefix. I came up with the following solution:</p>
</span>/// A generic struct that we can implement the prefix over.
</span></span>#[derive(Clone, Copy, Debug, Eq, PartialEq)]
</span></span>pub </span>struct </span>UserIDPrefix;
</span></span>
</span></span>impl </span>TypedIDPrefix </span>for </span>UserIDPrefix </span>{
</span></span>    </span>/// The prefix that this should use for public representation.
</span></span>    </span>const </span>PREFIX</span>: </span>&'static </span>str </span>= </span>"user"</span>;
</span></span>}
</span></span>
</span></span>/// Export the complete type for use everywhere else.
</span></span>pub </span>type </span>UserID </span>= </span>TypedID<UserIDPrefix>;
</span></span></code></pre>
Your model or struct might then look as simple as:</p>
</span>#[derive(Clone, Identifiable, Queryable, Selectable)]
</span></span>#[diesel(table_name </span>=</span> crate::schema::users)]
</span></span>pub </span>struct </span>User </span>{
</span></span>    </span>pub </span>id</span>: UserID,
</span></span>    </span>pub </span>name</span>: String,
</span></span>    </span>pub </span>email</span>: String,
</span></span>    </span>// etc...
</span></span>}
</span></span></code></pre>
TypedID</code> itself is a type that transparently handles the following scenarios:</p>

Loading UUIDs from Postgres via Diesel</li>
Writing the UUID back to Postgres, or using it in queries</li>
Serializing the value in "public" form, with the {slug_ base32encodedUUID}</code> format</li>
Deserializing the value from the "public" form into the underlying uuid::Uuid</code>.</li>
</ul>

With the serde implementations, you can also use this type in HTTP handlers when using frameworks like axum</a>.</p>
</blockquote>

Note that this also uses the fast32</code></a> crate for base32 conversion. You can, of course, substitute whatever you'd like here.</p>
</blockquote>
</span>use </span>std</span>::</span>fmt;
</span></span>use </span>std</span>::</span>hash</span>::</span>Hash;
</span></span>use </span>std</span>::</span>io</span>::</span>Write;
</span></span>use </span>std</span>::</span>marker</span>::</span>PhantomData;
</span></span>use </span>std</span>::</span>ops</span>::</span>Deref;
</span></span>
</span></span>use </span>diesel</span>::</span>deserialize</span>::</span>FromSql;
</span></span>use </span>diesel</span>::</span>pg</span>::</span>{</span>Pg, PgValue</span>}</span>;
</span></span>use </span>diesel</span>::</span>serialize</span>::</span>{</span>IsNull, Output, ToSql</span>}</span>;
</span></span>use </span>diesel</span>::</span>sql_types</span>::</span>Uuid </span>as</span> PgUuid;
</span></span>use </span>diesel</span>::</span>*</span>;
</span></span>use </span>fast32</span>::</span>base32</span>::</span>CROCKFORD_LOWER</span>;
</span></span>use </span>serde</span>::</span>{</span>Serialize, Serializer</span>}</span>;
</span></span>use </span>serde</span>::</span>de</span>::</span>{</span>self</span>, Deserialize, Deserializer, Unexpected</span>}</span>;
</span></span>use </span>uuid</span>::</span>Uuid;
</span></span>
</span></span>/// A trait for denoting the prefix that a `TypedID<>`
</span></span>/// should use when displaying/formatting.
</span></span>pub </span>trait </span>TypedIDPrefix: Clone + Copy + fmt::Debug </span>{
</span></span>    </span>/// The prefix to use in IDs, 4 characters or less.
</span></span>    </span>///
</span></span>    </span>/// (Ideally 4 characters)
</span></span>    </span>const </span>PREFIX</span>: </span>&'static </span>str</span>;
</span></span>}
</span></span>
</span></span>/// A `TypedID` is made up of two parts:
</span></span>///
</span></span>/// - A `prefix`, a 4-character `&'static str` that's prepended
</span></span>/// - A (base32 encoded) `uuid` (v7) that forms the back half of the ID
</span></span>///
</span></span>/// The ID effectively ends up looking like (e.g):
</span></span>///
</span></span>/// ```no_run
</span></span>/// user_3LKQhvGUcADgqoEM3bh6psl
</span></span>/// ```
</span></span>#[derive(Clone, Copy, Debug, PartialEq, FromSqlRow, AsExpression, Eq)]
</span></span>#[diesel(sql_type </span>=</span> PgUuid)]
</span></span>pub </span>struct </span>TypedID<PrefixType>(PhantomData<PrefixType>, Uuid);
</span></span>
</span></span>impl</span><PrefixType> </span>fmt</span>::</span>Display </span>for </span>TypedID<PrefixType>
</span></span>where
</span></span>    </span>PrefixType: TypedIDPrefix,
</span></span>{
</span></span>    </span>/// Formats the value.
</span></span>    </span>fn </span>fmt</span>(</span>&</span>self</span>, </span>f</span>: </span>&mut </span>fmt</span>::</span>Formatter<'</span>_</span>>) </span>-> </span>fmt</span>::</span>Result </span>{
</span></span>        </span>write!(f, </span>"</span>{}</span>_</span>{}</span>"</span>, </span>PrefixType</span>::</span>PREFIX</span>, </span>CROCKFORD_LOWER</span>.</span>encode_uuid</span>(</span>self</span>.</span>1</span>))
</span></span>    </span>}
</span></span>}
</span></span>
</span></span>impl</span><PrefixType> Hash </span>for </span>TypedID<PrefixType>
</span></span>where
</span></span>    </span>PrefixType: TypedIDPrefix,
</span></span>{
</span></span>    </span>/// Enables using this type as a hashable value.
</span></span>    </span>fn </span>hash</span><H: </span>std</span>::</span>hash</span>::</span>Hasher>(</span>&</span>self</span>, </span>state</span>: </span>&mut</span> H) </span>{
</span></span>        </span>self</span>.</span>0.</span>hash</span>(</span>PrefixType</span>::</span>PREFIX</span>);
</span></span>        </span>self</span>.</span>1.</span>hash</span>(state);
</span></span>    </span>}
</span></span>}
</span></span>
</span></span>impl</span><PrefixType> Serialize </span>for </span>TypedID<PrefixType>
</span></span>where
</span></span>    </span>PrefixType: TypedIDPrefix,
</span></span>{
</span></span>    </span>/// Serializes the identifier as a String, in the form of
</span></span>    </span>/// `{prefix}_{base32encodeduuidv7}`.
</span></span>    </span>fn </span>serialize</span><S>(</span>&</span>self</span>, </span>serializer</span>: S) </span>-> Result<</span>S</span>::</span>Ok, </span>S</span>::</span>Error>
</span></span>    </span>where
</span></span>        </span>S: Serializer,
</span></span>    </span>{
</span></span>        </span>let</span> id </span>= </span>self</span>.</span>to_string</span>();
</span></span>        </span>serializer</span>.</span>serialize_str</span>(</span>&</span>id)
</span></span>    </span>}
</span></span>}
</span></span>
</span></span>impl</span><</span>'de</span>, PrefixType> Deserialize<</span>'de</span>> </span>for </span>TypedID<PrefixType>
</span></span>where
</span></span>    </span>PrefixType: TypedIDPrefix,
</span></span>{
</span></span>    </span>/// Attempts to deserialize the value. This checks the prefix on
</span></span>    </span>/// an ID string before attempting to deserialize the actual UUID portion.
</span></span>    </span>fn </span>deserialize</span><D>(</span>deserializer</span>: D) </span>-> Result<</span>Self</span>, </span>D</span>::</span>Error>
</span></span>    </span>where
</span></span>        </span>D: Deserializer<</span>'de</span>>,
</span></span>    </span>{
</span></span>        </span>// @TODO: Could this ever be &str?
</span></span>        </span>let</span> value: </span>String </span>= </span>Deserialize</span>::</span>deserialize(deserializer)</span>?</span>;
</span></span>
</span></span>        </span>for </span>(index, part) </span>in</span> value</span>.</span>split</span>(</span>"_"</span>)</span>.</span>enumerate</span>() </span>{
</span></span>            </span>if</span> index </span>== </span>0 </span>{
</span></span>                </span>if !</span>part</span>.</span>starts_with</span>(</span>PrefixType</span>::</span>PREFIX</span>) </span>{
</span></span>                    </span>return </span>Err</span>(</span>de</span>::</span>Error</span>::</span>invalid_value(
</span></span>                        </span>Unexpected</span>::</span>Str(</span>&</span>value),
</span></span>                        </span>&</span>PrefixType</span>::</span>PREFIX
</span></span>                    </span>));
</span></span>                </span>}
</span></span>
</span></span>                </span>continue</span>;
</span></span>            </span>}
</span></span>
</span></span>            </span>return match </span>CROCKFORD_LOWER</span>.</span>decode_uuid_str</span>(part) </span>{
</span></span>                </span>Ok</span>(id) </span>=> </span>Ok</span>(</span>Self</span>(PhantomData, id)),
</span></span>                </span>Err</span>(error) </span>=> </span>Err</span>(</span>de</span>::</span>Error</span>::</span>custom(error))
</span></span>            </span>}</span>;
</span></span>        </span>}
</span></span>
</span></span>        </span>Err</span>(</span>de</span>::</span>Error</span>::</span>invalid_value(</span>Unexpected</span>::</span>Str(</span>&</span>value), </span>&</span>PrefixType</span>::</span>PREFIX</span>))
</span></span>    </span>}
</span></span>}
</span></span>
</span></span>impl</span><PrefixType> ToSql<PgUuid, Pg> </span>for </span>TypedID<PrefixType>
</span></span>where
</span></span>    </span>PrefixType: TypedIDPrefix,
</span></span>{
</span></span>    </span>/// Writes the underlying uuid bytes to the output.
</span></span>    </span>fn </span>to_sql</span><</span>'b</span>>(</span>&'b </span>self</span>, </span>out</span>: </span>&mut </span>Output<</span>'b</span>, '</span>_</span>, Pg>) </span>-> </span>serialize</span>::</span>Result </span>{
</span></span>        </span>out</span>.</span>write_all</span>(</span>self</span>.</span>1.</span>as_bytes</span>())
</span></span>            </span>.</span>map</span>(|_| </span>IsNull</span>::</span>No)
</span></span>            </span>.</span>map_err</span>(</span>Into</span>::</span>into)
</span></span>    </span>}
</span></span>}
</span></span>
</span></span>impl</span><PrefixType> FromSql<PgUuid, Pg> </span>for </span>TypedID<PrefixType>
</span></span>where
</span></span>    </span>PrefixType: TypedIDPrefix,
</span></span>{
</span></span>    </span>/// Convert from the SQL byte payload into our custom type.
</span></span>    </span>fn </span>from_sql</span>(</span>bytes</span>: PgValue<'</span>_</span>>) </span>-> </span>deserialize</span>::</span>Result<</span>Self</span>> </span>{
</span></span>        </span>match </span>Uuid</span>::</span>from_slice(bytes</span>.</span>as_bytes</span>()) </span>{
</span></span>            </span>Ok</span>(id) </span>=> </span>Ok</span>(</span>Self</span>(PhantomData, id)),
</span></span>
</span></span>            </span>// For whatever reason, Diesel is able to just call `Into::into`
</span></span>            </span>// for this error - but doing that here fails?
</span></span>            </span>//
</span></span>            </span>// @TODO: Probably look into this at some point.
</span></span>            </span>Err</span>(error) </span>=> </span>Err</span>(error</span>.</span>to_string</span>()</span>.</span>into</span>())
</span></span>        </span>}
</span></span>    </span>}
</span></span>}
</span></span>
</span></span>impl</span><PrefixType> Deref </span>for </span>TypedID<PrefixType>
</span></span>where
</span></span>    </span>PrefixType: TypedIDPrefix,
</span></span>{
</span></span>    </span>type </span>Target </span>=</span> Uuid;
</span></span>
</span></span>    </span>fn </span>deref</span>(</span>&</span>self</span>) </span>-> &</span>Self</span>::</span>Target </span>{
</span></span>        </span>&</span>self</span>.</span>1
</span></span>    </span>}
</span></span>}
</span></span>
</span></span>impl</span><PrefixType> TypedID<PrefixType>
</span></span>where
</span></span>    </span>PrefixType: TypedIDPrefix,
</span></span>{
</span></span>    </span>/// Allocates and returns a new `String` in the
</span></span>    </span>/// `{prefix}_{base32encodeduuidv7}` format.
</span></span>    </span>pub </span>fn </span>to_string</span>(</span>&</span>self</span>) </span>-> String </span>{
</span></span>        </span>format!(</span>"</span>{}</span>"</span>, </span>self</span>)
</span></span>    </span>}
</span></span>
</span></span>    </span>/// Returns a copy of the underlying `Uuid`.
</span></span>    </span>pub </span>fn </span>uuid</span>(</span>&</span>self</span>) </span>-> Uuid </span>{
</span></span>        </span>self</span>.</span>1
</span></span>    </span>}
</span></span>}
</span></span></code></pre>


ORM-ish Diesel Helpers
Tue, 09 Jul 2024 00:00:00 +0000
In the Rust ecosystem, one of the more popular methods of interfacing with a database is diesel</a>. It's not an ORM, but it has some qualities that can make it feel like one.</p>
I'm working on a project where I wanted to add an admin interface for records that are more or less flat objects. Admin interfaces tend to very boilerplate-heavy, and this was no exception - so I wound up cobbling together a trait that enabled a slightly cleaner import and query structure for fetching and deleting entities.</p>
It's not a solution for every use case, and you probably don't want to blanket-apply this in all scenarios - but I've found it more handy than I originally figured it'd be and so decided I'd dump it here in case anyone else is looking (especially since it seems people have been poking at this topic around the internet for a few years now).</p>
As a bonus, jump to the next block for an async</code> implementation. Hope it helps!</p>
Sync Helpers</h2>
</span>use </span>diesel</span>::</span>{</span>Connection, OptionalExtension</span>}</span>;
</span></span>use </span>diesel</span>::</span>associations</span>::</span>HasTable;
</span></span>use </span>diesel</span>::</span>dsl</span>::</span>{</span>Find, Limit</span>}</span>;
</span></span>use </span>diesel</span>::</span>query_builder</span>::</span>{</span>DeleteStatement, IntoUpdateTarget</span>}</span>;
</span></span>use </span>diesel</span>::</span>query_dsl</span>::</span>{</span>LoadQuery, RunQueryDsl</span>}</span>;
</span></span>use </span>diesel</span>::</span>query_dsl</span>::</span>methods</span>::</span>{</span>FindDsl, LimitDsl</span>}</span>;
</span></span>
</span></span>/// A type alias just to make the trait bounds easier to read.
</span></span>type </span>DeleteFindStatement</span><</span>F</span>> =
</span></span>    </span>DeleteStatement<<F </span>as</span> HasTable></span>::</span>Table, <F </span>as</span> IntoUpdateTarget></span>::</span>WhereClause>;
</span></span>
</span></span>/// A trait that contains default implementations for common
</span></span>/// routines that we call very often. As long as a type derives
</span></span>/// `diesel::HasTable`, the methods on this trait will "just work"
</span></span>/// for certain common operations that we wind up polluting everywhere
</span></span>/// else. `HasTable` is generally derived on the core types that point
</span></span>/// to tables, so this comes "for free" in most cases.
</span></span>pub </span>trait </span>GenericModelMethods: HasTable </span>{
</span></span>    </span>/// Given an entity primary key, attempts to locate and return a record from 
</span></span>    </span>/// the database.
</span></span>    </span>///
</span></span>    </span>/// If no entity is found, this will return `Ok(None)` - it's effectively
</span></span>    </span>/// just masking the need to check for a diesel error type of `does not exist`
</span></span>    </span>/// or by filtering for something when we know it's either one or none.
</span></span>    </span>fn </span>find_by_pk</span><</span>'a</span>, PK, Conn>(
</span></span>        </span>conn</span>: </span>&mut</span> Conn,
</span></span>        </span>primary_key</span>: PK,
</span></span>    </span>) </span>-> Result<Option<</span>Self</span>>, </span>diesel</span>::</span>result</span>::</span>Error>
</span></span>    </span>where
</span></span>        </span>Self</span>: Sized,
</span></span>        </span>Conn: Connection,
</span></span>        </span>Self</span>::</span>Table: FindDsl<PK>,
</span></span>        </span><</span>Self</span>::</span>Table </span>as </span>FindDsl<PK>></span>::</span>Output: RunQueryDsl<Conn>,
</span></span>        </span>Find<</span>Self</span>::</span>Table, PK>: LimitDsl,
</span></span>        </span>Limit<Find<</span>Self</span>::</span>Table, PK>>: LoadQuery<</span>'a</span>, Conn, </span>Self</span>>,
</span></span>    </span>{
</span></span>        </span>let</span> entity </span>= </span>FindDsl</span>::</span>find(</span>Self</span>::</span>table(), primary_key)
</span></span>            </span>.</span>first</span>(conn)
</span></span>            </span>.</span>optional</span>()</span>?</span>;
</span></span>
</span></span>        </span>Ok</span>(entity)
</span></span>    </span>}
</span></span>
</span></span>    </span>/// Attempts to delete a row for the specified `primary_key`.
</span></span>    </span>///
</span></span>    </span>/// This will return the deleted row for any last minute usage.
</span></span>    </span>fn </span>delete_by_pk</span><</span>'a</span>, PK, Conn>(
</span></span>        </span>conn</span>: </span>&mut</span> Conn,
</span></span>        </span>primary_key</span>: PK
</span></span>    </span>) </span>-> Result<Option<</span>Self</span>>, </span>diesel</span>::</span>result</span>::</span>Error>
</span></span>    </span>where
</span></span>        </span>Self</span>: Sized,
</span></span>        </span>Conn: Connection,
</span></span>        </span>Self</span>::</span>Table: FindDsl<PK>,
</span></span>        </span>Find<</span>Self</span>::</span>Table, PK>: IntoUpdateTarget,
</span></span>        </span>DeleteFindStatement<Find<</span>Self</span>::</span>Table, PK>>: LoadQuery<</span>'a</span>, Conn, </span>Self</span>>
</span></span>    </span>{
</span></span>        </span>let</span> query </span>= </span>FindDsl</span>::</span>find(</span>Self</span>::</span>table(), primary_key);
</span></span>
</span></span>        </span>let</span> entity </span>= </span>diesel</span>::</span>delete(query)
</span></span>            </span>.</span>get_result</span>(conn)
</span></span>            </span>.</span>optional</span>()</span>?</span>;
</span></span>
</span></span>        </span>Ok</span>(entity)
</span></span>    </span>}
</span></span>}
</span></span>
</span></span>///	Implement generic methods for all types that implement `HasTable`.
</span></span>impl</span><T> GenericModelMethods </span>for </span>T
</span></span>where
</span></span>    </span>T: HasTable,
</span></span>{}
</span></span></code></pre>Async Helpers</h2>
</span>use </span>diesel</span>::</span>OptionalExtension;
</span></span>use </span>diesel</span>::</span>associations</span>::</span>HasTable;
</span></span>use </span>diesel</span>::</span>dsl</span>::</span>{</span>Find, Limit</span>}</span>;
</span></span>use </span>diesel</span>::</span>query_builder</span>::</span>{</span>DeleteStatement, IntoUpdateTarget</span>}</span>;
</span></span>use </span>diesel</span>::</span>query_dsl</span>::</span>methods</span>::</span>{</span>FindDsl, LimitDsl</span>}</span>;
</span></span>
</span></span>use </span>diesel_async</span>::</span>{</span>AsyncPgConnection, RunQueryDsl</span>}</span>;
</span></span>use </span>diesel_async</span>::</span>methods</span>::</span>LoadQuery;
</span></span>
</span></span>/// A type alias just to make the trait bounds easier to read.
</span></span>type </span>DeleteFindStatement</span><</span>F</span>> =
</span></span>    </span>DeleteStatement<<F </span>as</span> HasTable></span>::</span>Table, <F </span>as</span> IntoUpdateTarget></span>::</span>WhereClause>;
</span></span>
</span></span>/// A trait that contains default implementations for common
</span></span>/// routines that we call very often. As long as a type derives
</span></span>/// `diesel::HasTable`, the methods on this trait will "just work"
</span></span>/// for certain common operations that we wind up polluting everywhere
</span></span>/// else. `HasTable` is generally derived on the core types that point
</span></span>/// to tables, so this comes "for free" in most cases.
</span></span>#[allow(async_fn_in_trait)]
</span></span>pub </span>trait </span>GenericModelMethods: HasTable </span>{
</span></span>    </span>/// Given an entity primary key, attempts to locate and return a record from 
</span></span>    </span>/// the database.
</span></span>    </span>///
</span></span>    </span>/// If no entity is found, this will return `Ok(None)` - it's effectively
</span></span>    </span>/// just masking the need to check for a diesel error type of `does not exist`
</span></span>    </span>/// or by filtering for something when we know it's either one or none.
</span></span>    </span>///
</span></span>    </span>/// Note that this method cannot currently be generic over `AsyncConnection`
</span></span>    </span>/// due to a bug in lifetime inference in the Rust compiler.
</span></span>    </span>///
</span></span>    </span>/// (Sub your connection type, basically)
</span></span>    </span>async </span>fn </span>find_by_pk</span><</span>'a</span>, PK>(
</span></span>        </span>conn</span>: </span>&mut</span> AsyncPgConnection,
</span></span>        </span>primary_key</span>: PK,
</span></span>    </span>) </span>-> Result<Option<</span>Self</span>>, </span>diesel</span>::</span>result</span>::</span>Error>
</span></span>    </span>where
</span></span>        </span>Self</span>: Sized + Send,
</span></span>        </span>Self</span>::</span>Table: FindDsl<PK>,
</span></span>        </span><</span>Self</span>::</span>Table </span>as </span>FindDsl<PK>></span>::</span>Output: RunQueryDsl<AsyncPgConnection>,
</span></span>        </span>Find<</span>Self</span>::</span>Table, PK>: LimitDsl,
</span></span>        </span>Limit<Find<</span>Self</span>::</span>Table, PK>>: LoadQuery<</span>'a</span>, AsyncPgConnection, </span>Self</span>> + Send + </span>'a</span>,
</span></span>    </span>{
</span></span>        </span>let</span> entity </span>= </span>FindDsl</span>::</span>find(</span>Self</span>::</span>table(), primary_key)
</span></span>            </span>.</span>first</span>(conn)</span>.</span>await
</span></span>            </span>.</span>optional</span>()</span>?</span>;
</span></span>
</span></span>        </span>Ok</span>(entity)
</span></span>    </span>}
</span></span>
</span></span>    </span>/// Attempts to delete a row for the specified `primary_key`.
</span></span>    </span>///
</span></span>    </span>/// This will return the deleted row for any last minute usage.
</span></span>    </span>///
</span></span>    </span>/// Note that this method cannot currently be generic over `AsyncConnection`
</span></span>    </span>/// due to a bug in lifetime inference in the Rust compiler.
</span></span>    </span>///
</span></span>    </span>/// (Sub your connection type, basically)
</span></span>    </span>async </span>fn </span>delete_by_pk</span><</span>'a</span>, PK>(
</span></span>        </span>conn</span>: </span>&mut</span> AsyncPgConnection,
</span></span>        </span>primary_key</span>: PK
</span></span>    </span>) </span>-> Result<Option<</span>Self</span>>, </span>diesel</span>::</span>result</span>::</span>Error>
</span></span>    </span>where
</span></span>        </span>Self</span>: Sized + Send,
</span></span>        </span>Self</span>::</span>Table: FindDsl<PK>,
</span></span>        </span>Find<</span>Self</span>::</span>Table, PK>: IntoUpdateTarget,
</span></span>        </span>DeleteFindStatement<Find<</span>Self</span>::</span>Table, PK>>: LoadQuery<</span>'a</span>, AsyncPgConnection, </span>Self</span>> + Send + </span>'a</span>,
</span></span>    </span>{
</span></span>        </span>let</span> query </span>= </span>FindDsl</span>::</span>find(</span>Self</span>::</span>table(), primary_key);
</span></span>
</span></span>        </span>let</span> entity </span>= </span>diesel</span>::</span>delete(query)
</span></span>            </span>.</span>get_result</span>(conn)</span>.</span>await
</span></span>            </span>.</span>optional</span>()</span>?</span>;
</span></span>
</span></span>        </span>Ok</span>(entity)
</span></span>    </span>}
</span></span>}
</span></span>
</span></span>///	Implement async generic methods for all types that implement `HasTable`.
</span></span>impl</span><T> GenericModelMethods </span>for </span>T
</span></span>where
</span></span>    </span>T: </span>diesel</span>::</span>associations</span>::</span>HasTable,
</span></span>{}
</span></span></code></pre>


Pagination in Async Diesel
Fri, 10 May 2024 00:00:00 +0000
In the Rust ecosystem, there are quite a few ways to approach interacting with Postgres. One of
the older and more established libraries is diesel</a>, which effectively gives you
a Rust-wrapped path to constructing and executing queries. If it helps, you can think of it as a "light"
ORM.</p>
One of the bigger questions over the years has been whether diesel</code> not being "async by default" is an issue.
You could always wrap your queries in tasks and just await those, and that's probably fine - in fact, if I understand
correctly, this is what crates.io</a> does. However, diesel-async</a> also exists
for those who want to have a "pure" approach to the async interaction pattern. It's a smaller crate that effectively
just requires importing a few extra traits to "override" the core diesel</code> traits, and changing your connection type
to be an asynchronous one. Overall, I've found it works pretty well.</p>
One thing I did run into recently was needing some pagination for an admin interface I was throwing together.
diesel actually has an example for this</a> that
works well if you're using synchronous calls or wrapping in tasks, but
if you're using diesel-async</code>, you'll need to tweak some things to make it work. I figured I'd share my changes here
in case anyone needs them; yes, these could</em> be on GitHub, but I'm in a weird phase of re-evaluating my usage of the
platform, so I'm dumping it here.</p>
You're smart, you can figure it out. The only real changes needed were importing some diesel-async</code> items and tweaking
the bounds on load_and_count_pages</code> to accomodate the async differences. With this, you should be able to just call
.paginate(page)</code> on your queries and have mostly automatic paging. Enjoy.</p>
</span>use </span>diesel</span>::</span>pg</span>::</span>Pg;
</span></span>use </span>diesel</span>::</span>prelude</span>::</span>*</span>;
</span></span>use </span>diesel</span>::</span>query_builder</span>::</span>*</span>;
</span></span>use </span>diesel</span>::</span>sql_types</span>::</span>BigInt;
</span></span>
</span></span>// Import these, since we'll need them.
</span></span>use </span>diesel_async</span>::</span>AsyncPgConnection;
</span></span>use </span>diesel_async</span>::</span>methods</span>::</span>LoadQuery;
</span></span>
</span></span>pub </span>trait </span>Paginate: Sized </span>{
</span></span>    </span>fn </span>paginate</span>(</span>self</span>, </span>page</span>: </span>i64</span>) </span>-> Paginated<</span>Self</span>></span>;
</span></span>}
</span></span>
</span></span>impl</span><T> Paginate </span>for </span>T </span>{
</span></span>    </span>fn </span>paginate</span>(</span>self</span>, </span>page</span>: </span>i64</span>) </span>-> Paginated<</span>Self</span>> </span>{
</span></span>        </span>Paginated </span>{
</span></span>            </span>query: </span>self</span>,
</span></span>            </span>per_page: </span>DEFAULT_PER_PAGE</span>,
</span></span>            </span>page,
</span></span>            </span>offset: (page </span>- </span>1</span>) </span>* </span>DEFAULT_PER_PAGE</span>,
</span></span>        </span>}
</span></span>    </span>}
</span></span>}
</span></span>
</span></span>const </span>DEFAULT_PER_PAGE</span>: </span>i64 </span>= </span>10</span>;
</span></span>
</span></span>#[derive(Debug, Clone, Copy, QueryId)]
</span></span>pub </span>struct </span>Paginated<T> </span>{
</span></span>    </span>query</span>: T,
</span></span>    </span>page</span>: </span>i64</span>,
</span></span>    </span>per_page</span>: </span>i64</span>,
</span></span>    </span>offset</span>: </span>i64</span>,
</span></span>}
</span></span>
</span></span>impl</span><T> Paginated<T> </span>{
</span></span>    </span>pub </span>fn </span>per_page</span>(</span>self</span>, </span>per_page</span>: </span>i64</span>) </span>-> </span>Self </span>{
</span></span>        </span>Paginated </span>{
</span></span>            </span>per_page,
</span></span>            </span>offset: (</span>self</span>.</span>page </span>- </span>1</span>) </span>*</span> per_page,
</span></span>            </span>..</span>self
</span></span>        </span>}
</span></span>    </span>}
</span></span>
</span></span>    </span>// Mark the bounds on `T` and `U` to ensure the async calls compile correctly,
</span></span>    </span>// and have `results` go through the async `RunQueryDsl`.
</span></span>    </span>pub</span> async </span>fn </span>load_and_count_pages</span><</span>'a</span>, U>(
</span></span>        </span>self</span>,
</span></span>        </span>conn</span>: </span>&mut</span> AsyncPgConnection
</span></span>    </span>) </span>-> QueryResult<(Vec<U>, </span>i64</span>)>
</span></span>    </span>where
</span></span>        </span>T: </span>'a</span>,
</span></span>        </span>U: Send + </span>'a</span>,
</span></span>        </span>Self</span>: LoadQuery<</span>'a</span>, AsyncPgConnection, (U, </span>i64</span>)>,
</span></span>    </span>{
</span></span>        </span>let</span> per_page </span>= </span>self</span>.</span>per_page;
</span></span>        </span>let</span> results </span>= </span>diesel_async</span>::</span>RunQueryDsl</span>::</span>load</span>::</span><(U, </span>i64</span>)>(</span>self</span>, conn)</span>.</span>await</span>?</span>;
</span></span>        </span>let</span> total </span>=</span> results</span>.</span>first</span>()</span>.</span>map</span>(|</span>x</span>| x</span>.</span>1</span>)</span>.</span>unwrap_or</span>(</span>0</span>);
</span></span>        </span>let</span> records </span>=</span> results</span>.</span>into_iter</span>()</span>.</span>map</span>(|</span>x</span>| x</span>.</span>0</span>)</span>.</span>collect</span>();
</span></span>        </span>let</span> total_pages </span>= </span>(total </span>as </span>f64 </span>/</span> per_page </span>as </span>f64</span>)</span>.</span>ceil</span>() </span>as </span>i64</span>;
</span></span>        </span>Ok</span>((records, total_pages))
</span></span>    </span>}
</span></span>}
</span></span>
</span></span>impl</span><T: Query> Query </span>for </span>Paginated<T> </span>{
</span></span>    </span>type </span>SqlType </span>= </span>(</span>T</span>::</span>SqlType, BigInt);
</span></span>}
</span></span>
</span></span>impl</span><T> RunQueryDsl<PgConnection> </span>for </span>Paginated<T> </span>{}
</span></span>
</span></span>impl</span><T> QueryFragment<Pg> </span>for </span>Paginated<T>
</span></span>where
</span></span>    </span>T: QueryFragment<Pg>,
</span></span>{
</span></span>    </span>fn </span>walk_ast</span><</span>'b</span>>(</span>&'b </span>self</span>, </span>mut </span>out</span>: AstPass<'</span>_</span>, </span>'b</span>, Pg>) </span>-> QueryResult<()> </span>{
</span></span>        </span>out</span>.</span>push_sql</span>(</span>"SELECT *, COUNT(*) OVER () FROM ("</span>);
</span></span>        </span>self</span>.</span>query</span>.</span>walk_ast</span>(out</span>.</span>reborrow</span>())</span>?</span>;
</span></span>        </span>out</span>.</span>push_sql</span>(</span>") t LIMIT "</span>);
</span></span>        </span>out</span>.</span>push_bind_param</span>::</span><BigInt, </span>_</span>>(</span>&</span>self</span>.</span>per_page)</span>?</span>;
</span></span>        </span>out</span>.</span>push_sql</span>(</span>" OFFSET "</span>);
</span></span>        </span>out</span>.</span>push_bind_param</span>::</span><BigInt, </span>_</span>>(</span>&</span>self</span>.</span>offset)</span>?</span>;
</span></span>        </span>Ok</span>(())
</span></span>    </span>}
</span></span>}
</span></span></code></pre>


Plant-Based Berlin Recommendations
Mon, 15 Jan 2024 00:00:00 +0000
2023 has come and gone, and with it, a decent chunk of travel. The list below is an assortment of plant-based/vegan options in and around Berlin, Germany. I visited most of these during a recent trip, but never compiled them into a list until recently. I figure they're as good as anything for content to update this old still creaking along site - and it beats writing about tech for the millionth time.</p>
Eat</h2>

Dervish</a>

Vegan Uzbek cuisine. In a nightlife hotspot and open decently late, so you could do either lunch or dinner here. We never needed to make a reservation, and there are a number of other vegan restaurants on the stretch should they be full. It's not the best thing in the world, but it is cool just because it's pretty rare to find a vegan place that does this.</li>
Frea Bakery</a> / Frea Restaurant</a>

Zero-waste concept, all vegan. The bakery is two or so blocks from the restaurant, both are worth going to. The bakery is great for working out of if you're in need of space. Sanctuary - a vegan italian bakery - is around the corner, but if I had to choose one to go to, it'd probably be Frea. If you want the fine dining here but can't grab a booking, Cookies Cream or Lucky Leek are good second options.</li>
Vöner - doner kebab</a>

The original "vegan kebab" and pretty much still the best. I tried quite a few alternatives before finally coming here and wish I had just come here to begin with. Some reviews say the staff are rude or whatever, but I wound up talking to them for 15 minutes and they were super chill - YMMV but I wouldn't be put off by it.</li>
Chay Long P-Berg</a> / Chay Long Hasenheide</a>

Vegan Vietnamese with two locations. The menu is slightly different depending on which location you go to; we went to the Hasenheide location since it has a Bún Cá Hải Phòng on the menu that we hadn't seen elsewhere. I remember liking it, though my wife said it was good but not perfect. It's kind of a tough one to vegan-ize though.</li>
Tsu Tsu Kaarage</a>

We found this while walking around, pleasantly surprised since it gets close enough to what you'd want from kaarage. Small place with a few seats. There's also a pie shop around the corner from here that serves Oatly soft serve, but the name escapes me unfortunately.</li>
Kimchi Princess KBBQ</a>

KBBQ spot that - surprisingly - has two entirely vegan options. We tried the seitan one and it's decent enough, and it is</em> grilled in front of you, but they seem to not want you to handle the grill yourself which annoys me to no end. That said, I feel like finding this kind of thing with vegan options is already hard, so it was nice to experience again. They have tables for 2 if you don't want to be at a long table with others who grill meat or anything.</li>
la petite véganerie - brasserie</a>

This one is newer and we found it while looking for vegan steak. They basically try to properly recreate a French cafe style experience and have various cheeses/steaks/etc to pull it off. If you're looking into trying some plant-based steak options that we don't have in the USA - or are hard to get over here - this place can be fun. When we went the service was slower than I can possibly put into words, but it just seemed like growing pains and the staff were really chill. You can technically walk from here to Becketts Kopf if you want cocktails after.</li>
Tbilisi</a>

Georgian restaurant that has vegan options. We wanted</em> to go here as several friends recommended it, but it unfortunately got screwed schedule-wise. Listing it mostly on recs from others and for variety.</li>
Försters - Das Vegane Restaurant</a>

Because it's Berlin and you probably want some German food at some point. The website for this place is like... useless, but the food is decent and it's got massive portions for schnitzel. They also have options for the type of schnitzel, ranging from soy-based to... something else. I forget what. (Every list I read says to go to Vaust, but when we tried to go there they were really standoff-ish and said they weren't open anymore... well before their closed time... with no sign of an event going on. YMMV though.)</li>
</ul>
(I did</em> want to add in some easy vegan breakfast spots here, but my two go-tos - No Milk Today and Cafe Nullpunkt - unfortunately shuttered at the end of 2023. That said, most coffee shops I've been in there have some</em> vegan option nowadays due to how widespread the concept is.)</p>
Drink</h2>
Hope you enjoy your clothes reaking of smoke. For some of the below, reservations are a good idea.</p>

Timber Doodle</a> is a casual cocktail bar around the corner from Dervish that, if it's not too crowded, has some creative cocktails and good energy.</li>
Bar Becketts Kopf</a>

Yes, it's on the world's 50 best bars list or whatever. It's legitimately good for cocktail stuff though, and the wall art inside is... well, surreal. Pretty sure the door is unmarked.</li>
Buck and Breck</a>

Also on 50 best list but</em> drinks are legitimately good. No sign or anything so another unmarked bar, phones banned inside.</li>
Velvet</a>

Another cocktail bar but tends to focus more on seasonal/local ingredients. Near-ish to the Chay Long Hasenheide location if you want to stack them. We wandered in on an industry night and somehow got seated, so dunno what the normal menu is - but the vibe is great.</li>
Protokoll</a>

Craft beer options in Berlin generally suck but this place is decent with variety and vibe.</li>
Motif</a>

Natural wine bar + record shop. Out of the way, but if you're in the area it's cool to know about. Should</em> have vegan wines but you should of course ask.</li>
</ul>
Clubs</h2>

://about blank</code></a>

Industrial club that is larger than it seems. Indoor area with rotating genres but usually house, outdoor chill area, back building that rotates genres like 70s remixes or local artists. The back building is either really great or really "where the actual fuck am I" experience-wise, but the club overall is great albeit out of the way. They're strict about phone use, don't be a dick to the bouncers.</li>
</ul>
Shop</h2>

Veganz grocery store.

It's easy to find - right off a large train station - and you can't miss it. Fun to walk through if you like seeing what other vegan options are available outside the USA.</li>
</ul>


DriverKit, /Applications, and Quarantine
Wed, 15 Sep 2021 00:00:00 +0000
Earlier this year, I released a DriverKit-based port of GCAdapterDriver</a>. For the most part it's been pretty smooth sailing, once you get accustomed to how things work in a DriverKit-based world rather than Kext-based world. There's one odd bug that's sprouted up recently that only seems to be related to distribution, though - and I've not seen it noted anywhere else, so I figured I'd throw up a quick entry about it in case any other developers start trying to debug this.</p>
The Confusing Bug</h2>
The bug is simple (ish) in nature, but only shows up when you're shipping your application. Some quick context: DriverKit-based applications must</em> be in /Applications</code> in order to load an extension (at least, when a user has System Integrity Protection enabled). If your user doesn't place the app in there and attempts to install the extension, the resulting error will be OSSystemExtensionErrorDomain Code 3</code>, which roughly corresponds to: Application is not in /Applications</em>.</p>
Now, users of GCAdapterDriver started getting this message even though the app was</em> in the /Applications</code> folder. Odd, right? I started going through the usual debugging experience, making sure it was installed correctly, and that they had restarted the app after moving it into the folder (if they had started previously). All this turned up fine, though.</p>
So what's going on?</p>
Enter: Quarantine</h2>
A fitting title for the past year and some change, I guess.</p>
I recalled from other projects that if the com.apple.quarantine</code> attribute was on an Application bundle, it could cause some odd errors to occur. This generally happens when an app is downloaded from the internet and flagged; for whatever reason, it sometimes doesn't get cleared when the user trusts the app. I've mostly seen this with Chrome, but I see no reason for it to not happen with any other browser.</p>
In this case, I asked the user to check their status with the following:</p>
</span>xattr</span> /Applications/GCAdapterDriver.app
</span></span></code></pre>
Which, sure enough, produced the following:</p>
</span>com.apple.quarantine
</span></span></code></pre>
On a hunch, I asked them to clear the attribute - which you can do with the following:</p>
</span>sudo</span> xattr</span> -r -d</span> com.apple.quarantine /Applications/GCAdapterDriver.app
</span></span></code></pre>
Lo and behold, after starting the app in a non-quarantined</em> state, the driver activation worked just fine.</p>
Is this really a bug?</h2>
It's hard to say. I can see some logic for not activating a quarantined app's driver, but at the very least I think the error should be updated to spot the case where the application is in /Applications</code> and the quarantine attribute is what's blocking driver activation. I've filed feedback (FB9628611) for this, so here's hoping it gets updated in Monterey at least.</p>


Debugging Broken Signed/Notarized Apps on macOS
Thu, 24 Jun 2021 00:00:00 +0000
Consider the following: you've built a macOS app (perhaps outside of Xcode), signed and notarized it, and see no errors in your build log. This is a common scenario for CI (Continuous Integration) build pipelines.</p>
Now you run the resulting .app</code> bundle... and the OS screams at you that the bundle is broken, and should be moved to the trash. What gives?</p>
A Green Frog</h2>
One project I poke at from time to time - mostly with odd and/or esoteric macOS-related things - is Project Slippi</a>. Earlier this week, they released a new Launcher</a>, which helps with a number of things related to viewing replays, automatic updating, and more. Initial testing across the various Operating Systems seemingly went okay, but on release users started reporting that the macOS build started throwing up the aforementioned "bundle is broken"</em> notification.</p>
Nikhil</a> reached out to me fairly quickly, and we went back and forth for a few minutes debugging. Poking and prodding at the bundle structure brought up nothing special, with nothing out of place (i.e, it was a well-formed bundle). I decided to then see if maybe signing or notarizing had broken somehow. The steps I tend to default to are below, but if you want to do some more reading about the various incantations, I highly recommend this Eclectic Light post</a>.</p>
</span># Checks and displays signature information
</span></span>codesign</span> -dvvv</span> /path/to/app
</span></span>
</span></span># Checks and displays notarization status
</span></span>spctl</span> -a -vv -t</span> install /path/to/app
</span></span></code></pre>
Running the latter ultimately produced something useful to go on: a sealed resource is missing or invalid</code>.</p>
Resource Oddities</h2>
Unfortunately, that error message is a little light on details. Still, we can debug further. Scanning CI build pipeline instructions verified it hadn't been changed, and the output had no warning or error messages. We also reviewed the CI build to make sure the bundle wasn't tampered with after being built/signed/notarized, and this too checked out... so what on earth is this error?</p>
One piece of Apple documentation that never seems to show up in search engines (for me, at least) is how to actually troubleshoot failing signatures</a>. It's a shame, too, because there's an incredibly useful codesign incantation in here that leads right to the error:</p>
</span>codesign</span> --verify </span>\
</span></span>    </span>-vvvv </span>\
</span></span>    </span>-R</span>=</span>'anchor apple generic and certificate 1[field.1.2.840.113635.100.6.2.1] exists and (certificate leaf[field.1.2.840.113635.100.6.1.2] exists or certificate leaf[field.1.2.840.113635.100.6.1.4] exists)' </span>\
</span></span>    </span>/path/to/the.app
</span></span></code></pre>
Running the above brings us a slightly confusing (but still useful) error message:</p>
</p>
Wat.</p>
Special Character Issues...?</h2>
These are files used in showing what stage a game was played on. The app uses the filename as a key to display the appropriate image... and for whatever reason, the accented é</code> causes issues in signature verification.</p>
Vinceau</a> thankfully had a quick fix</a>: just rename all the images to key on stage ID. After kicking CI to rebuild, the resulting bundle successfully passed signature verification.</p>
This post illustrates a seemingly simple to debug issue, but one that I've found elusive on details for discerning the root cause. Hopefully this helps someone else in the future.</p>


Cacao: Building macOS (and iOS) Apps in Rust
Thu, 10 Jun 2021 00:00:00 +0000
Building native macOS apps outside the normal Apple ecosystem is sometimes a not-so-obvious
task. The shifting ecosystem of AppKit, Catalyst, and SwiftUI - coupled with documentation that's
sometimes non-existent, or spanning multiple operating system versions that each have their own nuance -
makes it tricky to know just what you need to tie into.</p>
One language that I've felt hasn't had a great solution to this yet is Rust. I've released an initial version of
Cacao</a>, which is my effort to enable building macOS (and iOS, see below) apps in Rust. This post showcases a bit of what Cacao is, how it works, and includes some opinions on GUI work sprinkled throughout.</p>
History, Rust and Objective-C</h2>
I should clarify something before going any further. When I say that Rust hasn't had a great solution to this yet, I mean
that there hasn't been an elegant way to build a macOS app in Rust. There is a litany of prior work though - some of which Cacao uses.</p>

The objc</a> crate by SSheldon</a> has been around for years now, and does a very good job of providing a way to bridge Rust with Objective-C. Cacao relies on this heavily for bridging with the Apple side of things.</li>
Delisa Mason wrote</a> about building macOS apps in Rust as far as back as 2016, and the examples repository</a> still holds up.</li>
The core-foundation</a> crate is often passed around as the "way" to build macOS apps in Rust. As far as I know, this was originally built to help Mozilla and Servo. It's a good crate, but I feel it's not as simple, and doesn't expose certain patterns that help make a macOS app feel "right".</li>
fruity</a> and objrs</a> both attempt to offer better interop with the Objective-C side of things. Neither is used by Cacao, but I felt they're worth mentioning as they both are decent reading anyway.</li>
</ul>
Each of these are great works on their own, but none of them contribute to what I feel is a "native" macOS API style in Rust.</p>
Feeling Native</h2>
So, let's define native</em>.</p>
When you build a macOS app in the standard, conventional way (AppKit), your primary building block is your Application Delegate</em>. This is effectively where you receive varying messages from the OS (notifications, lifecycle events), and then handle them accordingly. The above examples don't provide a simple way to do this, and feel very procedural. Trying to go against the grain on macOS development often becomes annoying very quickly, and thus I define native</em> as being able to replicate the intended pattern of development.</p>
Let's look at a basic Swift macOS window example. Note that we're doing this in a no-storyboards or interface-builder fashion, as that's what Rust equivalent code will be doing; it's entirely fair to say that this could be shorter if you're the type to use Interface Builder.</p>
</span>import </span>Cocoa
</span></span>import </span>Foundation
</span></span>
</span></span>class </span>AppDelegate</span>: </span>NSObject</span>, </span>NSApplicationDelegate</span> {
</span></span>    </span>var </span>window</span>: </span>NSWindow</span>?
</span></span>    </span>
</span></span>    </span>func </span>applicationDidFinishLaunching</span>(</span>_ </span>aNotification</span>: </span>Notification</span>) {
</span></span>        </span>let</span> frame = </span>CGRect</span>(
</span></span>            </span>x</span>: </span>10.0</span>,
</span></span>            </span>y</span>: </span>10.0</span>,
</span></span>            </span>width</span>: </span>400.0</span>,
</span></span>            </span>height</span>: </span>400.0
</span></span>        </span>)
</span></span>        </span>
</span></span>        </span>let</span> win = </span>NSWindow</span>(</span>contentRect</span>: frame, </span>styleMask</span>: [
</span></span>            </span>.</span>closable</span>, .</span>fullSizeContentView</span>, .</span>miniaturizable</span>, .</span>fullScreen</span>, 
</span></span>            </span>.</span>resizable</span>, .</span>unifiedTitleAndToolbar
</span></span>        </span>], </span>backing</span>: .</span>buffered</span>, </span>defer</span>: </span>true</span>)
</span></span>        </span>
</span></span>        </span>win</span>.</span>title = </span>"Hello world"
</span></span>        </span>win</span>.</span>makeKeyAndOrderFront(</span>nil</span>)
</span></span>        </span>window = win
</span></span>    </span>}
</span></span>}
</span></span>
</span></span>// Just for running the app without all the Xcode @main items.
</span></span>let</span> delegate = </span>AppDelegate</span>()
</span></span>NSApplication</span>.</span>shared</span>.</span>delegate = delegate
</span></span>_</span> = </span>NSApplicationMain</span>(</span>CommandLine</span>.</span>argc, </span>CommandLine</span>.</span>unsafeArgv)
</span></span></code></pre>
All things considered, that's pretty succinct - even the Objective-C version wouldn't be much longer! What I take note of here is specifically the applicationDidFinishLaunching(_:)</code> method: this is a delegate method, and is a prime example of what I wanted in Rust. With Cacao, I feel like it gets fairly close:</p>
</span>use </span>cacao</span>::</span>macos</span>::</span>{</span>App, AppDelegate</span>}</span>;
</span></span>use </span>cacao</span>::</span>macos</span>::</span>window</span>::</span>Window;
</span></span>
</span></span>#[derive(Default)]
</span></span>struct </span>BasicApp </span>{
</span></span>    </span>window</span>: Option<Window>
</span></span>}
</span></span>
</span></span>impl </span>AppDelegate </span>for </span>BasicApp </span>{
</span></span>    </span>fn </span>did_finish_launching</span>(</span>&</span>self</span>) </span>{
</span></span>        </span>let</span> window </span>= </span>Window</span>::</span>default();
</span></span>        </span>window</span>.</span>set_minimum_content_size</span>(</span>400.</span>, </span>400.</span>);
</span></span>        </span>window</span>.</span>set_title</span>(</span>"Hello World!"</span>);
</span></span>        </span>window</span>.</span>show</span>();
</span></span>
</span></span>        </span>self</span>.</span>window </span>= </span>Some</span>(window);
</span></span>    </span>}
</span></span>}
</span></span>
</span></span>fn </span>main</span>() </span>{
</span></span>    </span>App</span>::</span>new(</span>"com.hello.world"</span>, </span>BasicApp</span>::</span>default())</span>.</span>run</span>();
</span></span>}
</span></span></code></pre>
Here, we do roughly the same thing as our Swift example, albeit even more succinct due to being able to take advantage of Default</code> in Rust. App</code> wraps NSApplication</code>, and marshals events and method calls over to the AppDelegate</code> trait implementation. For macOS, most of the NSApplicationDelegate</code> methods and events are supported - although I haven't gotten around to wrapping NSNotification</code> and passing it in to some methods. Pull requests welcome. :)</p>
From here, you could continue with Cacao, or defer to another framework of your choice and simply rely on Cacao for the "mac" pieces. In fact, each Cacao control exposes a public objc</code> property, which you can lock on and message pass to directly. This enables usage of other Rust wrappers (e.g, Metal), so you're not locked in to any one thing about Cacao.</p>
On Subclassing</h2>
Rust doesn't have a concept of a Class</code> built in to the language, instead favoring more of a composition-based approach with trait implementations. Many existing GUI models are subclass-heavy, though, and working with them can feel a bit odd from the Rust side. gtk-rs</a> provides some utilities for working with subclasses from the Rust side, but what if we could keep it composition-based?</p>
Cacao supports this, in a sense. Most widget types can be declared one of two ways: stock, in which you can call into it and set your properties, and treat it like a normal control - or delegated, where you can provide a struct that implements a trait for a given widget. For example, the View</code> type could be constructed this way:</p>
</span>let</span> view </span>= </span>View</span>::</span>default();
</span></span>// Customize your view
</span></span></code></pre>
This works fine - you could build up a tree from here and slap it wherever you want. If we did it as a delegate pattern, it'd look like this:</p>
</span>#[derive(Debug)]
</span></span>pub </span>struct </span>MyView </span>{
</span></span>    </span>handle</span>: Option<View>
</span></span>}
</span></span>
</span></span>impl </span>ViewDelegate </span>for </span>MyView </span>{
</span></span>    </span>fn </span>did_load</span>(</span>&mut </span>self</span>, </span>view</span>: View) </span>{
</span></span>        </span>// Customize your view
</span></span>        </span>self</span>.</span>handle </span>= </span>Some</span>(view);
</span></span>    </span>}
</span></span>
</span></span>    </span>// You could implement further methods here for handling drop and drop, etc
</span></span>}
</span></span>
</span></span>// elsewhere...
</span></span>let</span> view </span>= </span>View</span>::</span>with(</span>MyView</span>::</span>default());
</span></span></code></pre>
Feels kind of familiar, right?</p>
A friend of mine once told me over beers: "If you go more than one subclass deep, you've done something wrong"</em>. Over the years, I've come around to this point of view, and I feel this approach fits that mantra perfectly - it feels like a subclass, in that you have a place to localize the logic and control setup, implement event handlers, and so on - but you can't go further into subclass hell.</p>
The State of Things</h2>
As I'm writing this, Cacao is 0.2.0</code>. It would</em> be 0.1.0</code>, but crates.io has a bit of a squatting issue, so 0.1.0</code> didn't truly exist.</p>
It currently supports enough widgets on macOS to be usable. You can check out the examples</a> folder to see more.</p>
</p>
iOS support... it's more of a demo, but there's nothing really blocking controls from being ported other than the time investment.</p>
Who's this even for...?</h2>
I don't expect that anybody would say to themselves "alright, time to write/rewrite macOS apps in Rust". I would expect that Cacao would never be able to be as usable as the blessed layers and frameworks that can be found with Swift and Objective-C, and I don't see the crossover between Apple-ecosystem developers and Rust-developers needing GUI tools to be massive.</p>
I do see Cacao being useful for some things, though:</p>
Rust-based Utilities</h3>
I think it's conceivable that there are Rust-based utilities (scripts, etc) that could be useful with a GUI, but bridging is (frankly) boring work, and frustrating when it goes wrong. Cacao is useful in this scenario as it enables building a native macOS GUI without having to leave the Rust ecosystem.</p>
Cross-Platform GUI Framework</h3>
My dream for a Rust GUI framework is simple:</p>

Target only the big three (Windows, macOS, Gnome). Anything else can be community supported. Maybe</em> iOS and/or Android, if the effort isn't too signficant.</li>
Offering more than the basic controls makes the framework unmaintainable over time. Follow the web model and keep the kitchen sink barebones, even if it's annoying. Long term maintainability > a million widgets.</li>
Always expose a native hook on each control for the cases where someone knows what they want. AKA, get out of the way when asked.</li>
A declarative (non-JSX-ish) model. Basically, copy SwiftUI.</li>
</ul>
I think some combination of winsafe</a>, gtk-rs</a>, and cacao</a> could achieve this. If it happens, I'm happy to repurpose alchemy</a> for this and make it a community thing - it was my original attempt at building a Rust cross-platform GUI, until I was sidelined by life events.</p>
On iOS</h2>
A cool thing about Cacao is that the approach can work on iOS (and, presumably, tvOS) too. While support is currently very alpha in comparison to macOS, you are able to build a proper iOS app and run it</a>:</p>
</p>
This implements the newer UIScene</code> API, meaning you should have a modern app that works well across both iOS and iPad (and in particular supports the iPad multi-app capability).</p>
Going Forwards</h2>
Part of why I wanted to push out 0.2.0</code> is for community usage. I'm curious to see how people like it, whether it sees adoption, and so on. The documentation isn't perfect by any means (I welcome pull requests on this, although I'll continue to work on it as well), but I'm hopeful that feedback drives it forward.</p>
In the long (long) term, I think frameworks like this will fade into the background and become building blocks for something like a RustUI (akin to SwiftUI with AppKit/UIKit). This is fine, and I consider it a win if Cacao acts as a bridge between UI generations.</p>


What Melee Gave Me
Fri, 20 Nov 2020 00:00:00 +0000
On or around November 19th, 2020, The Big House - one of the largest and storied tournaments for Super Smash Bros. Melee - received an unfortunate cease and desist notice</a> from Nintendo of America, Inc.</p>
Referenced in the matter is Slippi</a>, a fan made, and supported, method of playing Melee online utilizing rollback</a>, providing an almost console-level experience when it comes to netplay latency. In a year full of unpredictable events, and the worst pandemic of our lifetimes, Slippi has been vital in ensuring the health of the Melee scene without</em> risking the health of individuals.</p>
I'm not a lawyer, nor do I know the specifics of the cease and desist that The Big House received, so I can't comment on that. However, I wish Nintendo would reconsider their stance - I've been playing Melee since launch day, and it's meant the world to me, so I think it's worth sharing this.</p>
For full disclosure, I've contributed to the Slippi project over the past few months - primarily on the Mac side of things, helping to ensure things work well there. I do it mostly because it feels like giving back to a game and community that gave me what you'll read below. With that said: none of the opinions in this post should be taken as representative of the Slippi team at all, though - mine, and mine alone.</p>
Melee and Me</h2>
Super Smash Bros. Melee was released on Dec 3rd, 2001. I got my Gamecube shortly after, and with it, a copy of Melee. While I'd been playing fighting games for as long as I could remember (going all the way back to Street Fighter 2, then moving into the era of Third Strike, Marvel vs Street Fighter/Capcom, and so on - along with the requisite Smash 64 experience), this game immediately felt different</em>. Not necessarily better</em>, but expressive in a way they weren't - from graphics, to sound design, to movement options, to stage design and more, I was enthralled in a way no game had managed before.</p>
I come from a rather large family (I'm the oldest of 7...), so we always had enough people to play with. We started, like many, with your standard Free-For-All matches on Hyrule Temple, moving on to trying every item option possible, exhausting the single player modes, and finding every trophy. At a certain point, the game felt complete... but fighting games have a competitive aspect to them, and there's always someone to try and beat.</p>
So I found the competitive scene, and dabbled on and off. In the interest of keeping this readable, we're going to skip ahead a bit - just know that Melee was there for some of the most difficult and formative periods of my life.</p>
Melee and Jamss</h2>
My youngest brother, Jake (or as he was known online, @notjamss</a>), first found Melee by chance: walking through the living room while I was watching a tournament, and asking what it was. So we hung out there, and I started to explain the game, from tournament lore, to techniques and more. He was hooked - and wrote about it once, if you wanted his take</a>.</p>
Our family is from Northern Virginia, so it was perhaps natural that we'd want to attend SmashCon</a>. We first went in 2016; for Jake, it was his first exposure to the competitive scene in real life, and we made plans to attend again. We missed 2017 due to my travel schedule, but we did hit 2018... albeit under some tougher circumstances.</p>
You see, in February of 2018, Jake was diagnosed with a combination of Acute Myleoid and Acute Lymphoid Leukemia. This required an immediate, and ultimately long, stay in the hospital. Our Father was (literally) always there with him, but the rest of us siblings would take turns staying with him. His room was almost amusing, considering everything we moved in there to make it better for him - including, most importantly, a working Melee setup.</p>
And so play Melee, we did. A ton.</p>
</p>
The Community</h2>
In an attempt to keep his spirits up in the hospital, I decided to see if I could put together some surprises for him. Through a friend of my lovely wife, we got Twitch to send him a care package. He had a fledgling interest in coding, so I sat with him and we put together a basic Smash.gg app</a>, which wound up bringing a swag package from them as well. He'd alternate Twitch and Smash.gg hoodies for his walks around the hospital, and always seemed happy to explain them to anyone curious.</p>
Most notably, though, was reaching out to Panda Global, who sent him a jersey that he could be found wearing... pretty much every day.</p>
</p>
Graciously, they also said they'd be happy to meet and play with him if SmashCon 2018 was able to work out. I didn't tell Jake this, but I did tell him that if he made it out of the hospital by SmashCon I'd be happy to take him. His doctors worked tirelessly - and amazingly, he was able to go to outpatient treatment, albeit wearing a mask all the time (before it was popular).</p>
The timing was tight, but I flew back, and off to SmashCon we went.</p>
SmashCon 2018</h2>
Much has been written about this tournament elsewhere, and I encourage you to read (or watch!) it if you haven't: pretty much every game had fun sets and great Grand Finals, coupled with SmashCon's generally great setup for chilling and playing.</p>
Jake and I spent our time roaming around, playing various games and browsing the merchandise stalls. Jake got to meet up with some members of the community he'd been friends with for a bit, and the Panda Global crew made him feel like a VIP - MVD and Wobbles (Panda Global players at the time) in particular were great, with MVD somehow finding Jake in the crowd and welcoming him personally. Wobbles welcomed Jake into some friendlies and spent time showing him tech, and signed his new controller to replace the one from 2016.</p>
A very friendly Panda Global representative, who I've unfortunately forgotten the name of, eventually found us and asked Jake if he'd like to meet Plup and play some games with him. Jake jumped at the chance, and they played for about an hour or so. If I recall correctly, Plup wasn't feeling the best, but still went out of his way to do this - and it meant a lot to Jake.</p>
</p>
To top it all off, we watched what is one of the greatest Grand Finals set of all time (and the final US singles set before Armada's sudden retirement). Here, Melee gave me one of the best weekends of my life.</p>
 We left SmashCon 2018 feeling great, and we'd continue our general tournament watching and netplay sessions. Since I was located in Seattle, this became our way of staying close even when I couldn't hang with him in-person.</p>
Eventually, Jake made it to a stable enough place to go for a bone marrow transplant (and thankfully, one other sibling was a good match). He got it, and we waited to see if it worked.</p>
Saying Goodbye</h2>
Unfortunately, science just sucks sometimes. The doctors did everything they could, but it looked as if it just wasn't taking - Jake's cancer was pretty rare, and options became limited to comfort to ride it out. Jake would ultimately pass at home, surrounded by family and without pain. We miss him every day.</p>
For me, I've struggled to write about this experience since it happened, and it's the subject of another blog post that I'll eventually finish writing, when the words come. What I wanted to showcase here, though, happened shortly before Jake passed.</p>
Before death, some experience what's known as a "surge" or "rally" - a noticeable, but short, return to energy and form. It can be jarring to witness, mostly due to the juxtaposition of watching the decline beforehand - but in a way, it's beautiful too. Jake had a rally, and he looked up, and asked if we wanted to play Melee.</p>
We all kind of just looked around, and then said yes. We played a few one on one, and then we swapped out and played group games with the cast of siblings.</p>
</p>
To this day, they were the most surreal games of Melee I've ever played.</p>
Some quick additional context might explain. Fighting games in general (and Melee in particular) are incredibly complex games, and Melee served as a great test for eyeing decline. When we'd play in the hospital, or over netplay, Jake and I would often ask each other if his reactions started to get slower, or if the game became difficult to play - for example, hands not listening, or being unable to process things on screen. Against the odds (and likely thanks to the support of his incredible doctors), he never really declined.</p>
Except towards the end of those last games.</p>
Jake had never really talked much about the concept of death, other than being proud that any research or efforts on his condition might be helpful to others down the road. I spent a few months struggling to parse these games, until one day I realized that Melee had transcended just being a game for us - it was a language, and that was our goodbye. We were given closure in a package I didn't understand, but to this day I'm thankful for it.</p>
On Melee</h2>
This post leans heavily personal, and I'd forgive anybody for wondering how this pertains to the Big House Online cease and desist.</p>
Simply put: I wanted to showcase what Melee gave me. The game is approaching 20 years old</em>, and while I understand Nintendo wanting to protect copyright and trademark and so on, there comes a time where, like any child, it ceases to just be a product of your own creation.</p>
Melee as an experience is defined</em> by the 20 year rollercoaster of a community it developed. There is no other Smash Bros. game that has reached the level that Melee has, and there is no technological achievement, or cast of characters, or quirky mechanics that can match it - because Nintendo, frankly, did not create the part of Melee that matters now. But they could be a part</em> of it.</p>
Nintendo, if you happen to read this: I get that you're the "family friendly" company, and I understand you're a business. But families come in different shapes and sizes, and Melee meant more to mine than you could possibly imagine.</p>
I implore you to reconsider your position, and find a way to get okay with streaming tournaments.</p>


You Did Not EARN IT
Sun, 15 Mar 2020 00:00:00 +0000
In the midst of a global pandemic, there's a bill moving through the Senate that has massive ramifications for private companies and platforms utilizing encryption to secure user data. Smarter people than me have written in depth about it, and I urge you to read their take and contact your representatives to take action against this bill.</p>
Essential Reading</h2>

EARN IT is a direct attack on end-to-end encryption</a></li>
THE EARN IT ACT IS HERE. SURPRISE, IT’S STILL BAD NEWS.</a></li>
ACLU and AFP to Congress: “EARN IT” Act Jeopardizes Every Americans’ Private Communications</a></li>
EARN IT Act Threatens Encryption, Free Expression, and Prosecutions of Child Exploitation</a></li>
</ul>
Contact Your Representatives</h2>
If you can take action, contact your representatives and ask them to vote against or condemn this bill. The passage of this would cause serious harm to users, ranging from the general web-browsing population to activists and targeted groups (e.g, minorities). I've included a copy of the letter I sent to my representatives earlier this week - feel free to use it as a base when contacting your own. If you're unsure where to look or how to contact your representatives, check out this EFF tool for getting started</a>.</p>



I'm writing today to ask you to consider voting against the EARN IT act currently making its way through the Senate. While the act is targeting the very serious issue of child exploitation, it does so in an overly broad way that threatens the foundations of the internet. The bill effectively proposes the creation of a government-funded commission that would be tasked with establishing U.S. government dictated best practices for private-sector companies and services in regards to detecting Child Sexual Abuse Material, or "CSAM".</p>
Private companies that would be threatened by this already work to aggressively detect, flag, and address harmful content (CSAM), and are actively engaged in working with the government to further this work. Passage of this bill, however, would ensure that the freedoms the internet has held, which allowed it to grow and innovate on an unprecedented scale, would effectively be tied to Attorney General signoff.</p>
The bill (indirectly, but notably) curtails the ability for private companies to design secure products and services. These types of development require strong encryption, both for systems like digital commerce, as well as the safety of users - including children.</p>
Allowing this type of legislation to pass under an adminstration that has seen fit to strip away civil liberties is a frightening prospect that must be rejected.</p>
</blockquote>


Wobbling in Rust
Wed, 01 Jan 2020 00:00:00 +0000
In 2019, one of my goals was to get back to writing here more regularly. I'm proud to say I was mostly successful in that endeavor: it was certainly an increase from the amount written in 2018, and absolutely a win over 2017 (which saw... no posts). I think personal websites still have value in the modern era, and so I'm going to continue this goal in 2020 and try to write at least a post a month.</p>
To start things off, I figured this'd be an amusing topic - equal parts stupid, dangerous, and potentially useful.</p>
How to never fail in Rust</h2>
Let's say that you've got a task you need to run. For whatever reason, a multitude of runtime errors can occur where you need to just keep retrying - for example, an upstream network endpoint is finnicky and drops the connection sometimes, and resuming is not an option. It can panic due to a third party library, too - Rust is still a newer language, even with the insane growth it's seen the past few years, so this isn't too out there concept-wise.</p>
Assuming we have a method like the following:</p>
</span>use </span>std</span>::</span>error</span>::</span>Error;
</span></span>
</span></span>fn </span>do_something</span>() </span>-> Result<(), Box<dyn Error>> </span>{
</span></span>    </span>// Code that could potentially Err() or panic
</span></span>    </span>Ok</span>(())
</span></span>}
</span></span></code></pre>
Our goal is simple: how do we just keep retrying this thing, results be damned?</p>
Unwinding a panic</h2>
In the standard library, we can find some methods that are useful for this problem. The one we use below is std::panic::catch_unwind</code></a>, which will catch unwinding</em> panic events. Note that this doesn't cover every type of panic event - as the docs point out, one that aborts the process will bypass this entirely.</em> It returns a Result</code>, where the Ok</code> variant is just the result of a passed in closure, and the Err</code> variant being the cause of the panic.</p>

Hey, listen! This is a Footgun.</h4>
The docs do point out that you should not use this as a general try/catch mechanism. They're right.</strong></p>
My use case for this was a panic happening somewhere in ssh2</a></code>, where I'd occassionally run into a panic due (seemingly) to it linking against C code. In my particular case, it was easier to just keep trying since it was randomly failing, but would work 100% fine the rest of the time.</p>
It's entirely possible this was a bug in an older version of ssh2</code> and would not happen today. Consider this trick a footgun and only contemplate using it if you're truly in a situation that requires it.</p>
You've been warned!</p>
</div>

Corrections as of March 19th, 2020</h4>
A few weeks after this was posted, it wound up /r/rust</a>, where /u/najamelan and /u/viaxxdev</a> pointed out some issues with the original code in this post. This has been updated to take their points into account, and major thanks to them for catching it!</p>
Later in the day, type_N_is_N_to_Never</a> also noted that this could be reduced down - so the code block below now uses that approach, as it's cleaner and arguably easier to digest. Nice!</p>
</div>
Disclaimers out of the way, we now know how to catch and loop a panic. The code below illustrates a naive way to loop and handle panic events. Notice we mark the passed in closure as requiring RefUnwindSafe</code></a>.</p>
</span>use </span>std</span>::</span>error</span>::</span>Error;
</span></span>use </span>std</span>::</span>panic</span>::</span>{</span>catch_unwind, RefUnwindSafe</span>}</span>;
</span></span>
</span></span>/// Given a closure, will attempt to run it and unwind from panics... infinitely
</span></span>/// retrying until it works.
</span></span>///
</span></span>/// Maybe.
</span></span>fn </span>wobble</span><
</span></span>    </span>F: RefUnwindSafe </span>+</span> Fn() -> Result<(), Box<dyn Error>>
</span></span>>(</span>process</span>: F) </span>{
</span></span>    </span>while </span>let </span>Err</span>(err) </span>= </span>catch_unwind</span>(|| </span>process</span>()) </span>{
</span></span>        </span>eprintln!(</span>"{:?}"</span>, err);
</span></span>    </span>}
</span></span>}
</span></span></code></pre>
Usage is relatively straightforward. For example:</p>
</span>fn </span>do_something</span>() </span>-> Result<(), Box<dyn Error>> </span>{
</span></span>    </span>panic!(</span>"Induce a panic here, for testing"</span>);
</span></span>}
</span></span>
</span></span>fn </span>main</span>() </span>{
</span></span>    </span>wobble</span>(|| </span>{
</span></span>        </span>do_something</span>()
</span></span>    </span>}</span>);
</span></span>}
</span></span></code></pre>Why's it called Wobbling?</h2>
It's an "infinite" move (or glitch, some might say) in Super Smash Bros Melee for the Nintendo Gamecube. I chose the name because the move is divisive, not something most people enjoy seeing in competitive tournaments, and while valid (depending on the ruleset), might not be the best way to play the game. It kind of symbolically fits here: you probably don't want to use this, and it's arguably not a smart way of doing things... but hey, you might make top 8 once in awhile.</p>
Great! Should I use this?</h2>
Probably not.</p>
I mean, sure, you can. For a small subset of problems it can be a useful trick. It's probably not what you want to do, though. It almost feels like a lurking unsafe {}</code> without explicitly being so. The code could also be slightly less verbose, for sure, albeit code golf wasn't the point here.</p>
With that said, it definitely worked for me. Lately I've come to value my time more highly than I did in the past, and this let me focus on other things while still logging errors to determine what the actual issue was. I'll call it a win.</p>


Decoupling, or: where's my data?
Sat, 07 Dec 2019 00:00:00 +0000
Privacy, data rights and ownership are hot topics in 2019. The increased focus on these topics grew over the past few years from a few different things. Snowden's 2013 leaks showed the general public that the data you put out there is not as private as once assumed. An increasing number of database leaks over the past few years have made more people aware that not all data on the internet is necessarily safe and secure. Europe's General Data Protection Regulation (GDPR)</em> woke many companies up to legal liabilities of not taking this stuff seriously, and an increasing number of countries and locales are starting to follow suit (examples include Japan's Act on the Protection of Personal Information (APPI)</em>, becoming more restrictive, and California pushing through with the California Consumer Privacy Act (CCPA)</em>).</p>
This is all generally net good for consumers. It pushes forward towards building products that have more respect for users and their rights, and normalizes the conversation in the public eye. However, there's an interesting area of study that I haven't seen as much attention paid to, though - back in the early years of the iPhone and App Store, there was an explosion of apps released that took user data and withered on the vine, to to speak. What happened to the data these apps held and had access to?</p>
I started looking at this for an app I had personal experience with: Couple</a>.</p>
What is (or was) Couple?</h2>
Couple (originally branded at launch as "Pair") was an app that debuted in the 2012 Y Combinator</a> batch. The general target market was people in relationships: a supposedly closed off, intimate place to chat, leave media, notes, drawings, and thoughts for each other, along with a shared calendar and a map to send each other your location. It described itself in 2014 with the following text:</p>
</p>

An Intimate Place for Two.

Keep all your moments private & make your memories last forever.
</blockquote>
You might be thinking to yourself: why would anybody use this</em>? Well, remember that this was 2012 - a few years into the App Store, where various social networks and services were still fighting it out. The appeal of having a special app on your homescreen to differentiate your partner from the myriad of other chats and social networks was very enticing. It launched on Android as well, so it found a decent enough market of connecting people across the two platforms (over 4 billion downloads and seemingly billions of messages).</p>
Now, back in 2012, I was fortunate enough to have met the woman who'd eventually become my wife. She was studying overseas, and I was on a business trip. We started dating. It became a situation that will sound familiar to many people: long distance</em>, an excruciatingly annoying experience when you're utterly infatuated with someone. An app like Couple seemed like a great idea - a way to put more of an emphasis on the relationship than another chat line in your app of choice.</p>
We used it until we were no longer long distance. The app eventually disappeared from the App Store, and while the servers would periodically crash, it seemingly still worked - I know I was able to sync the data to my current phone, and apparently people</a> were</a> using</a> it</a> as</a> late</a> as</a> this year</a>.</p>
Others, like me</a>, wondered about what actually happened to all the data that was on Couple's servers. Note that this thread has a comment mentioning the service had been hacked - I've been unable to verify that this was the case, and as it's one comment on one thread I'm inclined to not believe it until determined otherwise. Take it with a grain of salt</em>.</p>
So what happened here?</h2>
If we try to trace this, a few things become apparent:</p>

Couple launches in 2012, under four cofounders.</li>
Around October 2014, three of the four cofounders leave to go work at Dropbox</a>.</li>
On Feburary 12th, 2016, Couple was acquired by Life360</a>, a company focused on providing a "family network" experience. It seems like an acquihire, and after looking around some of the former Couple staff still work there.</li>
On June 27th, 2018, Couple was apparently transfered or sold</a> without much fanfare (seriously, this tweet is all I could find).</li>
I contacted Life360 via Twitter on Dec 6th, 2019</a>. They state, accordingly, that they have no relationship with the app anymore, and refer you to contact support@couple.me</a>.</li>
The company that Couple was transfered to is Coupleapp, Inc</a>. According to that business filing, the founder is Corey Wiles (@kwylez on Twitter)</a>. He's the creator of a an app known as "Significant Other", that has similiar goals to those of Couple originally.</li>
According to his website</a>, he was a contractor at Life360 for a period.</li>
Emails to the Couple support email (support@couple.me</a>) go unanswered. Poking on Twitter</a> similarly goes unanswered. The website has not been updated since the original owners (Tenthbit, Inc) had posession of it.</li>
</ul>
</p>
Now, it's important to state this: the data sent over and stored on Couple's servers was often very personal data</em>. To the best of my knowledge, and having searched quite a bit, there's never been any</em> communication from any</em> owner of Couple regarding what exactly happened to the data. The service 503</code>'s now; if you try to delete your account or data from within the app, it simply won't work. Some might consider this to mean it's just gone, but if you've built any service like this, you know very well that there's a real possibility the data is still sitting on some S3 bucket somewhere.</p>
Why on earth is it acceptable that Life360 can spin this back out without any notice beyond a quick tweet? It blows my mind that this just happened without much notice or coverage.</p>
What to do from here?</h2>
So, here's the thing - I'm absolutely, totally fine with the service shutting down. I'd just like to know what happened to the data that was held by this service. Former users who trusted the service with their data deserve to know if the new owners were given everything; a transfer like that is not something that should be announced over Twitter alone. The type of content or data that's involved here is very personal in nature - personal thoughts, photos, videos and more.</p>
Furthermore, in a world of GDPR, CCPA and so on, I'd love to know: where does something like this fall</em>? Considering the download numbers that this app did, and given that it was available worldwide... I have to think that it absolutely falls within the realm of GDPR. CCPA comes into enforcement on January 1st, 2020 - around 3 weeks from time of writing this. When the new entity doesn't respond, what's next? Kick this up the chain to state or national agencies?</p>
If someone involved in the app could publicly clarify what exactly happened here, it would do every former user a world of good.</p>
Ultimately, it's worth remembering that the focus on privacy and user rights that we have today weren't always at the forefront years ago. Many services existed then that might still contain your digital footprint, and it's good to review and take stock of these. You don't always know where your data wound up.</p>


Automatic Old Reddit Redirect Safari Extension
Thu, 01 Aug 2019 00:00:00 +0000
Miss the old Reddit browsing experience? You're not alone. While I've no doubt that they'll eventually produce something really smooth and cool (they're too good of an engineering team not to), in the meantime I've found myself preferring to use the old Reddit design. It's sleeker, faster to load, and easier to skim large amounts of posts with.</p>
You can set your preference in your profile to use the old Reddit design, but I've noticed that it doesn't automatically push you to it - you'll still wind up waiting for a behemoth of a UI to load if you click a random Reddit link while not on old.reddit.com</code> already</em>. Chrome and Firefox have convenient extensions to force-rewrite the URL, but Safari is lacking... maybe due to the APIs being different, or maybe due to the up-front cost for the developer program.</p>
At any rate, I wanted that extension in Safari, so I ported it over. I call it "Oldr for Reddit", and you can download it here.</a> Once it's installed, check your Safari preferences</code> -> Extensions</code> list and enable it, and it should "just work" from there.</p>
Privacy Policy and Terms of Service</h2>
The software is released as-is, and by using it, you agree that you understand this. I don't record ay data, and have no analytics beyond anything Apple gives me in terms of download numbers. If you find anywhere that I've errored in this, get in touch.</p>
Questions or comments? Feel free to email me or catch me on Twitter.</p>


On Sign-In with Apple
Wed, 05 Jun 2019 00:00:00 +0000
At WWDC this year, Apple announced a new feature for user registration with applications. Called simply "Sign In with Apple"</a>, it's effectively an OAuth2 authentication ritual similar to what Facebook, Google, Twitter (and more) currently offer. The catch is that Apple wants to do it in a way that protects your privacy, by acting as an in-between agent to avoid your email address being used for spam, data targeting or profiling, and more. It's really significant, since a company the size of Apple pushing this could enable it to take off in a way that just wouldn't happen elsewhere.</p>
However, I've noticed more than a few people throwing comments around the web to the tune of:</p>

"I already do this by providing a fake email, like myemail+lol@gmail.com</code>, to everyone!"</li>
"I'm protected already because I run my own domain with a catch-all email, like abc@mydomain.com</code>!"</li>
</ul>
These imply that what Apple is doing is easily replicated, which is somewhat far from the case. Let's examine why.</p>
The Special Email</h2>
You sign up to a provider for some service that you just want to scope out, and you're worried about the safety of it. You use Gmail, so you decide "let's just give it a special one that I can block later, like myemail+lol@gmail.com</code>". Later on the service database leaks. You're safe, right?</p>
Not so much. Removing the special character bits from Gmail is not inherently difficult, so matching your email across database dumps becomes relatively straightforward for any cleaning script worth its salt. You can block all the emails coming from that special email, but nothing is stopping you from getting them... and nothing is stopping the provider from emailing your real one, which as noted, there's a good chance they've got now. Linking your data sets together for profiling is also relatively easy at this point.</p>
How's this change with Apple's approach? When you sign in with Apple, you get assigned a special email address that acts as a relay to your true email. Reading the documentation further, this becomes even more useful than it sounds - to send email via that relay, it has to come from a domain that the developer explicitly proves they control. Anything else is outright ignored. This means that, should database leaks occur, you have a per-app-unique email that can't be tied across leaks, and can't be arbitrarily emailed or spammed. It's providing privacy in a way that your home-grown special email case simply can't.</p>
The Catch-All Email</h2>
So you're savvy enough to run your own domain-based email, and you decide "alright, let's just use a catch-all@mydomain.com</code> email and weed out the bad actors this way". This works slightly better than the special email case above, but at the end of the day, I'm going to be honest with you: I've seen more than my fair share of data cleaning scripts, and if your domain isn't a known email provider, you're just going to be attributed as the same user across leaks. You're not big enough to matter to a bad actor, and it's easy enough to lump anything matching your domain together. You're still going to be profiled if you go this route.</p>
Big-Corp?</h2>
The other thing I keep seeing come up is paranoia around big corporations being the one to vend out these solutions. This is also sometimes phrased as "privacy shouldn't come at a price". This is correct, it shouldn't... but Apple should be applauded for this move, because your home-grown solution isn't actually doing anything to solve the bigger issue. Apple didn't invent email relays, privacy tools, or what have you, but they're able to push them at a scale that forces the tech industry to change for the better.</p>
We will not move past this era of user-targeting unless there's a big entity that steps in, be it government regulation (seemingly, currently, unlikely) or a large corporation with enough muscle to make it happen (in this case, Apple). Dislike them for whatever reason you want, but they really do deserve credit for being willing to stand up and push this issue.</p>


One Last Ride
Wed, 15 May 2019 00:00:00 +0000
When did redesigning a personal website become such hell? I've had this site running for almost two decades now, and while it's been a point of (perhaps misplaced) pride, I try to keep it looking decent and up to date. The modern landscape is crazy, though - a million-ish screen sizes and densities, different appearance APIs depending on whether you're running a dark mode or not, and much higher standards for what "looks good".</p>
I think I settled on something I'm happy with for the next few years, and with any luck, the remainder of my time on these here internets.</p>
RYMC 4.0</h2>
The previous design for this site was made towards the tail-end of my time living in Tokyo. I realized one day that I'd kept the design from... 2008... up for almost ten years. We're talking pre-iPhone here. I redesigned it to effectively look like a Medium blog with some elements of personality, and was happy with it for awhile: it did the job and stayed out of my way.</p>
Then earlier this year, a family member was unfortunately diagnosed with cancer. Sitting in a hospital room with someone you care about while they battle something like that isn't easy - it makes you think a lot about how you live your own life. I remember pulling up my site one day and thinking to myself: "wow, this is incredibly devoid of personality. Is this mine?"</em></p>
Since I had time to pass while sitting there, I just kind of started throwing stuff at the screen and seeing what I liked.</p>

I wanted something with dynamic-ish shapes. A growing current trend in (web-based) design is softer shapes and more variation in element positioning.</li>
I wanted to keep it loading insanely fast. I personally like a CSS-Zen-Garden approach (I'm dating myself here) to see what all can be done without needing a litany of network connections.</li>
I wanted to spruce up the old content, for better SEO and reading comfort.</li>
I wanted to support dark mode, for browsers that support the new @media</code> query for appearance preferences.</li>
I wanted a smooth code reading experience, for the more technical articles.</li>
I wanted personality in here somewhere.</li>
</ul>
Activity Feed(s)</h2>
That last point dovetails into the other big thing I wanted. The web I grew up on was people owning their content, and we lost that somewhere along the way. It's a difficult thing to walk back, too, but I figure I can at least have it for myself - hence why this site now automatically grabs my tweets, GitHub activity, and Dribbble work and displays it throughout as you browse. In keeping with ensuring this thing loads like demonically fast, the data is scraped and repackaged into what's effectly a static site every few minutes.</p>
If you're interested, I open sourced the code I used for this part here</a>. Feel free to use!</p>
Moving Forward</h2>
I'm hoping to continue posting content here, since it's nice to have your own space. 2019 has been a pretty good clip for this! Also, never let me do this again.</p>


Vim, ALE, Docker, and Per-Project Linting
Thu, 07 Mar 2019 00:00:00 +0000
I've been using Vim for a little over ten years now. Up until Vim 8, I'd go so far as to say little changed for me... but Vim 8 actually changed the game in a pretty big way. The introduction of asynchronous jobs that can run in the background enables functionality like code linting and completion that don't block the editor, a rather stark contrast to the old days. In fact, I outright didn't bother with code completion and the like prior to Vim 8 - it was never fast enough and just left me too annoyed to care.</p>
Anyway, thanks to this new functionality, we can use projects like ALE</a> to provide smooth linting, autocompletion, fixing, and so on. Setting up this and other Vim plugins is a bit outside the scope of this post, but I'd highly recommend it if you haven't tried it. ALE includes support for LSP (language-server-protocol)</a>, originally developed by Microsoft and now supported by a litany of editors and IDEs. This support has made Vim feel like far less of a black-box at points!</p>
ALE and Docker</h2>
One thing I ran into when setting ALE up was that various projects have their own rules. For example, a Japanese company I help has some rather peculiar style rules for their Python codebase. I recently converted their infrastructure to a Docker-based architecture, and as a result all Python code executes inside a virtual machine (at least, insofar as MacOS/Windows are concerned - Linux users might have a slightly easier time here!).</p>
In most cases, this is not too big of a problem - however, this particular case means that tools like flake8 are running inside the VM, and not in the userspace where you'd be running Vim. In the issues I glanced over, the author of ALE recommends just running Vim over SSH into the VM, which can be an alright solution... albeit a bit clunky, given your setup for Vim runs on your local machine. We really just need a way to communicate between the two layers, right?</p>
This is actually possible with just a bit of extra configuration work. We'll need two things before we can make it work, though:</p>

If you haven't already, I recommend setting up your Vim installation so that it supports some kind of local .vimrc setup. I use embear/vim-localvimrc</a> and whitelist the projects I know are safe, but you do you.</li>
A custom shell script to act as the bridge between Docker and the host environment.</li>
</ul>
The Shell Script</h2>
This is much simpler than you'd think! Somewhere in your project, edit and throw the following:</p>
</span>#!/bin/bash
</span></span>docker-compose</span> exec</span> -T </span>{{ Your docker env name here }} flake8 $</span>@
</span></span></code></pre>
This is inspired by acro5piano's post over on qiita</a>, but fixed up slightly to work with what I presume are recent changes in Docker and/or ALE. Notably, our command has to specify -T</code> to stop Docker from allocating a pseudo TTY. Save this and mark it as executable, and ensure your Docker environment is running if you want ALE to report errors.</p>
(I also figured I'd throw this post up in English, just so the knowledge is a bit more freely available)</em></p>
Local .lvimrc Configuration</h2>
With the shell script in place, we just need to instruct ALE on how to call flake8. If you're using vim-localvimrc</code>, you can throw a .lvimrc</code> in your project root with the following:</p>
</span>let </span>g:ale_python_flake8_executable</span> = </span>'/path/to/flake8/shell/script'
</span></span></code></pre>
Provided you did all the above correct, flake8 should now be properly reporting to ALE. You'd need to do this setup per-project, but to be honest I don't find it that annoying, as I find Docker is worth it over the old-school Virtualenv solutions. If you know of a better way to do this, I'm all ears!</p>


Rust, Cargo, lcrypto/OpenSSL, Mac, and You
Mon, 18 Feb 2019 00:00:00 +0000
If you're trying to compile code on recent versions of macOS, and it tries to link to OpenSSL, you may find yourself driven a bit mad by how odd it all is. The long and short of it is that Apple, in a recent-ish release, removed the headers for their version of OpenSSL, and you need to install a modern version of OpenSSL via Homebrew</a>. This is really straightforward... but won't, in some cases, automatically make your project compile.</p>
This was the case for a project I was working on, which happened to be written in Rust. The resulting errors spewed from Cargo were, after parsing, pretty clear: it was trying and failing to find and link to an OpenSSL installation. This can be confusing to diagnose and fix, since over the years Rust moved pretty quickly, and there's a litany of strange GitHub issue threads devoted to the issue. It crosses over with some macOS issues, and... yeah.</p>
Thus, I'm going to dump my .bashrc</code> fixes here. Throwing the following in your bash profile, then running a cargo clean + build should get your project compiling.</p>
</span>export </span>OPENSSL_ROOT_DIR</span>=</span>$(</span>brew</span> --prefix</span> openssl)
</span></span>export </span>OPENSSL_LIB_DIR</span>=</span>"$</span>OPENSSL_ROOT_DIR</span>/lib"
</span></span>export </span>OPENSSL_INCLUDE_DIR</span>=</span>"$</span>OPENSSL_ROOT_DIR</span>/include"
</span></span>export </span>LDFLAGS</span>=</span>"-L$</span>OPENSSL_ROOT_DIR</span>/lib"
</span></span>export </span>CPPFLAGS</span>=</span>"-I$</span>OPENSSL_ROOT_DIR</span>/include"
</span></span>export </span>PKG_CONFIG_PATH</span>=</span>"$</span>OPENSSL_ROOT_DIR</span>/lib/pkgconfig"
</span></span>export </span>LIBRARY_PATH</span>=</span>"$</span>LIBRARY_PATH</span>:$</span>OPENSSL_ROOT_DIR</span>/lib/"
</span></span></code></pre>
Exporting these flags ensures that Rust, Cargo, LLVM and crew correctly grok where to find OpenSSL to link against. Hopefully this helps someone else out there, since this can be annoying to diagnose! Some tweaking may be needed depending on how you have your system configured.</p>


Dynamic Images in iOS Push Notification Extensions
Thu, 31 Jan 2019 00:00:00 +0000
Some time ago, I read an interesting article from The Guardian about their work with a concept they call "Live Notifications"</a>. The general idea is being able to do more with push notifications, turning them into a rich experience with dynamically generated or updated assets. I experimented with this on my own when I wanted a simple way of charting some personal data; I have a server that periodically checks a source, and notifies based on updated findings (yes, this is as generic a description as it can get - it's personal). Rather than generating and storing images on a server that'd only be needed once, couldn't I just dynamically generate them client side?</p>
Turns out, it's not super complicated in the grand scheme of things. Using an iOS Notification Content Extension</a> or iOS Notification Service Extension</a>, it's possible to have a lightweight process running that can act dynamically on received push notifications. This is the key - we'll send a lightweight payload via Apple's Push Notification Service (APNS), and then build and attach an image to the notification before it displays.</p>
Limitations</h2>
There are, surprisingly, not too many limitations... but there's one or two to know about.</p>

Usage of portions of UIKit</code> is pretty much impossible - for instance, UIApplication</code> is out, but you can use CoreGraphics</code> et al as necessary.</li>
The memory limitations are much smaller and the system is more aggressive in killing your extension if you're not careful, so it's best to keep this efficient. I'd highly recommend sending a default notification with usable title and text, and then customize it as necessary when you do the image.</li>
If you want to access NSUserDefaults</code>, you'll need to ensure you're using an App Group to communicate between processes properly, as the extension lives separately from your app.</li>
Oh, and if you use Realm</a>, it's a little tricky to read data in extensions (as of writing this, I don't believe it works properly). I've only used this in situations with NSUserDefaults</code>, Core Data</code>, or SQLite</code>. I'm sure there's a method for Realm, but you're on your own for that.</li>
</ul>
Building the Extension</h2>
For this example, we'll assume you have an iOS app that's properly configured for push notifications. If you're unsure of how to do this, there's enough guides around the internet to walk you through this, so run through one of those first. The example below also makes use of the excellent Charts library by Daniel Gindi</a>, so grab that if you need it.</p>
We'll start with a standard iOS Service Extension, and wire it up to attempt producing an image in the didReceive(...)</code> method. We'll implement three methods, and support throwing up the chain to make things easier - it's less ideal if an extension crashes, because getting it restarted is... unlikely. We'll simply recover "gracefully" from any error, but due to this it's also worth getting right in testing.</p>
</span>import </span>UIKit
</span></span>import </span>UserNotifications
</span></span>import </span>Charts
</span></span>
</span></span>class </span>NotificationService</span>: </span>UNNotificationServiceExtension</span> {
</span></span>    </span>var </span>contentHandler</span>: ((</span>UNNotificationContent</span>) -> </span>Void</span>)</span>?
</span></span>    </span>var </span>bestAttemptContent</span>: </span>UNMutableNotificationContent</span>?
</span></span>
</span></span>    </span>override </span>func </span>didReceive</span>(</span>_ </span>request</span>: </span>UNNotificationRequest</span>, withContentHandler </span>contentHandler</span>: </span>@escaping</span> (</span>UNNotificationContent</span>) -> </span>Void</span>) {
</span></span>        </span>self.</span>contentHandler = contentHandler
</span></span>        </span>bestAttemptContent = (request</span>.</span>content</span>.</span>mutableCopy() </span>as? </span>UNMutableNotificationContent</span>)
</span></span>        </span>
</span></span>        </span>if let</span> bestAttemptContent = bestAttemptContent {
</span></span>            </span>bestAttemptContent</span>.</span>title = </span>"\(</span>bestAttemptContent</span>.</span>title</span>) [modified]"
</span></span>            </span>
</span></span>            </span>do</span> {
</span></span>                </span>buildChartAttachment(request)
</span></span>            </span>} </span>catch</span> {
</span></span>                </span>// Assuming you sent a "good enough" notification by default, this should be
</span></span>                </span>// safe. We can log here to see what's wrong, though...
</span></span>                </span>print(</span>"Unexpected error building attachment! \(</span>error</span>)."</span>)
</span></span>            </span>}
</span></span>
</span></span>            </span>contentHandler(bestAttemptContent)
</span></span>        </span>}
</span></span>    </span>}
</span></span>    </span>
</span></span>    </span>override </span>func </span>serviceExtensionTimeWillExpire</span>() {
</span></span>        </span>if let</span> contentHandler = contentHandler, </span>let</span> bestAttemptContent =  bestAttemptContent {
</span></span>            </span>contentHandler(bestAttemptContent)
</span></span>        </span>}
</span></span>    </span>}
</span></span>
</span></span>    </span>// The three main methods we'll implement in a moment
</span></span>    </span>func </span>renderChartImage</span>() -> </span>UIImage</span>?</span> {}
</span></span>    </span>func </span>storeChartImage</span>(</span>_ </span>image</span>: </span>UIImage</span>?</span>) </span>throws</span> -> </span>URL</span> {}
</span></span>    </span>func </span>buildChartAttachment</span>(</span>_ </span>request</span>: </span>UNNotificationRequest</span>) </span>throws</span> {}
</span></span>}
</span></span></code></pre>Rendering the Chart</h2>
For the sake of example, we'll make a very basic LineChart</code> using bogus data. In a real world scenario, you'd want your data to fit into the space of a push notification (2kb - 4kb, which is actually a good amount of space). You could also use a different type of chart, if you wanted. The use cases here are pretty cool - imagine if RobinHood allowed you to, say, see a chart at a glance of how your portfolio is doing. Depending on the performance, that chart could change color or appearance to convey more information at a glance.</p>
Granted, you might not want that much information being on a push notification. Maybe you have prying eyes around you, or something - privacy is probably good to consider if you're reading this and looking to implement it as a feature. The chart below has some settings pre-tuned for a "nice enough" display, but you can tinker with it to your liking.</p>
</span>func </span>renderChartImage</span>() -> </span>UIImage</span>?</span> {
</span></span>    </span>let</span> chartView = </span>LineChartView</span>(</span>frame</span>: </span>CGRect</span>(</span>x</span>: </span>0</span>, </span>y</span>: </span>0</span>, </span>width</span>: </span>320</span>, </span>height</span>: </span>320</span>))
</span></span>    </span>chartView</span>.</span>minOffset = </span>0
</span></span>    </span>chartView</span>.</span>chartDescription</span>?.</span>enabled = </span>false
</span></span>    </span>chartView</span>.</span>rightAxis</span>.</span>enabled = </span>false
</span></span>    </span>chartView</span>.</span>leftAxes</span>.</span>enabled = </span>false
</span></span>    </span>chartView</span>.</span>xAxis</span>.</span>drawLabelsEnabled = </span>false
</span></span>    </span>chartView</span>.</span>xAxis</span>.</span>drawAxisLineEnabled = </span>false
</span></span>    </span>chartView</span>.</span>xAxis</span>.</span>drawGridLinesEnabled = </span>false
</span></span>    </span>chartView</span>.</span>legend</span>.</span>enabled = </span>false
</span></span>    </span>chartView</span>.</span>drawGridBackgroundEnabled = </span>true
</span></span>    </span>chartView</span>.</span>drawBordersEnabled = </span>false
</span></span>    </span>chartView</span>.</span>setScaleEnabled(</span>false</span>)
</span></span>    </span>chartView</span>.</span>contentScaleFactor = </span>2
</span></span>    </span>chartView</span>.</span>backgroundColor = </span>UIColor</span>.</span>black
</span></span>    </span>chartView</span>.</span>gridBackgroundColor = </span>UIColor</span>.</span>green
</span></span>
</span></span>    </span>let</span> dataSet = </span>LineChartDataSet</span>(</span>values</span>: [
</span></span>        </span>ChartDataEntry</span>(</span>x</span>: </span>1</span>, </span>y</span>: </span>2</span>),
</span></span>        </span>ChartDataEntry</span>(</span>x</span>: </span>2</span>, </span>y</span>: </span>5</span>),
</span></span>        </span>ChartDataEntry</span>(</span>x</span>: </span>3</span>, </span>y</span>: </span>7</span>),
</span></span>        </span>ChartDataEntry</span>(</span>x</span>: </span>4</span>, </span>y</span>: </span>12</span>),
</span></span>        </span>ChartDataEntry</span>(</span>x</span>: </span>5</span>, </span>y</span>: </span>18</span>),
</span></span>        </span>ChartDataEntry</span>(</span>x</span>: </span>6</span>, </span>y</span>: </span>7</span>),
</span></span>        </span>ChartDataEntry</span>(</span>x</span>: </span>7</span>, </span>y</span>: </span>1</span>)
</span></span>    </span>], </span>label</span>: </span>""</span>)
</span></span>    </span>
</span></span>    </span>dataSet</span>.</span>lineWidth = </span>4
</span></span>    </span>dataSet</span>.</span>drawCirclesEnabled = </span>false
</span></span>    </span>dataSet</span>.</span>drawFilledEnabled = </span>true
</span></span>    </span>dataSet</span>.</span>setColor(</span>UIColor</span>.</span>green)
</span></span>    </span>dataSet</span>.</span>fillColor = </span>UIColor</span>.</span>green
</span></span>    </span>
</span></span>    </span>let</span> data = </span>LineChartData</span>(</span>dataSets</span>: [dataSet])
</span></span>    </span>data</span>.</span>setDrawValues(</span>false</span>)
</span></span>    </span>chartView</span>.</span>data = data
</span></span>    </span>
</span></span>    </span>return</span> chartView</span>.</span>getChartImage(</span>transparent</span>: </span>false</span>)
</span></span>}
</span></span></code></pre>
Note that the size of the chart is hard-coded, and that the scale is manually set. Both are critical for pixel-perfect rendering; the logic could certainly be better (e.g, larger phones really need the scale to be 3), but the general idea is showcased here.</p>
Storing the Image</h2>
We now need to attach the image to the notification. We do this using a UNNotificationAttachment</code>, which... requires a URL</code>. Thus, we'll be writing this to the filesystem temporarily. This method attempts to create a temporary directory and write the PNG data from the chart image returned in our prior method.</p>
</span>func </span>storeChartImage</span>(</span>_ </span>image</span>: </span>UIImage</span>?</span>) </span>throws</span> -> </span>URL</span> {
</span></span>    </span>let</span> directory = </span>URL</span>(</span>fileURLWithPath</span>: </span>NSTemporaryDirectory</span>(), </span>isDirectory</span>: </span>true</span>)
</span></span>    </span>try </span>FileManager</span>.default.</span>createDirectory(</span>at</span>: directory, </span>withIntermediateDirectories</span>: </span>true</span>, </span>attributes</span>: </span>nil</span>)
</span></span>    </span>
</span></span>    </span>let</span> url = directory</span>.</span>appendingPathComponent(</span>"tmp.png"</span>)
</span></span>    </span>try</span> image</span>?.</span>pngData()</span>?.</span>write(</span>to</span>: url, </span>options</span>: .</span>atomic</span>)
</span></span>    </span>
</span></span>    </span>return</span> url
</span></span>}
</span></span></code></pre>
Note that, in my testing, simply writing to the same URL over and over again didn't impact multiple notifications - i.e, you're not overwriting an old image that might be on the screen. I've no idea if this will change in later iOS revisions, though, so keep it in the back of your mind!</p>
Putting it all together</h2>
With the image saved and ready, we can attach it to the notification and let the system display it to the user.</p>
</span>func </span>buildChartAttachment</span>(</span>_ </span>request</span>: </span>UNNotificationRequest</span>) </span>throws</span> {
</span></span>    </span>let</span> chartImage = renderChartImage()
</span></span>    </span>let</span> url = </span>try</span> storeChartImage(chartImage)
</span></span>    </span>let</span> attachment = </span>try </span>UNNotificationAttachment</span>(</span>identifier</span>: </span>""</span>, </span>url</span>: url, </span>options</span>: </span>nil</span>)
</span></span>    </span>bestAttemptContent</span>?.</span>attachments = [attachment]
</span></span>}
</span></span></code></pre>
And voila, you now have a dynamically generated chart. No need to worry about rendering images server side, storing and caching them, or anything like that!</p>


Your chart hopefully looks better than this demo image I found laying around from my test runs. :)</p>
</div>
...surely there must be a catch...</h2>
Yeah, there's a few things to consider here.</p>

You're technically pushing the processing requirements to the user's device, but in my testing, this didn't cause significant battery drain over time. If you opt to do this, consider the time interval that you're pushing notifications on.</li>
As mentioned before, you should design notifications such that they're sent "good enough", in case a notification extension crashes or is killed by the OS for whatever reason. This means ensuring a good default title, body, and so on are sent.</li>
If you use this for financial data, which would not surprise me as the chief interest here, you should consider making this feature "opt-in" rather than "opt-out". Charts can convey a lot more than text at a glance, and people might not want their information being blown out like that.</li>
</ul>
But with that all said, it's a pretty cool trick! Due credit goes to The Guardian for inspiring me to look into this. If you find issues with the code samples above, feel free to ping me over email or Twitter and let me know!</p>


Using a Custom JSONEncoder for Pandas and Numpy
Wed, 02 Jan 2019 00:00:00 +0000
Recently, I had a friend ask me to glance at some data science work he was doing. He was puzzled why his output, upon attempting to send it to a remote server for processing, was crashing the entire thing. The project was using a pretty standard toolset - Pandas, Numpy, and so on. After looking at it for a minute, I realized he was running into a JSON encoding issue regarding certain data types in Pandas and Numpy.</p>
The fix is relatively straightforward, if you know what you're looking for. I didn't see too much concrete info floating around after a cursory search, so I figured I'd throw it here in case some other wayward traveler needs it.</p>
Creating and Using a Custom JSONEncoder</h2>
It all comes down to instructing your json.dumps()</code> call to use a custom encoder. If you're familiar with the Django world, you've probably run into this with the DjangoJSONEncoder</code> serializer. We essentially want to coerce Pandas and Numpy-specific types to core Python types, and then JSON generation more or less works. Here's an example of how to do so, with comments to explain what's going on.</p>
</span>import </span>numpy
</span></span>from </span>json </span>import </span>JSONEncoder
</span></span>
</span></span>class </span>CustomJSONEncoder</span>(</span>JSONEncoder</span>):
</span></span>    </span>def </span>default</span>(</span>self</span>, </span>obj_to_encode</span>):
</span></span>        </span>"""Pandas and Numpy have some specific types that we want to ensure
</span></span>        </span>are coerced to Python types, for JSON generation purposes. This attempts
</span></span>        </span>to do so where applicable.
</span></span>        </span>"""
</span></span>        </span># Pandas dataframes have a to_json() method, so we'll check for that and
</span></span>        </span># return it if so.
</span></span>        </span>if </span>hasattr</span>(obj_to_encode, </span>'to_json'</span>):
</span></span>            </span>return </span>obj_to_encode</span>.</span>to_json</span>()
</span></span>
</span></span>        </span># Numpy objects report themselves oddly in error logs, but this generic
</span></span>        </span># type mostly captures what we're after.
</span></span>        </span>if </span>isinstance</span>(obj_to_encode, numpy</span>.</span>generic):
</span></span>            </span>return </span>numpy</span>.</span>asscalar</span>(obj_to_encode)
</span></span>        </span>
</span></span>        </span># ndarray -> list, pretty straightforward.
</span></span>        </span>if </span>isinstance</span>(obj_to_encode, numpy</span>.</span>ndarray):
</span></span>            </span>return </span>obj_to_encode</span>.</span>to_list</span>()
</span></span>
</span></span>        </span># If none of the above apply, we'll default back to the standard JSON encoding
</span></span>        </span># routines and let it work normally.
</span></span>        </span>return </span>super</span>()</span>.</span>default</span>(obj_to_encode)
</span></span></code></pre>
With that, it's a one-line change to use it as our JSON encoder of choice:</p>
</span>json</span>.</span>dumps</span>({
</span></span>    </span>'my_pandas_type'</span>: pandas_value,
</span></span>    </span>'my_numpy_type'</span>: numpy_value
</span></span>}, </span>cls</span>=</span>CustomJSONEncoder)
</span></span></code></pre>Wrapping Up</h2>
Now, returning and serializing Pandas and Numpy-specific data types should "just work"</em>. If you're the Django type, you could optionally subclass DjangoJSONEncoder</code> and apply the same approach with easy serialization of your model instances.</p>


My 2018 Reading List
Mon, 31 Dec 2018 00:00:00 +0000
It's the last day of 2018, and a few hours before midnight strikes. Looking back, I didn't get to do as much writing on here for the year as I wanted to (something I'm trying to change in 2019 and beyond). I did, however, manage to find time to do a lot of reading this year; mostly due to long flights, but also from a real effort on my part to get back into the habit.</p>
It seemed like a fitting way to close the year out, then, by listing the books I found insightful and worth grabbing a copy of. I'm opting not to link to Amazon for these, but if you prefer to buy books through there, you should be able to find any of them with a quick search. These are also lightly divided by topics, primarily for some structure.</p>
Privacy</h2>
I've generally been a private person, but 2018 in general led to me looking for a better understanding of what privacy really means, both on a consumer and product development level. It's not a topic that can be approached with technology alone; the books below helped me to have an even better understanding of the history of privacy (insofar as US law goes, although much of it is applicable in general).</p>
Habeas Data, by Cyrus Farivar</a></h3>
I found this book while stumbling through the Elliot Bay Book Company</a> in Seattle, and bought it after skimming a few pages. Cyrus does an amazing job outlining the most significant court cases that have shaped the current legal view on privacy, while simultaneously showcasing how the government and general public have failed to keep up with the ethical questions and concerns that have come up in the past few decades as technology has exploded. In general, this was a tough book to put down: it easily messed up my sleep schedule, due to a night or two of reading into the morning hours, and I walked away feeling like I had a better understanding of the privacy landscape.</p>
Rating</strong>: 10/10</p>
Future Crimes, by Marc Goodman</a></h3>
This book was frustrating, is the best way I can put it. I picked it up on sale after noticing that it was listed as a best seller... and then I regretted it for the following few weeks as I labored through it. The author has a writing style that can be explained best as "stating the obvious for 500 pages"</em>. If you have a background in technology, I would skip this; if you're wondering just what's possible with technology, it's probably an okay read, if not a bit hyperbolic.</p>
Rating</strong>: 4/10</p>
Privacy's Blueprint, by Woodrow Hartzog</a></h3>
Much of the internet is opt-in, in a sense - there's generally a privacy policy and terms of service, but it's up to you to read the fine print and decide whether it's good or bad. This book that examines how privacy can be regulated and enforced from the legal side, by requiring product makers to respect privacy in how they build. If you work in tech, touch user data, or have a passing interest in privacy, then this is worth a read.</p>
Rating</strong>: 7.5/10</p>
Food</h2>
Cooking is a hobby of mine. I wouldn't consider myself professional, but it's amazing for stress relief. It's also a creative outlet for when I can't stand looking at a computer anymore.</p>
How to Taste, by Becky Selengut</a></h3>
This book changed my life: it gave me the final secret to scrambled eggs that I didn't know I needed. While it's worth picking up for this fact alone, the author does a great job illustrating the link between salt, taste, and why so much of what you taste out there tastes bad. I started this on an 8 hour flight and was finished before the end, could not put it down.</p>
Rating</strong>: 9/10</p>
Acid Trip: Travels in the World of Vinegar, by Michael Harlan Turkell</a></h3>
A strange book on this list, in that it's easy to look at it more as a cookbook than anything else. I received my copy from a dinner party I attended where the author was giving a presentation, and I guarantee you there's more to it: Turkell does a great job going into the history of vinegar, the different forms out there, and the insane amount of uses it serves. Features a ton of recipes (~100), some of which I still haven't gotten to trying. Highly recommended.</p>
Also, Michael, if you're reading this, my dog literally ate your business card. Hope you found everything you were looking for in Tokyo.</p>
Rating</strong>: 7/10</p>
Self</h2>
These are books I picked up on a whim, with some level of self improvement in mind.</p>
Harvard Business Review's 10 "Must Reads" on Emotional Intelligence</a></h3>
A collection of articles and essays that help define and increase understanding of emotional intelligence. I originally picked this up to broaden my skills regarding interacting with and leading other people, and I think it helped foster a better way of looking at situations that involve other people. A little bit less about the data and numbers, and more about understanding what it takes to effectively manage and work with people. Recommended.</p>
Rating</strong>: 7/10</p>
Mastermind: How to Think like Sherlock Holmes, by Maria Konnikova</a></h3>
This is another book where the writing style drove me slightly insane; it definitely felt like the same points being repeated for multiple paragraphs straight. With that said, the content was worth slogging through, and if you can put up with the writing, this is a fun read that'll leave you with some exercises for your brain.</p>
Rating</strong>: 6.5/10</p>
2019</h2>
Most of these titles were, sadly, only read in the last six months. I'm hoping to make a bigger push in 2019, with a wider range of topics to boot. If you have any recommendations for titles similar to the above, feel free to let me know!</p>


Forcing PNG for Twitter Profile Photos
Tue, 18 Dec 2018 00:00:00 +0000

    Edit as of January 8th, 2019:</h4>
    Twitter announced that they were modifying their last changes, ensuring that some images remain as PNGs! You can read the full announcement here</a>, which details when an image will remain a PNG. Thanks to this, you may not need the trick below - I'll keep it up in case anyone finds it interesting, though.
    </p>
</div>

    Edit as of December 26th, 2018:</h4>
    Twitter announced recently that come February 11th, 2019, they'll be enforcing stricter conversion logic surrounding uploaded images. Until then, the below still works; a theoretical (and pretty good sounding) approach for post-Feb-11th is outlined here</a>.
    </p>
</div>
A rather short entry, but one that I felt was necessary - a lot of the information floating in search engines on this is just plain wrong in 2018, and I spent longer than I wanted to figuring this out. It helped me to get my twitter avatar</a> a bit nicer looking, though.</p>
Help, Twitter compressed the hell out of my image!</h2>
Yeah, that happens. If you upload an image for your profile or banner image, Twitter automatically kicks off background jobs to take that image and produce lightweight JP(E)G variants. These tend to look... very bad. There's a trick you can use for posting photos in tweets where, if you make an image have one pixel that's ~90% transparent, Twitter won't force it off of PNG. It doesn't appear to work on profile photos at first glance, though.</p>
Getting around the problem</h2>
Before I explain how to fix this, there's a few things to note:</p>

Your profile photo should be 400 by 400 pixels. Any larger will trigger resizing. Any smaller, you're just doing yourself a disservice.</li>
Your profile photo should be less than 700kb, as noted in the API documentation. Anything over will trigger resizing.</li>
Your profile photo should be a truecolor PNG (24bit), with transparency included. Theoretically you can also leave it interlaced but this didn't impact anything in my testing.</li>
</ul>
Now, the thing that I found is that the 1 pixel transparency trick doesn't work on profile photos, but if you crop it to be a circle with the transparency behind it, this seems to be enough. If I had to hazard a guess, I'd wager that Twitter ignores transparent pixels unless it deems they seriously matter... as in, there's a threshold you have to hit, or something.</p>
Something like this:</p>
</p>
Uploading Properly</h2>
For some reason, uploading your profile photo on the main site incurs notably more distorted images than if you do it via an API call. I cannot fathom why this is, but it held true for me. If you're not the programming type, old school apps like Tweetbot</a> still use the API call, so changing the photo via Tweetbot should theoretically do it.</p>
If you're the programming type, here's a handy little script to do this for you:</p>
</span># pip install twython to get this library
</span></span>from </span>twython </span>import </span>Twython
</span></span>
</span></span># Create a new App at https://dev.twitter.com/, check off "sign in via Twitter", and get your tokens there
</span></span>twitter </span>= </span>Twython</span>(</span>'Consumer API Key'</span>, </span>'Consumer API Secret'</span>, </span>'Access Token'</span>, </span>'Access Token Secret'</span>)
</span></span>
</span></span># Read and upload the image, see image guidelines in post above~
</span></span>image </span>= </span>open</span>(</span>'path/to/image.png'</span>, </span>'rb'</span>)
</span></span>twitter</span>.</span>update_profile_image</span>(</span>image</span>=</span>image)
</span></span></code></pre>
Keep in mind that Twitter will still make various sizes out of what you upload, so even this trick doesn't save you from their system - just helps make certain images a tiny bit more crisp. Hope it helps!</p>


Swipeable NSCollectionView
Mon, 03 Dec 2018 00:00:00 +0000
If you've done any iOS development, you're likely familiar 
I kid, but only somewhat. Over the past few macOS releases, 
In iOS-land, there's a pretty great project by the name 
Just Give Me the Code...</h2> If you're the type who'd rather dig around in code, 
Swiping on Mac</h2> Getting this working for Cocoa was a bit cumbersome, as there's 
 Like UIKit, Cocoa and AppKit have the concept of Gesture Recognizers... 
We could try the old school Mouse tracking NSEvent</code> </ul> Ultimately, the best approach I found was going with simple 
Opting In</h2> Before implementing those methods, setting up an NSCollectionV 
 </span>class </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span></code></pre> Of note here:</p> 
 We need to make sure that allowedTouchTypes</code> 
We add in a contentView</code> property here; UICollectionViewCell 
postsFrameChangedNotifications</code> and postsBou 
We keep a leftAnchor</code> reference to do swipe </ul> Capturing the Swipe</h2> With the above in place, touches should properly register. 
 </span>override </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span></code></pre> When the first two-finger swipe begins, we grab the initial 
 </span>override </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span></code></pre> As a drag occurs, this event will continually fire. We grab 
 </span>override </span></span> </span></span> </span></span> </span></span> </span></span> </span></span>override </span></span> </span></span> </span></span> </span></span> </span></span> </span></span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span> </span></span></code></pre> The last necessary pieces are just handling when a drag event 
Taking It Further</h2> While the above implements swiping, it's not... great 
 </p> 
  Rust, or: What's the Deal with GUIs?
 Fri, 29 Jun 2018 00:00:00 +0000

with UICollectionView</code>, a data-driven way of building complex views that offer more flexibility than UITableView</code>. If you've dabbled in Cocoa (macOS) development, you've probably seen NSCollectionView</code> and NSTableView</code>... and promptly wondered what era you stepped in to.</p> Apple's been silently patching these classes to be more modern. NSTableView</code> is actually super similar to UITableView</code>; auto-sizing rows work fine, and you can get free row-swiping on trackpads. You'll be stuck working around a strange data source discrepancy (a flat list vs a 2-dimensional list), but it can work. NSCollectionView</code> was mired by an old strange API for awhile, but it's now mostly compatible with UICollectionView</code>, provided you do the proper ritual to force it into the new API.</p> of SwipeCellKit</a> which brings swipe-to-reveal functionality to UICollectionView</code>. It's nice, as one of the more annoying things about moving from UITableView</code> to UICollectionView</code> has been the lack of swipeable actions. In an older project I wound up looking into how difficult it'd be to bring this same API to NSCollectionViewItem</code>; I didn't finish it as the design for the project wound up being easier to implement with NSTableView</code>, but I figured I'd share my work here in case anyone out there wants to extend it further. A good chunk of this has been from digging through various disconnected docs and example projects from Apple, coupled with poking and prodding through Xcode, so I'd hate for it to fade back into obscurity.</p> feel free to jump directly to the project on GitHub</a>. It's a complete macOS Xcode project that you can run and mess around with, in the style of a holiday calendar. It's December, sue me.</p> a few different ways you can attempt it, all with their own pitfalls.</p> but they're more limited in general, as they seemingly require a full click before you can act on mouse or gesture movement. I spent a bit of time testing this, and it seems impossible to disable. This means they ultimately don't work, as a trackpad on Mac can be configured to not be click-on-tap. In addition, a few things here seem specific to the Touch Bar found in newer MacBook Pros, which don't particularly help here.</li> APIs, but they feel very cumbersome in 2018 (not that they don't have their place). Documentation also feels very spotty on them.</li> touchesBegan()</code>, touchesMoved()</code>, and touchesEnded()</code> methods on the view controller item. The bulk of the logic happens in touchesMoved()</code>, with the rest existing mostly as flow-control for everything.</p> iewItem</code> so that it'll report touch events requires a couple of lines of code. I don't use Interface Builder, so this is included in overriding loadView()</code> below; if you're an Interface Builder user, you might opt for this to happen in viewDidLoad()</code> instead.</p> </span>HolidayCalendarCollectionViewItem</span>: </span>NSCollectionViewItem</span> { </span>var </span>leftAnchor</span>: </span>NSLayoutConstraint</span>? </span>var </span>initialTouchOne</span>: </span>NSTouch</span>? </span>var </span>initialTouchTwo</span>: </span>NSTouch</span>? </span>var </span>currentTouchOne</span>: </span>NSTouch</span>? </span>var </span>currentTouchTwo</span>: </span>NSTouch</span>? </span>var </span>initialPoint</span>: </span>CGPoint</span>? </span>var</span> isTracking = </span>false </span>public lazy var </span>contentView</span>: </span>NSView</span> = { </span>let</span> view = </span>NSView</span>(</span>frame</span>: .</span>zero</span>) </span>view</span>.</span>translatesAutoresizingMaskIntoConstraints = </span>false </span>return</span> view </span>}() </span>override </span>func </span>loadView</span>() { </span>let</span> itemView = </span>NSView</span>(</span>frame</span>: .</span>zero</span>) </span>itemView</span>.</span>postsFrameChangedNotifications = </span>false </span>itemView</span>.</span>postsBoundsChangedNotifications = </span>false </span>itemView</span>.</span>wantsLayer = </span>true </span>itemView</span>.</span>allowedTouchTypes = [.</span>direct</span>, .</span>indirect</span>] </span>itemView</span>.</span>addSubview(contentView) </span> </span>leftAnchor = contentView</span>.</span>leftAnchor</span>.</span>constraint(</span>equalTo</span>: itemView</span>.</span>leftAnchor) </span>NSLayoutConstraint</span>.</span>activate([ </span>contentView</span>.</span>topAnchor</span>.</span>constraint(</span>equalTo</span>: itemView</span>.</span>topAnchor), </span>leftAnchor</span>!</span>, </span>contentView</span>.</span>bottomAnchor</span>.</span>constraint(</span>equalTo</span>: itemView</span>.</span>bottomAnchor), </span>contentView</span>.</span>widthAnchor</span>.</span>constraint(</span>equalTo</span>: itemView</span>.</span>widthAnchor), </span>]) </span> </span>view = itemView </span>} } supports direct and indirect touch types. Some of the docs allude to these being used more for the Touch Bar, but in my testing not having them resulted in the swipes not registering sometimes. Go figure.</li> already has this property, but NSCollectionViewItem is a View Controller and lacks it. Since we need two layers for swiping to reveal something, we'll just follow the UICollectionView API for comfort.</li> ndsChangedNotifications</code> are something I disable, as they can make resizing and animating complex NSCollectionViews choppy. I learned of this from some Cocoa developer who threw it on Twitter, where it likely fell into the ether and doesn't surface much anymore. Helped me in early 2018, so I'm not inclined to believe it's changed. Friends don't let friends post this stuff on Twitter.</li> animations later, and rather than pin the right anchor to the item right anchor, we just map the width.</li> We're primarily interested in mimicing the two-finger swipe-to-reveal that NSTableView</code> has, so our touchesBegan</code> should block anything other than that.</p> </span>func </span>touchesBegan</span>(with </span>event</span>: </span>NSEvent</span>) { </span>if</span>(isTracking) { </span>return</span> } </span>let</span> initialTouches = event</span>.</span>touches(</span>matching</span>: .</span>touching</span>, </span>in</span>: view) </span>if</span>(initialTouches</span>.</span>count != </span>2</span>) { </span>return</span> } </span> </span>isTracking = </span>true </span>initialPoint = view</span>.</span>convert(event</span>.</span>locationInWindow, </span>from</span>: </span>nil</span>) </span>let</span> touches = </span>Array</span>(initialTouches) </span>initialTouchOne = touches[</span>0</span>] </span>initialTouchTwo = touches[</span>1</span>] </span>currentTouchOne = touches[</span>0</span>] </span>currentTouchTwo = touches[</span>1</span>] } points for comparing to later movements.</p> </span>func </span>touchesMoved</span>(with </span>event</span>: </span>NSEvent</span>) { </span>if</span>(</span>!</span>isTracking) { </span>return</span> } </span> </span>let</span> currentTouches = event</span>.</span>touches(</span>matching</span>: .</span>touching</span>, </span>in</span>: view) </span>if</span>(currentTouches</span>.</span>count != </span>2</span>) { </span>return</span> } </span> </span>currentTouchOne = </span>nil </span>currentTouchTwo = </span>nil </span> </span>currentTouches</span>.</span>forEach { (</span>touch</span>: </span>NSTouch</span>) </span>in </span>if</span>(touch</span>.</span>identity</span>.</span>isEqual(initialTouchOne</span>?.</span>identity)) { </span>currentTouchOne = touch </span>} </span>else</span> { </span>currentTouchTwo = touch </span>} </span>} </span> </span>let</span> initialXPoint = [ </span>initialTouchOne</span>?.</span>normalizedPosition</span>.</span>x ?? </span>0.0</span>, </span>initialTouchTwo</span>?.</span>normalizedPosition</span>.</span>x ?? </span>0.0 </span>].</span>min</span>() ?? </span>0.0 </span> </span>let</span> currentXPoint = [ </span>currentTouchOne</span>?.</span>normalizedPosition</span>.</span>x ?? </span>0.0</span>, </span>currentTouchTwo</span>?.</span>normalizedPosition</span>.</span>x ?? </span>0.0 </span>].</span>min</span>() ?? </span>0.0 </span> </span>let</span> deviceWidth = initialTouchOne</span>?.</span>deviceSize</span>.</span>width ?? </span>0.0 </span>let</span> oldX = (initialXPoint * deviceWidth)</span>.</span>rounded(.</span>up</span>) </span>let</span> newX = (currentXPoint * deviceWidth)</span>.</span>rounded(.</span>up</span>) </span>var </span>delta</span>: </span>CGFloat</span> = </span>0.0 </span>if</span>(oldX > newX) { </span>// Swiping left </span>delta = (oldX - newX) * -</span>1.0 </span>} </span>else if</span>(newX > oldX) { </span>// Swiping right </span>delta = newX - oldX </span>} </span>NSAnimationContext</span>.</span>runAnimationGroup { [</span>weak self</span>] (</span>context</span>: </span>NSAnimationContext</span>) </span>in </span>context</span>.</span>timingFunction = </span>CAMediaTimingFunction</span>(</span>name</span>: .</span>easeIn</span>) </span>context</span>.</span>duration = </span>0.2 </span>context</span>.</span>allowsImplicitAnimation = </span>true </span>self?.</span>leftAnchor</span>?.</span>animator()</span>.</span>constant = delta </span>} } the newest ("current") touches, and compare where they are in relation to the initial touches. There's a bit of math involved here to get this right, as the Trackpad on Mac isn't quite like a touch screen (normalizedPosition</code> doesn't map to a pixel coordinate). Once we've calculated everything, we can begin animating the top (content) view to reveal the contents underneath.</p> </span>func </span>touchesEnded</span>(with </span>event</span>: </span>NSEvent</span>) { </span>if</span>(</span>self.</span>isTracking) { </span>self.</span>endTracking(leftAnchor</span>?.</span>constant ?? </span>0</span>) </span>} } </span>func </span>touchesCancelled</span>(with </span>event</span>: </span>NSEvent</span>) { </span>if</span>(</span>self.</span>isTracking) { </span>self.</span>endTracking(leftAnchor</span>?.</span>constant ?? </span>0</span>) </span>} } c;color:#8be9fd;">func </span>endTracking</span>(</span>_ </span>delta</span>: </span>CGFloat</span>) { </span>initialTouchOne = </span>nil </span>initialTouchTwo = </span>nil </span>currentTouchOne = </span>nil </span>currentTouchTwo = </span>nil </span>isTracking = </span>false </span> </span>let </span>leftThreshold</span>: </span>CGFloat</span> = </span>50.0 </span>let </span>rightThreshold</span>: </span>CGFloat</span> = -</span>50.0 </span>var </span>to</span>: </span>CGFloat</span> = </span>0.0 </span> </span>if</span>(delta > leftThreshold) { </span>to = leftThreshold </span>} </span>else if</span>(delta < rightThreshold) { </span>to = rightThreshold </span>} </span> </span>NSAnimationContext</span>.</span>runAnimationGroup { [</span>weak self</span>] (</span>context</span>: </span>NSAnimationContext</span>) </span>in </span>context</span>.</span>timingFunction = </span>CAMediaTimingFunction</span>(</span>name</span>: .</span>easeIn</span>) </span>context</span>.</span>duration = </span>0.5 </span>context</span>.</span>allowsImplicitAnimation = </span>true </span>self?.</span>leftAnchor</span>?.</span>animator()</span>.</span>constant = to </span>} } ends or is cancelled. We'll forward both of those events into endTracking</code>, which determines the final resting state of the drag animation: if we've dragged far enough in either direction, it'll "snap" to the threshold and hang there until a new swipe gesture begins.</p> yet. As I noted over on the GitHub repository, this could definitely be tied into a SwipeCellKit-esque API (or just into SwipeCellKit entirely). It also doesn't take drag velocity into account, as calculating it on macOS isn't as simple as iOS, and I ended up scrapping this before using it in a shipping product. Feel free to crib whatever code or assets as necessary! If you end up building on this or taking it further, a line of credit would be cool.</p>

Two Years and GUIs</h2>
One of the big (and kind of annoying) discussions that's been bantered about in the tech world over those two years has been whether Electron, a web-browser-masquerading-as-native-app project, is a plague on society or not. Resource wise, it's probably got some argument there, but in terms of productivity it's hands down the king of the castle - effectively trading memory pressure and less focus on platform conventions in favor of just shipping something out the door. You can open and scan any thread on Hacker News or /r/programming and find people bemoaning this repeatedly.</p>
I wouldn't keep those threads open, for what it's worth - there's generally little worth reading in them, beyond people on both sides completely misunderstanding one another. The tl;dr for pretty much every thread is: more traditional native developers tend not to understand web development, or they look down upon it as easier and less worthy of respect. Web developers tend to favor shipping faster to a wider audience, and being able to implement things across (just about) any platform. You'll see some native developers go on about Qt/GTK and co as ideal native approaches (they're not), or advocating tripling your development efforts and re-implementing a UI across n platforms (why would you bother to do this for most commerical projects? Do you enjoy wasting time and money?).</p>
With that all said, I had reason to build some stuff in Rust recently, and wound up wanting to throw together a basic UI for it. Rust is a wonderful language, and I genuinely enjoy using it, but it's very clear that the community doesn't have a GUI focus. I figured I'd end up basically packaging together some web view (Electron or [insert your choice here]), but wanted to see how easily I could finagle things together at a native level. Since I haven't written anything in some time, I figured this would be a good fit for a super short post.</p>
Going Down a GUI Rabbit Hole</h2>
I use a Mac pretty much exclusively, and am pretty familiar with Cocoa, so jumping to that from Rust seemed pretty reasonable. It's also ridiculously simple, thanks to Objective-C - the C interop in Rust makes this fairly transparent, provided you're willing to dabble in the unsafe side of things. What I came up with was a mix of rust-objc</a> and rust-cocoa, from core-foundation-rs</a>, along with some usage of Serde for a quickly hacked together CSS framework.</p>
Given the following example styling...</p>
</span>{
</span></span>    </span>"</span>window</span>"</span>: {
</span></span>        </span>"backgroundColor"</span>: {</span>"r"</span>: </span>35</span>, </span>"g"</span>: </span>108</span>, </span>"b"</span>: </span>218</span>},
</span></span>        </span>"defaultWidth"</span>: </span>800</span>,
</span></span>        </span>"defaultHeight"</span>: </span>600
</span></span>    </span>},
</span></span>
</span></span>    </span>"</span>root</span>"</span>: {
</span></span>        </span>"backgroundColor"</span>: {</span>"r"</span>: </span>35</span>, </span>"g"</span>: </span>108</span>, </span>"b"</span>: </span>218</span>}
</span></span>    </span>},
</span></span>
</span></span>    </span>"</span>sidebar</span>"</span>: {
</span></span>        </span>"backgroundColor"</span>: {</span>"r"</span>: </span>5</span>, </span>"g"</span>: </span>5</span>, </span>"b"</span>: </span>5</span>},
</span></span>        </span>"width"</span>: </span>200</span>,
</span></span>        </span>"height"</span>: </span>400</span>,
</span></span>        </span>"top"</span>: </span>"root.top"</span>,
</span></span>        </span>"left"</span>: </span>"root.left"</span>,
</span></span>        </span>"bottom"</span>: </span>"root.bottom"
</span></span>    </span>},
</span></span>
</span></span>    </span>"</span>content</span>"</span>: {
</span></span>        </span>"backgroundColor"</span>: {</span>"r"</span>: </span>35</span>, </span>"g"</span>: </span>108</span>, </span>"b"</span>: </span>218</span>},
</span></span>        </span>"width"</span>: </span>100</span>,
</span></span>        </span>"height"</span>: </span>300</span>,
</span></span>        </span>"top"</span>: </span>"root.top"</span>,
</span></span>        </span>"left"</span>: </span>"sidebar.right"</span>,
</span></span>        </span>"right"</span>: </span>"root.right"</span>,
</span></span>        </span>"bottom"</span>: </span>"root.bottom"
</span></span>    </span>}
</span></span>}
</span></span></code></pre>
A basic app could be constructed like so:</p>
</span>extern crate</span> shinekit;
</span></span>use </span>shinekit</span>::</span>*</span>;
</span></span>
</span></span>fn </span>main</span>() </span>{
</span></span>    </span>shinekit</span>::</span>run(vec![
</span></span>        </span>StyleSheet</span>::</span>default(include_str!(</span>"styles/default.json"</span>))
</span></span>    </span>], </span>App</span>::</span>new(</span>"App"</span>, </span>View</span>::</span>named(</span>"root"</span>)</span>.</span>subviews</span>(vec![
</span></span>        </span>View</span>::</span>named(</span>"sidebar"</span>),
</span></span>        </span>View</span>::</span>named(</span>"content"</span>)
</span></span>    </span>])));
</span></span>}
</span></span></code></pre>
The declarative approach to the UI is inspired by React (and co). I threw the resulting package on Github as Shinekit</a>, in case anyone out there finds it interesting and would want to hack on it themselves. Since it's basically hacking through Objective-C, I've got a theory that it could be wired up to Microsoft's port of Objective-C for Windows</a>, which ultimately creates native UWP apps.</p>
Of note, some things for GUI programming are a pain in the ass in Rust - e.g, parent and child relationships. Shinekit pushes that stuff over to Cocoa/Objective-C where possible, rather than tackling it head-on. In a sense, it's cheating - but it creates a slightly nicer API, which (in my experience) is important in UI development.</p>
What's Next?</h2>
Well, if you're a native fan, you're gonna hate to hear that yes, I did wind up just throwing a web browser into the mix to ship. Goal wasn't to build a full GUI framework.</p>
With that said... time permitting I'll probably hack on this some more, as the existing GUI options in Rust don't really fit my idea of what a GUI framework should look and function like. As Rust becomes more popular, a decent GUI approach (even for small toolkit apps and the like) would be great to have. If or when this becomes more mature, I'd throw it up on crates.io as something to be used more widely.</p>


A Deep Dive into PL/v8
Tue, 22 Mar 2016 00:00:00 +0000
Back in August, Compose.io announced</a> the addition of JavaScript as an internal language for all new PostgreSQL deployments. This was thanks to the PL/v8 project</a>, which straps Google's rocket of a JavaScript engine (V8) to PostgreSQL. This got me thinking - PL/v8 offers a rich and featureful way to write functions in PostgreSQL. Let's take a look at what it offers by building a mini JavaScript module system on top of it, complete with basic support for the CommonJS API.</p>
Enabling PL/v8 on Your Deployment</h2>
First thing's first: you'll need to enable it by creating the extension. The quickest and easiest way to do this is likely using psql from a terminal (below), but if you prefer using another tool it shouldn't pose any problems.</p>
</span># You can find your login details over on your deployment's overview page 
</span></span>psql </span>"sslmode=require host=[host] port=[port] dbname=[dbname] user=[username]"
</span></span></code></pre></span>-- Once you've logged in, execute the statement below to enable plv8
</span></span>create extension plv8;
</span></span></code></pre>
PL/v8 also supports two extra JavaScript "dialects" - CoffeeScript</a>, and LiveScript</a>. CoffeeScript offers a more Ruby-esque syntax, and LiveScript is a more functional successor to CoffeeScript. We'll be using pure JavaScript in this article, but if you'd like to use either of these languages you'll need to create their extensions below as well.</p>
</span>-- If you prefer a different JS dialect, both CoffeeScript and LiveScript
</span></span>-- are supported. Create their extensions to use them!
</span></span>create extension plcoffee;
</span></span>create extension plls;
</span></span></code></pre>JavaScript in PostgreSQL: The Basics</h2>
Creating a function using PL/v8 looks like any other PostgreSQL function, with the exception of a language specifier change. Take the (basic) example below: we're simply incrementing each int in an Array by 2, and returning it as pure JSON.</p>
</span>create or replace function </span>addtwo</span>(vals </span>int</span>[]) 
</span></span>returns json </span>as</span> $$
</span></span>    </span>return </span>vals</span>.</span>map</span>(function(i) {
</span></span>        </span>return i </span>+ </span>2</span>;
</span></span>    </span>});
</span></span>$$ language plv8;
</span></span>
</span></span>select</span> addtwo(array[</span>0</span>, </span>47</span>, </span>30</span>]);
</span></span>-- Returns [2, 49, 32]
</span></span></code></pre>
JavaScript isn't technically a functional programming language, but it has many elements of one. Those features shine here - mapping over results is incredibly expressive and easy to work with. While you can't get all crazy with any ES6 code yet (the version of V8 currently used is a bit older), pretty much all the good parts of ES5 are up for grabs. Couple that with the native JSON support PostgreSQL offers, and you can get many of the features (e.g, Schema-less storage) from Document-oriented databases like MongoDB or RethinkDB.</p>
As far as working with SQL data in JavaScript goes, it's relatively straightforward. PL/v8 will convert most database types automatically for you, including polymorphic types (anyelement</code>, anyarray</code>, anyenum</code> and anynonarray</code>) and bytea</code> (through JavaScript's Typed Arrays). The only real "gotchas" to be aware of are that any Array you return must be flattened (unless you're returning JSON, in which case go for it), and you can't create your own Typed Arrays for use in functions; you can, however, modify and return the ones passed to your function.</p>
While not strictly a "gotcha", the ever-so-fun issue of context in JavaScript is present in PL/v8. Each SQL function is called with a different_this_ value, and it can be confusing at first. SQL functions do share context though, as far as accessing globally declared variables and functions. As long as you pay attention to scoping issues, you can avoid context binding issues and write reusable code.</p>
Hacking Together a Module System</h2>
V8 is synonymous with Node.js for many developers, and inevitably the question of importing modules comes up. There is no baked-in module system, but we can simulate one using some of the features of PL/v8. It's important to note that while this works, we're in a sandboxed environment - modules involving network calls or browser-related functionality won't work. We'll be simulating the CommonJS module.exports</code> API though, so many modules should "just work" right off npm</a>.</p>
The first thing we'll need is a table to store our module source(s) in. We really only need two columns to start: the module name (module</code>), and the source code (source</code>). To sweeten the deal we'll add an autoload column (autoload</code>) that we'll use to dictate whether a module should be transparently available at all times.</p>
</span>create table </span>plv8_js_modules</span> (
</span></span>    </span>module </span>text</span> unique </span>primary key</span>,
</span></span>    </span>autoload bool </span>default </span>true,
</span></span>    </span>source </span>text
</span></span>);
</span></span></code></pre>
We'll need a function to handle wrapping the require()</code> API, and ideally we'll want a cache for module loading so we're not pulling from a database table every time we require a module. The global plv8</code> object has a few things we'll make use of here - it brings important functionality like executing statements, subtransactions, logging and more to the table. We'll be eval()</code>ing the source for each module, but we wrap it in a function to ensure nothing leaks into the global scope. Our autoloading of certain modules also takes place in this function, just to prime the module cache for later use.</p>
</span>create or replace function </span>plv8_require</span>()
</span></span>returns void </span>as</span> $$
</span></span>    </span>moduleCache </span>=</span> {};
</span></span>
</span></span>    </span>load </span>=</span> function(key, source) {
</span></span>        </span>var module </span>=</span> {exports: {}};
</span></span>        </span>eval(</span>"(function(module, exports) {" </span>+</span> source </span>+ </span>"; })"</span>)(module, </span>module</span>.</span>exports</span>);
</span></span>            </span>
</span></span>        </span>//</span> store </span>in</span> cache
</span></span>        </span>moduleCache[key] </span>= </span>module</span>.</span>exports</span>;
</span></span>        </span>return </span>module</span>.</span>exports</span>;
</span></span>    </span>};
</span></span>
</span></span>    </span>require </span>=</span> function(module) {
</span></span>        </span>if(moduleCache[module])
</span></span>            </span>return moduleCache[module];
</span></span>
</span></span>        </span>var rows </span>= </span>plv8</span>.</span>execute</span>(
</span></span>            </span>"select source from plv8_js_modules where module = $1"</span>, 
</span></span>            </span>[module]
</span></span>        </span>);
</span></span>
</span></span>        </span>if(</span>rows</span>.</span>length </span>=== </span>0</span>) {
</span></span>            </span>plv8</span>.</span>elog</span>(NOTICE, </span>'Could not load module: ' </span>+</span> module);
</span></span>            </span>return </span>null</span>;
</span></span>        </span>}
</span></span>
</span></span>        </span>return load(module, rows[</span>0</span>].source);
</span></span>    </span>};
</span></span>    </span>
</span></span>    </span>//</span> Grab modules worth auto</span>-</span>loading at context start </span>and</span> let them cache
</span></span>    </span>var query </span>= </span>'select module, source from plv8_js_modules where autoload = true'</span>;
</span></span>    </span>plv8</span>.</span>execute</span>(query).forEach(function(row) {
</span></span>        </span>load(</span>row</span>.</span>module</span>, </span>row</span>.</span>source</span>);
</span></span>    </span>});
</span></span>$$ language plv8;
</span></span></code></pre>
Now in terms of using this, we have that dangling context problem to consider - how do we make sure that require()</code> is available to each PL/v8 function that needs it? Well, it just so happens that PL/v8 supports setting a specific function to run before any other functions run. We can use this hook to bootstrap our environment - while ordinarily you could set it in your config files, you don't have access to those on Compose. We can, however, SET</code> this value every time we open a connection. As long as you do this prior to any function call  (including CREATE FUNCTION</code> itself) you'll have access to require()</code>.</p>
</span>-- PL/v8 supports a "start proc" variable that can act as a bootstrap
</span></span>-- function. Note the lack of quotes!
</span></span>SET </span>plv8</span>.</span>start_proc </span>=</span> plv8_require;
</span></span></code></pre>
Let's try it out by throwing together a module that implements the Fisher-Yates shuffle algorithm - we'll name the module "shuffle", to keep things simple, and go ahead and set it to autoload.</p>
</span>insert into</span> plv8_js_modules (module, autoload, source) </span>values</span> (</span>'shuffle'</span>, true, </span>'
</span></span>    </span>module.exports = function(arr) {
</span></span>        </span>var length = arr.length,
</span></span>            </span>shuffled = Array(length);
</span></span>        </span>
</span></span>        </span>for(var i = 0, rand; i < length; i++) {
</span></span>            </span>rand = Math.floor(Math.random() * (i + 1));
</span></span>            </span>if(rand !== i)
</span></span>                </span>shuffled[i] = shuffled[rand];
</span></span>            </span>shuffled[rand] = arr[i];
</span></span>        </span>}
</span></span>        </span>
</span></span>        </span>return shuffled;
</span></span>    </span>};
</span></span>'</span>);
</span></span></code></pre>
Now we should be able to require()</code> this! We can try it immediately - a simple table of people and a super readable random_person()</code> function works well.</p>
</span>create table </span>people</span> (
</span></span>    </span>id </span>serial</span>,
</span></span>    </span>name </span>varchar</span>(</span>255</span>),
</span></span>    </span>age </span>int
</span></span>);
</span></span>
</span></span>insert into</span> people (name, age) </span>values 
</span></span>    </span>(</span>'Ryan'</span>, </span>27</span>),
</span></span>    </span>(</span>'Daniel'</span>, </span>25</span>),
</span></span>    </span>(</span>'Andrew'</span>, </span>23</span>),
</span></span>    </span>(</span>'Sam'</span>, </span>22</span>);
</span></span>
</span></span>create or replace function </span>random_person</span>()
</span></span>returns json </span>as</span> $$
</span></span>    </span>var shuffle </span>=</span> require(</span>'shuffle'</span>),
</span></span>        </span>people </span>= </span>plv8</span>.</span>execute</span>(</span>'select id, name, age from people'</span>);
</span></span>    </span>
</span></span>    </span>return shuffle(people); 
</span></span>$$ language plv8;
</span></span>
</span></span>select</span> random_person();
</span></span>
</span></span>-- Example Response: 
</span></span>-- [{
</span></span>--     "id": 3,
</span></span>--     "name": "Andrew",
</span></span>--     "age": 23
</span></span>-- }, {
</span></span>--     "id": 1,
</span></span>--     "name": "Ryan",
</span></span>--     "age":27
</span></span>-- }, {
</span></span>--     "id": 4,
</span></span>--     "name": "Sam",
</span></span>--     "age": 22
</span></span>-- }, {
</span></span>--     "id": 2,
</span></span>--     "name": "Daniel",
</span></span>--    "age": 25
</span></span>-- }]
</span></span></code></pre>
See how clean that becomes? A shuffle algorithm is only one application - modules like lodash</a> are a prime candidate to check out for using here.</p>
What Are You Waiting For?</h2>
Writing PostgreSQL functions in JavaScript can provide a few wins - if your stack is primarily JavaScript, there's less context-switching involved when dealing with your database. You can reap the benefits of Document-oriented, Schema-less databases while leaving yourself the option to get relational as necessary, and the native support for JSON marries perfectly with JavaScript. Modules can tie it all together and provide a method for organizing code that makes sense - you'll feel right at home.</p>
Even more in-depth documentation on PL/v8 can be found over on the official docs</a>. Try it out today!</p>


RedNoise, a Django-centric WhiteNoise addon
Thu, 04 Jun 2015 00:00:00 +0000
I've developed with Django for a number of years - out of all the
frameworks I've ever used, it strikes the best balance between "let me
get stuff done" and "don't try to provide me too much, get out of my way
when I say so". I was ecstatic when
WhiteNoise</a> was
released, as it solved a very annoying part of the development process
with Django - static files. Rather than uploading things to S3 (ala the
old Storages route) it's now just easier to toss CloudFront in front of
your files and let uwsgi serve it up. Since WhiteNoise debuted, I've
used it on a few different projects, and over time I found myself
wanting a few things that it lacked - django-rednoise provides them.</p>
Feel free to read on for details, or go find it on
GitHub!</a> I published
it as a separate module as the goals differ from the established
WhiteNoise goals, but I'd be absolutely open to it being merged or
pulled from.</p>
DEBUG Please</h2>
WhiteNoise has a Django-specific module that you can use, but it's
essentially geared towards production use-cases. I tend to prefer having
a development setup that mimics my production setup; patching Django
urls to load static or media files in development just feels clunky to
me.</p>
RedNoise respects whether Django is in DEBUG</code> mode or not. If DEBUG</code> is
set to True</code>, RedNoise will mimic Django's default static-file loading
pattern, so you don't need to reload the entire server just to debug
some frontend issues.</p>
Serve Media Files</h2>
WhiteNoise doesn't support serving user-uploaded media files, but I
wound up having to throw together a CMS at one point and ran into this
limitation. Content authors and editors wanted to be able to upload
photos, but I didn't want to have to keep a separate S3 bucket for it
all. RedNoise will serve media files, hooking into the associated
settings.py parameters to make it "just work".</p>
Should You Use It?</h2>
I've run it for a bit with no real issues; I would say that whatever you
do, tossing a CDN in front of it all is pretty efficient. Provided you
do that, the CDN should absorb most of the requests, leaving your server
to do its thing.</p>
If you use WhiteNoise, and wish you had the above features, give
django-rednoise a shot. It's just a pip install</code> away.</p>


Recording Live Audio Streams on iOS
Wed, 08 Jan 2014 00:00:00 +0000
Some people might consider this strange, but I'm still a fan of radio.
It's not my 24/7 music source, but I find myself getting annoyed with
algorithms trying to predict music that I'd like and ultimately failing.
In addition to music, you've got news and sports radio - getting a large
mix is fun.</p>
These days tons of radio stations have moved their streams to be
listen-able online, and recently I found myself wishing I had something
that I could use to record these radio streams on a whim. My main device
is an iPhone 5; sadly, I didn't find anything particularly pleasing or
enjoyable to use in the App Store, so I set out to see about throwing
together my own. What follows is a breakdown of a (relatively) easy way
to download live audio streams using AVFoundation and Core Audio. It
assumes you've got a working knowledge of Objective C, as well as a
working knowledge in terms of building iOS apps in general.</p>
Disclaimer</h2>
This code is here as an example and nothing more. In recording
anything from a live stream that might possibly be copyrighted and/or
legally protected you should ensure that you're allowed to do so. This
post and the author holds no responsibility for what you do with the
content hereafter.</p>
Update 2015</h2>
In the comments spg has shown a case wherein .m3u8</code> files
probably won't work with this method due to how they differ in playback.
It would be cool to see if there's a way around this, but I don't have
time at the moment to investigate sadly. Get in touch if you figure this
out!</p>
Update 2016</h2>
I've sinced removed comments from my site due to their neglect.
Feel free to email me with questions about this though!</p>
Audio Streaming</h2>
The basics of app structure/building aside, the first concern is the
actual streaming of the audio. There are a myriad of factors here that
are honestly just a massive chore to deal with - you've got network
speed issues, you could have the network drop and pick back up, the list
is endless. A cursory Google search tends to show that this is where
people tripped themselves up a lot - the general consensus seems to be
that relying on AVPlayer</code> can't work for remote data, as there's
seemingly no way to get at the AudioBuffer</code> data - it only works with
local files. This leads to everyone reinventing the wheel with the
(arguably painful) Core Audio APIs.</p>
Here's the thing: I had no desire to deal with any of that. They are
certainly interesting</em> problems, but right now they're just in the way.
If possible I would much rather use AVPlayer</code> and let Apple handle all
the intricacies/edge cases in regards to playback.</p>
Enter MTAudioProcessingTap</h2>
Now, MTAudioProcessingTap</code> is no secret - it's what you'd use to, say,
visualize audio data for local files played through AVPlayer</code>. If you're
not familiar with it, this is a pretty good writeup</a>.
The general gist is that you create a tap, set up an audio mix for a
track, and set it on the AVPlayerItem</code> of the audio player. The problem
with remote data is that AVPlayer</code> just works differently there - you
don't have access to any AVAssetTrack</code>s with which to make an
AVMutableAudioMix</code>, presumably because streaming is just a different
setup entirely behind the scenes.</p>
However</strong>, if we look a bit further, after the streaming starts, you
can access an AVAssetTrack</code> on the player. Now it's a simple matter of
KVObserve</code>-ing the status of the player, grabbing the track when it's
available, and setting up our stream handler. Given that it's
MTAudioProcessingTap</code> you could do any number of things here, but
personally I just needed to pass the raw audio data through.</p>
Unlike other articles on this site, I'm opting to just include three
gists at the bottom that act as a full (mini) library, along with
example usage. There's a bit of Core Audio involved, but it's nothing
too annoying - hopefully this helps anyone who's been wondering how to
handle this. This code isn't meant to be drop-in-good-to-go; with this
type of project it's kind of expected that you integrate it based on
your own needs.</p>
If you have questions, you can always feel free to get in touch, be it
email, Twitter, or GitHub. Generally down to help!</p>
</span>#import </span>"GenericClassName.h"
</span></span>
</span></span>@implementation </span>GenericClassName
</span></span>
</span></span>- (</span>void</span>)</span>myMethodToStartRecording
</span></span>{
</span></span>    </span>// Retain it, yo
</span></span>    </span>self</span>.</span>streamer </span>= </span>[RMStreamer </span>new</span>];
</span></span>    </span>[</span>self</span>.</span>streamer</span> recordStreamFromURL</span>:</span>myURL onError</span>:^</span>(</span>NSError </span>*</span>error) </span>{
</span></span>        </span>NSLog</span>(</span>@"Ah junks some error happened: </span>%@</span>"</span>, error);
</span></span>    </span>}</span>];
</span></span>}
</span></span>
</span></span>- (</span>void</span>)</span>myOtherMethodThatStopsStreaming
</span></span>{
</span></span>    </span>[</span>self</span>.</span>streamer</span> stopRecording];
</span></span>    </span>// Do stuff
</span></span>}
</span></span>
</span></span>@end
</span></span></code></pre></span>#import </span><AVFoundation/AVFoundation.h>
</span></span>#import </span><AudioToolbox/AudioToolbox.h>
</span></span>#import </span><Accelerate/Accelerate.h>
</span></span>#import </span><MediaToolbox/MediaToolbox.h>
</span></span>
</span></span>typedef void </span>(</span>^</span>RMStreamerErrorBlock)(</span>NSURL </span>*</span>);
</span></span>
</span></span>@interface </span>RMStreamer : </span>NSObject
</span></span>
</span></span>@property </span>(</span>nonatomic</span>, </span>strong</span>, </span>readonly</span>) </span>NSURL </span>*</span>outputURL;
</span></span>@property </span>(</span>nonatomic</span>, </span>assign</span>, </span>readonly</span>) ExtAudioFileRef captureFile;
</span></span>@property </span>(</span>nonatomic</span>, </span>strong</span>, </span>readonly</span>) AVPlayer </span>*</span>audioPlayer;
</span></span>@property </span>(</span>nonatomic</span>, </span>copy</span>) RMStreamerErrorBlock onError;
</span></span>
</span></span>- (</span>void</span>)</span>recordStreamFromURL:</span>(</span>NSURL </span>*</span>)</span>url </span>onError:</span>(RMStreamerErrorBlock)</span>error</span>;
</span></span>- (</span>void</span>)</span>stopRecording</span>;
</span></span>
</span></span>@end
</span></span></code></pre></span>#import </span>"RMStreamer.h"
</span></span>
</span></span>// Allows us to get access to our RMStreamer instance in the process method below~
</span></span>void </span>init</span>(MTAudioProcessingTapRef </span>tap</span>, </span>void </span>*</span>clientInfo</span>, </span>void </span>**</span>tapStorageOut</span>) </span>{
</span></span>    </span>*</span>tapStorageOut </span>=</span> clientInfo;
</span></span>}
</span></span>
</span></span>void </span>finalize</span>(MTAudioProcessingTapRef </span>tap</span>)
</span></span>{
</span></span>    </span>// Self explanatory - any final operations you need to handle.
</span></span>    </span>// I didn't need much in the way of anything here.
</span></span>}
</span></span>
</span></span>// We defer the creation of our output file until this is called - by doing so,
</span></span>// we don't need to guess at the format it comes in as.
</span></span>void </span>prepare</span>(
</span></span>    </span>MTAudioProcessingTapRef </span>tap</span>, 
</span></span>    </span>CMItemCount </span>maxFrames</span>, 
</span></span>    </span>const</span> AudioStreamBasicDescription </span>*</span>processingFormat
</span></span>) </span>{
</span></span>    </span>NSLog</span>(</span>@"Preparing the Audio Tap Processor"</span>);
</span></span>    </span>RMStreamer </span>*</span>streamer </span>= </span>(__bridge RMStreamer </span>*</span>) </span>MTAudioProcessingTapGetStorage</span>(tap);
</span></span>    </span>[streamer </span>createOutputFileForStreamWithFormat:</span>*</span>processingFormat];
</span></span>}
</span></span>
</span></span>void </span>unprepare</span>(MTAudioProcessingTapRef </span>tap</span>) </span>{
</span></span>    </span>// Self explanatory - if you have things you need done here, do them.
</span></span>}
</span></span>
</span></span>void </span>process</span>(
</span></span>    </span>MTAudioProcessingTapRef </span>tap</span>,
</span></span>    </span>CMItemCount </span>numberFrames</span>,
</span></span>    </span>MTAudioProcessingTapFlags </span>flags</span>,
</span></span>    </span>AudioBufferList </span>*</span>bufferListInOut</span>,
</span></span>    </span>CMItemCount </span>*</span>numberFramesOut</span>,
</span></span>    </span>MTAudioProcessingTapFlags </span>*</span>flagsOut
</span></span>) </span>{
</span></span>    </span>RMStreamer </span>*</span>streamer </span>= </span>(__bridge RMStreamer </span>*</span>) </span>MTAudioProcessingTapGetStorage</span>(tap);
</span></span>
</span></span>    </span>OSStatus</span> err </span>= </span>MTAudioProcessingTapGetSourceAudio</span>(
</span></span>        </span>tap, 
</span></span>        </span>numberFrames, 
</span></span>        </span>bufferListInOut, 
</span></span>        </span>flagsOut, 
</span></span>        </span>NULL</span>, 
</span></span>        </span>numberFramesOut
</span></span>    </span>);
</span></span>    </span>
</span></span>    </span>if</span>(err) </span>{
</span></span>        </span>// There was an error getting audio buffers from the stream.
</span></span>        </span>// React accordingly in your application!
</span></span>        </span>streamer</span>.</span>onError</span>([</span>NSError 
</span></span>            </span>errorWithDomain</span>:</span>NSOSStatusErrorDomain 
</span></span>            </span>code</span>:</span>err 
</span></span>            </span>userInfo</span>:</span>nil
</span></span>        </span>]);
</span></span>    </span>}
</span></span>    </span>
</span></span>    </span>OSStatus</span> f </span>= </span>ExtAudioFileWrite</span>(
</span></span>        </span>streamer</span>.</span>captureFile</span>, 
</span></span>        </span>*</span>numberFramesOut, 
</span></span>        </span>bufferListInOut
</span></span>    </span>);
</span></span>    </span>
</span></span>    </span>if</span>(f) </span>{
</span></span>        </span>// Writing to the audio file failed for some reason. Check why and react.
</span></span>        </span>streamer</span>.</span>onError</span>([</span>NSError 
</span></span>            </span>errorWithDomain</span>:</span>NSOSStatusErrorDomain 
</span></span>            </span>code</span>:</span>err 
</span></span>            </span>userInfo</span>:</span>nil
</span></span>        </span>]);
</span></span>    </span>}
</span></span>}
</span></span>
</span></span>@implementation </span>RMStreamer
</span></span>
</span></span>- (</span>void</span>)</span>recordStreamFromURL:</span>(</span>NSURL </span>*</span>)</span>url </span>onError:</span>(RMStreamerErrorBlock)</span>error
</span></span>{
</span></span>    </span>_onError </span>=</span> error;
</span></span>    </span>
</span></span>    </span>AVPlayerItem </span>*</span>item </span>= </span>[AVPlayerItem </span>playerItemWithURL:</span>url];
</span></span>    </span>_audioPlayer </span>= </span>[AVPlayer </span>playerWithPlayerItem:</span>item];
</span></span>
</span></span>    </span>// Watch the status property - when this is good to go, we can access the
</span></span>    </span>// underlying AVAssetTrack we need.
</span></span>    </span>[item </span>addObserver:</span>self </span>forKeyPath:</span>@"status" </span>options:</span>0 </span>context:</span>nil</span>];
</span></span>}
</span></span>
</span></span>- (</span>void</span>)</span>observeValueForKeyPath:</span>(</span>NSString </span>*</span>)</span>keyPath 
</span></span>                      </span>ofObject:</span>(</span>id</span>)</span>object 
</span></span>                        </span>change:</span>(</span>NSDictionary </span>*</span>)</span>change 
</span></span>                       </span>context:</span>(</span>void </span>*</span>)</span>context
</span></span>{
</span></span>    </span>if</span>(</span>!</span>[keyPath </span>isEqualToString:</span>@"status"</span>])
</span></span>        </span>return</span>;
</span></span>    </span>
</span></span>    </span>AVPlayerItem </span>*</span>item </span>= </span>(AVPlayerItem </span>*</span>)object;
</span></span>    </span>if</span>(item</span>.</span>status </span>!=</span> AVPlayerItemStatusReadyToPlay)
</span></span>        </span>return</span>;
</span></span>        </span>
</span></span>    </span>AVURLAsset </span>*</span>asset </span>= </span>(AVURLAsset </span>*</span>)item</span>.</span>asset</span>;
</span></span>    </span>AVAssetTrack </span>*</span>audioTrack </span>= </span>[asset </span>tracksWithMediaType:</span>AVMediaTypeAudio][</span>0</span>];
</span></span>    </span>[</span>self </span>beginRecordingAudioFromTrack:</span>audioTrack];
</span></span>    </span>[_audioPlayer </span>play</span>];
</span></span>}
</span></span>
</span></span>- (</span>void</span>)</span>beginRecordingAudioFromTrack:</span>(AVAssetTrack </span>*</span>)</span>audioTrack
</span></span>{
</span></span>    </span>// Configure an MTAudioProcessingTap to handle things.
</span></span>    </span>MTAudioProcessingTapRef tap;
</span></span>    </span>MTAudioProcessingTapCallbacks callbacks;
</span></span>    </span>callbacks</span>.</span>version </span>= </span>kMTAudioProcessingTapCallbacksVersion_0</span>;
</span></span>    </span>callbacks</span>.</span>clientInfo </span>= </span>(__bridge </span>void </span>*</span>)(</span>self</span>);
</span></span>    </span>callbacks</span>.</span>init </span>=</span> init;
</span></span>    </span>callbacks</span>.</span>prepare </span>=</span> prepare;
</span></span>    </span>callbacks</span>.</span>process </span>=</span> process;
</span></span>    </span>callbacks</span>.</span>unprepare </span>=</span> unprepare;
</span></span>    </span>callbacks</span>.</span>finalize </span>=</span> finalize;
</span></span>    </span>
</span></span>    </span>OSStatus</span> err </span>= </span>MTAudioProcessingTapCreate</span>(
</span></span>        </span>kCFAllocatorDefault</span>, 
</span></span>        </span>&</span>callbacks, 
</span></span>        </span>kMTAudioProcessingTapCreationFlag_PostEffects</span>, 
</span></span>        </span>&</span>tap
</span></span>    </span>);
</span></span>    </span>
</span></span>    </span>if</span>(err) </span>{
</span></span>        </span>NSLog</span>(</span>@"Unable to create the Audio Processing Tap </span>%ld</span>"</span>, err);
</span></span>        </span>_onError</span>([</span>NSError </span>errorWithDomain:</span>NSOSStatusErrorDomain </span>code:</span>err </span>userInfo:</span>nil</span>]);
</span></span>        </span>return</span>;
</span></span>    </span>}
</span></span>
</span></span>    </span>// Create an AudioMix and assign it to our currently playing "item", which
</span></span>    </span>// is just the stream itself.
</span></span>    </span>AVMutableAudioMix </span>*</span>audioMix </span>= </span>[AVMutableAudioMix </span>audioMix</span>];
</span></span>    </span>AVMutableAudioMixInputParameters </span>*</span>inputParams </span>= </span>[AVMutableAudioMixInputParameters 
</span></span>        </span>audioMixInputParametersWithTrack</span>:</span>audioTrack];
</span></span>        </span>
</span></span>    </span>inputParams</span>.</span>audioTapProcessor </span>=</span> tap;
</span></span>    </span>audioMix</span>.</span>inputParameters </span>=</span> @[inputParams];
</span></span>    </span>_audioPlayer</span>.</span>currentItem</span>.</span>audioMix </span>=</span> audioMix;
</span></span>}
</span></span>
</span></span>// This you'll want to customize to your needs - it's pulled from my 
</span></span>// own project and quickly revamped. Good luck!
</span></span>- (</span>void</span>)</span>createOutputFileForStreamWithFormat:</span>(AudioStreamBasicDescription)</span>clientFormat
</span></span>{
</span></span>    </span>// This is an incredibly generic file path. Customize as need be.
</span></span>    </span>NSError </span>*</span>nserr </span>= </span>nil</span>;
</span></span>    </span>NSFileManager </span>*</span>fm </span>= </span>[</span>NSFileManager </span>defaultManager</span>];
</span></span>    </span>NSArray </span>*</span>paths </span>= </span>NSSearchPathForDirectoriesInDomains</span>(
</span></span>        </span>NSDocumentDirectory</span>, 
</span></span>        </span>NSUserDomainMask</span>, 
</span></span>        </span>YES
</span></span>    </span>);
</span></span>    </span>NSString </span>*</span>documentsDirectory </span>= </span>[paths </span>objectAtIndex:</span>0</span>];
</span></span>    </span>NSString </span>*</span>dir </span>= </span>[documentsDirectory </span>stringByAppendingPathComponent:</span>@"rm_streamer"</span>];
</span></span>    </span>if</span>(</span>!</span>[fm </span>fileExistsAtPath:</span>dir])
</span></span>        </span>[fm </span>createDirectoryAtPath:</span>dir 
</span></span>            </span>withIntermediateDirectories:</span>YES 
</span></span>            </span>attributes:</span>nil 
</span></span>            </span>error:</span>&</span>nserr];
</span></span>    </span>
</span></span>    </span>NSTimeInterval</span> timestamp </span>= </span>[[</span>NSDate </span>date</span>] timeIntervalSince1970];
</span></span>    </span>NSString </span>*</span>output </span>= </span>[</span>NSString </span>stringWithFormat:</span>@"</span>%@</span>/</span>%f</span>.caf"</span>, dir, timestamp];
</span></span>    </span>unlink</span>([output </span>UTF8String</span>]);
</span></span>    </span>
</span></span>    </span>_outputURL </span>= </span>[</span>NSURL </span>fileURLWithPath:</span>];
</span></span>    </span>OSStatus</span> err </span>= </span>ExtAudioFileCreateWithURL</span>(
</span></span>        </span>(__bridge CFURLRef)_outputURL, 
</span></span>        </span>kAudioFileCAFType</span>, 
</span></span>        </span>&</span>clientFormat, 
</span></span>        </span>NULL</span>, 
</span></span>        </span>kAudioFileFlags_EraseFile</span>, 
</span></span>        </span>&</span>_captureFile
</span></span>    </span>);
</span></span>    </span>
</span></span>    </span>if</span>(err) </span>{
</span></span>        </span>_onError</span>([</span>NSError </span>errorWithDomain:</span>NSOSStatusErrorDomain </span>code:</span>err </span>userInfo:</span>nil</span>]);
</span></span>        </span>// An error occurred with creating the file. Go figure.
</span></span>    </span>}
</span></span>    </span>
</span></span>    </span>// This setting is... annoying. Some devices will randomly crap out 
</span></span>    </span>// if the hardware audio support is wonky. Change as you need to.
</span></span>    </span>UInt32</span> codecManf </span>= </span>kAppleHardwareAudioCodecManufacturer</span>;
</span></span>    </span>// UInt32 codecManf = kAppleSoftwareAudioCodecManufacturer;
</span></span>    </span>err </span>= </span>ExtAudioFileSetProperty</span>(
</span></span>        </span>_captureFile, 
</span></span>        </span>kExtAudioFileProperty_CodecManufacturer</span>, 
</span></span>        </span>sizeof</span>(</span>UInt32</span>), 
</span></span>        </span>&</span>codecManf
</span></span>    </span>);
</span></span>
</span></span>    </span>if</span>(err) </span>{
</span></span>        </span>_onError</span>([</span>NSError </span>errorWithDomain:</span>NSOSStatusErrorDomain </span>code:</span>err </span>userInfo:</span>nil</span>]);
</span></span>        </span>return</span>;
</span></span>    </span>}
</span></span>    </span>
</span></span>    </span>err </span>= </span>ExtAudioFileSetProperty</span>(
</span></span>        </span>_captureFile, 
</span></span>        </span>kExtAudioFileProperty_ClientDataFormat</span>, 
</span></span>        </span>sizeof</span>(clientFormat), 
</span></span>        </span>&</span>clientFormat
</span></span>    </span>);
</span></span>    </span>
</span></span>    </span>if</span>(err) </span>{
</span></span>        </span>_onError</span>([</span>NSError </span>errorWithDomain:</span>NSOSStatusErrorDomain </span>code:</span>err </span>userInfo:</span>nil</span>]);
</span></span>        </span>return</span>;
</span></span>    </span>}
</span></span>}
</span></span>
</span></span>// Getting an MTAudioProcessingTapRef to properly release is kind of annoying in general.
</span></span>// This should more or less handle it~
</span></span>- (</span>void</span>)</span>stopRecording
</span></span>{
</span></span>    </span>[_audioPlayer </span>pause</span>];
</span></span>    </span>ExtAudioFileDispose</span>(_captureFile);
</span></span>
</span></span>    </span>[_audioPlayer</span>.</span>currentItem</span> removeObserver</span>:</span>self</span> forKeyPath</span>:</span>@"status"</span>];
</span></span>    </span>AVMutableAudioMixInputParameters </span>*</span>params </span>= </span>(AVMutableAudioMixInputParameters </span>*</span>) _player</span>.</span>currentItem</span>.</span>audioMix</span>.</span>inputParameters</span>[</span>0</span>];
</span></span>    </span>MTAudioProcessingTapRef tap </span>=</span> params</span>.</span>audioTapProcessor</span>;
</span></span>    </span>_player</span>.</span>currentItem</span>.</span>audioMix </span>= </span>nil</span>;
</span></span>    </span>_player </span>= </span>nil</span>;
</span></span>    </span>CFRelease</span>(tap);
</span></span>}
</span></span>
</span></span>@end
</span></span></code></pre>


We are the New Blue Collar
Wed, 10 Apr 2013 00:00:00 +0000
Over the past year, there's been an explosion of interest in terms of
teaching children how to program in schools. This is a great movement;
the world is becoming more digital by the day, and as we automate away
jobs with technology we certainly need more people to help maintain that
automation. While it's not a 1:1 replacement for the jobs that get lost
in the process, it's an industry that's not going anywhere.
Organizations such as Treehouse</a> or
Codecademy</a>, and efforts such as
code.org</a> are helping educate others when
it comes to the simple fact that these skills are useful in todays
economy and cannot be ignored.</p>
The thing is, as someone who's lived and worked "in the trenches" for
the past seven to eight years, the rhetoric coming out of some of these
movements is somewhat alarming. I think this is doing a major disservice
to the future generations of programmers, and I wanted to take a minute
to explain what learning to program really does for you, career-wise.</p>
The Hidden Side of Programming</h2>
There's a few things these movements don't</em> teach you about programming
for a living.</p>

Simply learning to program does not automatically open doors for you - being successful in programming requires drive and hard work just
like any other industry.</li>
A great deal of programming jobs are based in maintaining a code
base, not "writing the future" or the latest amazing technology.
Generally, we as programmers fear jobs that are just maintenance.
It's not something that will be explained outside of the core of the
industry - these jobs don't typically offer you advancement
opportunities, they stifle your creativity and generally cause you to
consider looking for a new job, often going against what can be (in
many cases) a considerably decent salary.</li>
That aforementioned "considerably decent" salary will be driven down
over time as more and more programmers become available. What's
posited as a great reason to learn to code right now (money) won't
necessarily be the case in a few years.</li>
Ultimately, what's often thrown around as you get further into this
career is the fact that nobody wants to be doing this when they're 40
years old. At some point you either try to move up to management, or
change careers (or retire, if you're lucky enough).</li>
</ul>
If you're following along, this isn't really considered a long-term
career path. As the world becomes more and more digital, being able to
program becomes the same kind of skill as being good with your hands and
being able to follow some directions. Yes, knowing how to control the
devices and technology around you enables</em> you to "build out your
dreams" or "own your destiny", but it's not a given - it requires levels
of drive and dedication that some people aren't willing to put out
there.</p>
The entire world cannot be artists, or it wouldn't function. If I talk
to any programmer I know who actually enjoys doing this for work, they
consider themselves an artist first and a data wrangler second; it's not
a particularly enjoyable field to be in just for the money. These
educational programs and efforts sell themselves as a way to realize
your dreams, and while that's a lofty goal, it's just not a given
because you can now write some code.</p>
Dissecting some Lofty Quotes</h2>

    "Coding is the American Dream. If you want to be the next Mark
    Zuckerberg or even want a high-paying job, those jobs are for
    programmers. … And yet the opportunity to be exposed to that is going to
    the top 10 percent, and that is just morally wrong."
    


    Hadi Partovi, Founder, code.org
</blockquote>
I would hesitate to refer to "Coding" as the "American Dream". The role
of a programmer is easily equated with any service-industry level job,
albeit using more of your brain than your hands. You're still beholden
to someone else at the end of the day, someone who controls when you get
paid, someone who expects more and more with less and less. Programming
is not a safe haven from the economic woes we face today.</p>
I believe the point made at the end of this quote to be very accurate,
though: the top 10 percent shouldn't have the only access to essential
knowledge deemed 'critical'. The thing is that this statement could be
used for just about any industry out there today - Law, Medicine, even
Craftsmanship; our society doesn't enable easy access to this
information any more than it does with programming. It's a larger
problem that needs to be solved.</p>

"Coders change the world. They build new, amazing things faster than
    ever before. Anyone with imagination can learn to write code."
    


    Jeff Wilke, SVP Consumer Business, Amazon.com (via code.org)
</blockquote>
This is an incredibly bland quote that glazes over the fact that most
programming jobs don't actually entail building new amazing things. It
is very, very possible that you will wind up maintaining someone else's
code or editing a trainwreck that the person before you created. It's
not all innovation and aspirations.</p>

    "We need people from all walks of life to learn to code. Control your
    destiny, help your family, your community and your country."
    


    Mitch Kapor, Founder, Lotus Development Corporation & Partner, Kapor Capital (via code.org)
</blockquote>
Another bland quote that implies that being able to program helps you
control your destiny. If you have a desire to learn</em>, you're in control
of your destiny. Subscribing to a single discipline doesn't guarantee
you success or even (necessarily) the chance to obtain your goals. It's
a tool, a utility.</p>

    "Our programmers are our artists. They write beautiful code that
    millions of our travelers start to play with, to use, to help them
    travel better. It's a profound sense of power and satisfaction to have
    your work affect so many, so quickly, across the globe."
    

Dara Khosrowshahi, CEO, Expedia, Inc. (via code.org)
</blockquote>
I've worked with a ton of programmers in the past, at different
companies of varying sizes (startups, bigger companies,
freelancing/contracting), all over the world, and as a result I don't
feel off the mark with this statement: you wind up not caring about this
two weeks in. As long as you're creating for someone else and some
company owns what you build, you begin to back off of the idea of going
all in. You stop being wow'd by the idea that millions of people use
what you wrote - you realize it's the network effect, and you could go
work any number of other computer-related jobs and have the same thing.
This isn't to say you're a passion-lacking worker-bee; you might have
aspirations of helping people around the world, and that's a good thing I'm just illustrating what's not often shown.</p>
You'll see many deny this, though, as the tech industry has a problem
with speaking out, and has what could arguably could be considered a
very Japanese</a> work
ethic</a> - you live and die by the company you work for.</p>
Granted, we're not at the point of literally dying, but the hours and
expected commitment have many sad comparisons. It's also not to say you
have to fit that mould - it's just noting an environment you could
easily wind up in. You're expected to care 110%, or they'll find someone
else who can do what you won't.</p>
   "If you can program a computer, you can achieve your dreams. A computer
    doesn't care about your family background, your gender, just that you
    know how to code. But we're only teaching it in a small handful of
    schools, why?"


    Dick Costolo, CEO, Twitter (via code.org)
</blockquote>
Whether a computer cares about you or not is totally irrelevant in terms
of whether you should learn how to program or not. We should be teaching
it in more schools, but we should be teaching it for the right reasons -
it's essential, and can be an art, but it is not some almighty savior.</p>

"The extensive Treehouse library of step-by-step video courses and
    training exercises will give you a wide range of competitive, in-demand
    technology skills that will help you land your next dream job or build
    your startup idea"


    Treehouse.com
</blockquote>

"Our mission is to bring affordable Technology education to people
    everywhere, in order to help them achieve their dreams and change the
    world."


    Treehouse.com
</blockquote>
The company that's going to get involved with schools and teach
children how to
program</a>...
is presenting themselves as a way to land a dream job or become your own
boss. The former isn't always</em> the case, and the latter is in actuality
such a rare occurrence that most people never have it. I greatly</em>
admire them for reducing the costs surrounding teaching this material,
but positioning this as a world changing proposition for the people who
choose to give it a shot is ultimately misleading.</p>
So Should I Learn to Code?</h2>
Yes. A million times yes. Just do it for yourself; don't do it for the
money (because it won't always be there), and don't do it because people
tell you it's job security - you can't possibly do it forever, and
unless you plan your retirement correctly, good luck when you're 40. If
you don't get into it as an art, then you're getting into nothing but
new-age labor. You become a mechanic of the digital age.</p>
I believe programming should be taught in schools, and I 100% agree it's
an essential skill in the world today. I do not, however, agree with the
people who seem to believe that it's the most life changing thing you
could do for yourself (of course, I encourage you to determine this for
yourself). If we're not careful, we're going to do to the next
generation what earlier ones did to us. We have a country of college
graduates who were brought up on the idea that there'd be jobs for them,
because it's what they were led to believe from those who came before
them.</p>
They were wrong.</p>
Teaching programming is an important goal as we move forward, but it is
not a fix for a broken educational system. If we want kids to succeed,
we need to continue to focus on fixing that - rooting out the bad
teachers and paying teachers more</em>. We need to fix the problem in this
country that people are going hundreds of thousands of dollars in debt
just to have a decent paying job.</p>
The aforementioned programs don't fix these problems; they're simply
training for the newest blue collar job.</p>
Note:</strong> code.org is not full of bad quotes; I think it's a genuinely
good idea as far as movements go. The quotes I pulled are indicative of
the problem, a case of making the field out to be something it's not.</p>


Where is Ryan now? (tl;dr: Quit myGengo)
Sun, 08 Apr 2012 00:00:00 +0000
Six months is quite a bit of time to leave a personal writing depot
without updates, but when your life turns somewhat upside down you end
up neglecting things you never really expected to. In the past few
months, I've been asked "what are you doing now?" more times than I can
count. So it's publicly noted (and so I stop getting emails...) I quit
myGengo in February of 2012. They're mostly good people, and if you
think you're a good fit you should go look at joining them or using
their services. Now, as for what's next...</p>
I did yet another stint of traveling in the world, which has by far
become the most interesting thing for me as of late. Switzerland
(Zurich), England (London), Portugal (Lisbon/et al), Spain (Madrid,
Bilbao, St. Sebastian), Germany (Stuttgart, Berlin)... a somewhat long
list crammed into a few months. While it's fun and interesting, it's
also still... somewhat unfulfilling. I've found that unless I'm working
on something at all times, I'm just not happy. Remedying this has oddly
led me down a path of figuring out what I want to be working on.</p>
Who, me? Couldn't be...</h2>
I took a look at all the projects I've done over the past five or so
years. In the beginning it was a lot of client work, with open source
work dotting the landscape from time to time. As I gained more
experience in terms of my overall programming skill, open source work
took on more importance, and I eventually put down client work almost
completely. Now, it's a new point - I've found that my brain is again
interested in client work, although it's largely just one client - that
being myself. It's become a game of justifying my output for someone
else's vision or path.</p>
This isn't to say I can't see myself working for or with another
company, party, person, or cause in the future, it just has to be the
right fit. In the meantime, I'm mulling over various offers from
companies around the world while working on personal projects that I'd
like to release in the near future. It's a mix of things, as is my
general style - you've got some design, some product, some iOS/Android
App level work, and some basic web work.</p>
I'm also open to new contract work; if you've got an interesting project
or idea, feel free to get in touch with me!</p>
Moving Forward...</h2>
I want to check out Singapore. I've spent a bit too much time in
Europe-ish regions recently; short of London, I could do with a bit of a
break (seriously, people, open stores on Sunday or you will drive people
like me away). I want to finish up the few mobile projects on my plate,
and ultimately get back to updating this site more often, ideally with
concrete projects to point to.</p>


Using Javascript to control the Nintendo Wii
Mon, 15 Aug 2011 00:00:00 +0000
The Nintendo Wii was released around the end of 2006. That's a solid
four years now; an amazing amount of time in the lifespan of a
technological device these days. Often overlooked is the fact that the
Wii has a web browser, which is in fact a build of Opera, offering
support for canvas, CSS3, and more advanced aspects of HTML5. This
should be incredible; why does nobody develop more for it?</p>
The Ugly Truth</h2>
The chief portion is the target market; with so many internet enabled
devices laying around these days, the Wii's browsing experience is one
that tends to fall a little short. This was further compounded by a
small incident wherein, once the Wii's browser was released, an article
went up on Opera's official website about responding to Wii remote
commands in Javascript - Nintendo later demanded that they take it down,
and to this date I've never seen any official reasoning put forth by
either company.</p>
With that said, I don't think the Wii (and the browser therein) are 100%
lost potential. One of my goals in life is to examine and improve the
methods with which we teach programming to children, and I believe the
Wii can work very well for these purposes. Typically, young children
don't have their own computers, and from what I've found the recurring
issue here is that when they're using their parents computers, they
don't have creative freedom to do something that carries with it the
idea of being possibly "destructive".</p>
The Wii, on the other hand, is generally thought of as the "kids" device - it has a limited set of functionality that kids grasp pretty well
right off the bat, and coupled with the concept of "ownership" they'd
get out of this device it stands to reason they're more likely to
experiment on it.</p>
There used to be various Wii javascript libraries/SDKs laying around,
but most of them are woefully incomplete or no longer available. So with
that all in mind, I set out to build a library that allows simple, easy,
event-based interaction with the Wii's browser, hiding away the somewhat
insane complexities of reading the remote codes.</p>
Enter: wii-js</h2>
You can check out wii-js</a>
over on GitHub; it's entirely open source and released under an
MIT-style license. While the repository has in-depth documentation of
library usage, check out the example below and see how simple this has
become:</p>
</span>/**
</span></span> </span>*    Two wii remote instances; first one tracks the first
</span></span> </span>*    controller (held horizontally), the second one tracks
</span></span> </span>*    the second controller (held vertically).
</span></span> </span>*/
</span></span>var </span>wiimote </span>= new </span>Wii</span>.</span>Remote</span>(</span>1</span>, </span>{</span>horizontal: </span>true</span>}</span>), 
</span></span>    </span>wiimote2 </span>= new </span>Wii</span>.</span>Remote</span>(</span>2</span>, </span>{</span>horizontal: </span>false</span>}</span>);
</span></span>
</span></span>/**
</span></span> </span>*    Listen for the "A button pressed" event on each wiimote.
</span></span> </span>*/
</span></span>wiimote</span>.</span>when</span>(</span>'pressed_a'</span>, </span>function</span>() </span>{
</span></span>    </span>alert</span>(</span>'Wii Remote #1 pressed A!'</span>);
</span></span>}</span>);
</span></span>
</span></span>wiimote2</span>.</span>when</span>(</span>'pressed_a'</span>, </span>function</span>() </span>{
</span></span>    </span>alert</span>(</span>'Wii Remote #2 pressed A!'</span>);
</span></span>}</span>);
</span></span>
</span></span>/**
</span></span> </span>*    Start the system!
</span></span> </span>*/
</span></span>Wii</span>.</span>listen</span>();
</span></span></code></pre>
This example showcases how to set up basic controller instances, and
respond to events that they fire. Most button combinations are supported
(check the docs on GitHub for up-to-date event listings), but sadly this
library can only work with the actual Wii-remote. Nintendo (or Opera,
it's unknown who) opted not to provide controller mappings for anything
else, be it classic controllers or Gamecube controllers. All Wii remote
instances, with the exception of the first one, can get controller
events from the nunchuk; there doesn't appear to be a way around this,
which is nothing short of a shame.</p>
That said, even with these limitations, it remains a pretty versatile
library. The next steps for it are bundling in some basic sound/game
engine support to make it even easier for kids to jump in and create.
Follow the project on GitHub to see updates!</p>
A Note About Performance</h2>
Sadly, the Wii isn't the most performant device. It has significantly
less memory than most devices on the market today; due to this, it's
possible to get under-performant pretty quickly. While it does support
the canvas element, it appears you can't force a repaint any faster than
in 100ms intervals - anything lower and the Wii begins to choke
repeatedly. This isn't really fast enough for games; canvas may be
useful for other techniques, but for the most part any game engine
that's done outside of Flash needs to be using HTML or SVG. SVG seems
promising in recent tests, and it has a side benefit of reacting to DOM
events like HTML based scenarios do.</p>
Opera on the Wii also appears to have some level of support for
Server-Sent
Events</a>, which
could possibly prove useful for enabling lightweight two player
interaction. The performance considerations here are currently unknown
at this time.</p>
The Future</h2>
Nintendo recently announced their new console, the Wii U</em>. Whether it
will keep the Opera web browser is anyone's guess; it's worth noting
that the new 3DS replaced the Opera browser used on previous DS
incarnations with an engine similar to that of the PSP. There aren't too
many usage metrics which we can use to draw predictions from, either, so
at the moment it's a bit of "wait and see".</p>
I'm going to continue developing the library and concepts surrounding it
during my free time, and ideally want to try teaching a small class or
two once I've further refined it. If you're interested in helping out,
fork away on GitHub!</p>


Using the myGengo Translation API with Python
Tue, 31 May 2011 00:00:00 +0000
For those who haven't heard the news, Google has deprecated a slew of
their APIs</a>,
leaving many developers and services in a bit of a pinch. While there's
admittedly still time for developers to transition, it's a good time to
start considering alternatives. In my opinion, it's probably a good idea
to choose an alternative that has the technology in question as a core
competency, otherwise you're much more liable to have your provider pull
the rug out from underneath you.</p>
With that said, many engineers are hit particularly hard by the
deprecation of the Translation API that Google has so generously offered
up to this point, and desire a solid alternative. While there are other
machine translation APIs out there, I wanted to take a moment to show
more developers how integrating with the myGengo
API</a> can get them the
best of both worlds.</p>

    A Polite Heads Up</h4>
    
As of May 31, 2011 I am currently working with myGengo to further
    develop their translation services. However, this post represents my
    own thoughts and opinions, and in no way represents myGengo as a
    company. myGengo offers both free machine translation</strong> and paid
    human translation under one API. I simply
    want to show other developers that this is very easy to use.
    </p>
</div>
Getting Started with the myGengo API</h2>
This takes all of 5 minutes to do, but it's required before you can
start getting things translated. A full
rundown</a> is available,
which includes details on using the API Sandbox for extensive testing.
For the code below, we're going to work on the normal account.</p>

Create a myGengo account</a>.</li>
Once you've done that, create some API keys</a>.</li>
Install python-mygengo: pip install mygengo</code></li>
</ul>
A Basic Example</h2>
The myGengo API is pretty simple to use, but the authentication and
signing can be annoying to do at first (like many other APIs). To ease
this, there's a few client libraries you can use - the one I advocate
using (and to be fair, I also wrote it) is the
mygengo-python</a> library,
which you just installed. With this it becomes incredibly easy to start
making calls and submitting things for translation:</p>
</span>from </span>mygengo </span>import </span>MyGengo
</span></span>
</span></span>gengo </span>= </span>MyGengo</span>(
</span></span>    </span>public_key </span>= </span>'your_public_key'</span>,
</span></span>    </span>private_key </span>= </span>'your_private_key'</span>,
</span></span>    </span>sandbox </span>= </span>False</span>, </span># possibly True, depending on your dev needs
</span></span>)
</span></span>
</span></span>print </span>gengo</span>.</span>getAccountBalance</span>()[</span>'response'</span>][</span>'credits'</span>]
</span></span></code></pre>
The above script should print out your current account credits.</p>

Actually Translating Text</h2>
Extending the above bit of code to actually translate some text is very
simple - the thing to realize up front is that myGengo works on a system
of tiers</strong>, with said tiers being machine</em>, standard</em>, pro</em>, and
ultra</em>. These dictate the type of translation you'll get back. Machine
translations are the fastest and free, but least accurate</em>; the latter
three are all tiers of human translation, and their rates vary
accordingly (see the website for current rates).</p>
For the example below, we're going to just use machine translation,
since it's an effective 1:1 replacement for Google's APIs. A great
feature of the myGengo API is that you can upgrade to a human
translation whenever you want</em>; while you're waiting for a human to
translate your job, myGengo still returns the machine translation for
any possible intermediary needs.</p>

Note: It's your responsibility to determine what level you need - if you're
translating something to be published in another country, for instance,
human translation will inevitably work better since a native translator
understands the cultural aspects that a machine won't.
</blockquote>
</span># -*- coding: utf-8 -*-
</span></span>from </span>mygengo </span>import </span>MyGengo
</span></span>
</span></span>gengo </span>= </span>MyGengo</span>(
</span></span>    </span>public_key </span>= </span>'your_mygengo_api_key'</span>,
</span></span>    </span>private_key </span>= </span>'your_mygengo_private_key'</span>,
</span></span>    </span>sandbox </span>= </span>False</span>, </span># possibly False, depending on your dev needs
</span></span>)
</span></span>
</span></span>translation </span>= </span>gengo</span>.</span>postTranslationJob</span>(</span>job </span>= </span>{
</span></span>    </span>'type'</span>: </span>'text'</span>, </span># REQUIRED. Type to translate, you'll probably always put 'text' here (for now ;)
</span></span>    </span>'slug'</span>: </span>'Translating English to Japanese with the myGengo API'</span>, </span># REQUIRED. For storing on the myGengo side
</span></span>    </span>'body_src'</span>: </span>'I love this music!'</span>, </span># REQUIRED. The text you're translating. ;P
</span></span>    </span>'lc_src'</span>: </span>'en'</span>, </span># REQUIRED. source_language_code (see getServiceLanguages() for a list of codes)  
</span></span>    </span>'lc_tgt'</span>: </span>'ja'</span>, </span># REQUIRED. target_language_code (see getServiceLanguages() for a list of codes)
</span></span>    </span>'tier'</span>: </span>'machine'</span>, </span># REQUIRED. tier type ("machine", "standard", "pro", or "ultra")
</span></span>})
</span></span>
</span></span># This will print out 私はこの音楽が大好き！
</span></span>print </span>translation[</span>'response'</span>][</span>'job'</span>][</span>'body_tgt'</span>]
</span></span></code></pre>
This really couldn't be more straight-forward. We've just requested our
text be translated from English to Japanese by a machine, and gotten our
results instantly. This is only the tip of the iceberg, too - if you
have multiple things you need translated, you can actually bundle them
all up and post them all at once (see this
example</a>
in the mygengo-python repository).</p>
Taking it One Step Further!</h2>
Remember the "human translation is more accurate" point I noted above?
Well, it hasn't changed in the last paragraph or two, so let's see how
we could integrate this into a web application. The problem with human
translation has historically been the human factor itself; it's slower
because it has to pass through a person or two. myGengo has gone a long
way in alleviating this pain point, and their API is no exception: you
can register a callback url to have a job POSTed back to when it's been
completed by a human translator.</p>
This adds another field or two to the translation API call above, but
it's overall nothing too new:</p>
</span># -*- coding: utf-8 -*-
</span></span>from </span>mygengo </span>import </span>MyGengo
</span></span>
</span></span>gengo </span>= </span>MyGengo</span>(
</span></span>    </span>public_key </span>= </span>''</span>,
</span></span>    </span>private_key </span>= </span>''</span>,
</span></span>    </span>sandbox </span>= </span>False</span>, </span># possibly False, depending on your dev needs
</span></span>)
</span></span>
</span></span>translation </span>= </span>gengo</span>.</span>postTranslationJob</span>(</span>job </span>= </span>{
</span></span>    </span>'type'</span>: </span>'text'</span>, </span># REQUIRED. Type to translate, you'll probably always put 'text' here (for now ;)
</span></span>    </span>'slug'</span>: </span>'Translating English to Japanese with Python and myGengo API'</span>, </span># REQUIRED. Slug for internally storing, can be generic.
</span></span>    </span>'body_src'</span>: </span>'I love this music!'</span>, </span># REQUIRED. The text you're translating. ;P
</span></span>    </span>'lc_src'</span>: </span>'en'</span>, </span># REQUIRED. source_language_code (see getServiceLanguages() for a list of codes)  
</span></span>    </span>'lc_tgt'</span>: </span>'ja'</span>, </span># REQUIRED. target_language_code (see getServiceLanguages() for a list of codes)
</span></span>    </span>'tier'</span>: </span>'standard'</span>, </span># REQUIRED. tier type ("machine", "standard", "pro", or "ultra")
</span></span>    </span># New pieces...
</span></span>    </span>'auto_approve'</span>: </span>0</span>,
</span></span>    </span>'comment'</span>: </span>'This is an optional comment for a translator to see!'</span>,
</span></span>    </span>'callback_url'</span>: </span>'http://yoursite.com/your/callback/view'
</span></span>})
</span></span>
</span></span># This will print out a machine translation (私はこの音楽が大好き！), and you can 
</span></span># set up a callback URL (see below) to get the translated text back when it's been
</span></span># completed by a human. You can alternatively poll in intervals to check.
</span></span>print </span>translation[</span>'response'</span>][</span>'job'</span>][</span>'body_tgt'</span>]
</span></span>
</span></span># Credit for the note about machine translation goes to https://github.com/aehlke, who
</span></span># pointed out where I forgot to note. ;)
</span></span></code></pre>
All we've done here is change the level we want, to use a human
(standard level), and supplied a callback url to post the job to once
it's completed. As you can see, the response from our submission
includes a free machine translation to use in the interim, so you're not
left completely high and dry. You can also specify a comment for the
translator (e.g, if there's some context that should be taken into
account).</p>
Now we need a view to handle the job being sent back to us when it's
completed. Being a python-focused article, we'll use Django as our
framework of choice below, but this should be fairly portable to any
framework in general. I leave the routing up to the reader, as it's
largely basic Django knowledge anyway:</p>
</span>def </span>update_job</span>(</span>request</span>):
</span></span>    </span>"""Handles parsing and storing a POSTed completed job from myGengo.
</span></span>    </span>"""
</span></span>    </span>if </span>request</span>.</span>method </span>== </span>"POST"</span>:
</span></span>        </span># Load the POSTed object, it's JSON data.
</span></span>        </span>resp </span>= </span>json</span>.</span>loads</span>(resp)
</span></span>        </span>
</span></span>        </span># Your translated text is now available in resp['body_tgt']
</span></span>        </span># Save it, process it, whatever! ;D
</span></span>        </span>
</span></span>        </span>return </span>HttpResponse</span>(</span>200</span>)
</span></span>    </span>else</span>:
</span></span>        </span>return </span>HttpResponse</span>(</span>400</span>)
</span></span></code></pre>
Now, wasn't that easy? Human translations with myGengo are pretty fast,
and you get the machine translation for free - it makes for a very
bulletproof approach if you decide to use it.</p>
Room for Improvement?</h2>
mygengo-python</a> is open
source and fork-able over on GitHub. I'm the chief maintainer, and love
seeing pull requests and ideas for new features. If you think something
could be made better (or is lacking completely), don't hesitate to get
in touch!</p>


More Power to ExpressionEngine URLs
Sat, 07 May 2011 00:00:00 +0000

    Please Excuse the Tone. :(</h4>
    I wrote this when I was younger and, arguably, an asshole (pardon my French). There may still be technical content of note in here, so I'm keeping it up, but please ignore the harsh and unnecessary tone.</p>
</div>
When playing "contract engineer", you sometimes have to jump in and work
with a less than ideal codebase. This was the case on a recent project I
helped out on; the codebase is an install of ExpressionEngine 2
(EE2)</a>, a publishing system (CMS)
developed by the fine people at EllisLab</a>,
favored by web designers all over the place. While I personally find it
too limiting for my tastes (I suspect this is due to my doing less
design based work these days), I can understand why people choose to
work with it - highly sensible defaults with a pleasing overall control
panel design that you can sell to customers. We can all agree that not
reinventing the wheel is a good thing.</p>
That said, I would be lying if I didn't note that there are a few things
about EE2 that bug me. I'll write about them each in-depth in their own
articles; the focus of this one is on the somewhat limiting URL
structure that EE2 enforces on you, as well as how to get around this
and obtain a much higher degree of flexibility while still re-using your
same EE2 essentials (templates, session handling, etc).</p>
The Scenario to Fix</h2>
The way that EE2 handles URL
routing</a> is
pretty simple, and works for a large majority of use cases. The short
and sweet of it is this:</p>
http://example.com/index.php/\ template_group</strong>/template</strong>/</p>
That url will render a template named "template" that resides inside
"template_group", taking care of appropriate contextual data and such.
Let's imagine, though, that for SEO-related purposes you want a little
more dynamism in that url - the template_group</code> should act as more of
a controller, where it can be re-used based on a given data set. What to
do about this...</p>
Wait! EE2 is CodeIgniter!</h2>
This is where things get interesting. EE2 is actually built on top of
CodeIgniter</a>, an open source PHP framework
maintained by EllisLab</a>. It's similar to Ruby
on Rails in many regards.</p>
That said, if you're new to web development and reading this, please go
learn to use a real framework</a>.
Learning PHP (and associated frameworks) first will only set you up for
hardships later.</p>
Now, since we have a framework, we have to ask ourselves... why doesn't
EE2's setup look like a CodeIgniter setup? Well, EE2 swaps some
functionality into the CI build it runs on, so things are a bit
different. This is done (presumably) to maintain some level of backwards
compatibility with older ExpressionEngine installations.</p>
Exposing the Underlying Components</h2>
The first thing we need to address is the fact that the CodeIgniter
router functions are being overridden. If you open up the main index.php
file used by EE2 and go to line 94-ish, you'll find something like the
following:</p>
</span><?php
</span></span>
</span></span>// ...
</span></span>
</span></span>/*
</span></span> </span>* ---------------------------------------------------------------
</span></span> </span>*  Disable all routing, send everything to the frontend
</span></span> </span>* ---------------------------------------------------------------
</span></span> </span>*/
</span></span>$routing</span>[</span>'directory'</span>] </span>= </span>''</span>;
</span></span>$routing</span>[</span>'controller'</span>] </span>= </span>'ee'</span>;
</span></span>$routing</span>[</span>'function'</span>] </span>= </span>'index'</span>;
</span></span>
</span></span>// ...
</span></span></code></pre>
You're gonna want to just comment those lines out. What's basically
going on there is that this is saying "hey, let's just have every
request go through this controller and function", but we really don't
want this. By commenting these out, the full routing capabilities of
CodeIgniter return to us.</p>
One thing to note here is that if our desired route isn't found,
ExpressionEngine will still continue to work absolutely fine</strong>. This
is due to a line in the config/routes.php file:</p>
</span><?php
</span></span>
</span></span>// ...
</span></span>$route</span>[</span>'default_controller'</span>] </span>= </span>"ee/index"</span>;
</span></span>$route</span>[</span>'404_override'</span>] </span>= </span>"ee/index"</span>;
</span></span>
</span></span>// An example of a route we'll watch for
</span></span>$route</span>[</span>'example/(:any)'</span>] </span>= </span>"example_controller/test/$1"</span>;
</span></span>
</span></span>// ...
</span></span></code></pre>
The default controller, if no route is found matching the one we've
specified, is the EE controller, so nothing will break.</p>
Controllers and Re-using Assets</h2>
So now that we've got a sane controller-based setup rolling, there's one
more problem to tackle: layouts and/or views. Presumably all your view
code is built to use the EE2 templating engine; it'd be insane to have
to keep a separate set of view files around that are non-EE2 compatible,
so let's see if we can't re-use this stuff.</p>
A basic controller example is below:</p>
</span><?php
</span></span>
</span></span>if</span>(</span>!</span>defined</span>(</span>'BASEPATH'</span>)) </span>exit</span>(</span>'This cannot be hit directly.'</span>);
</span></span>
</span></span>class </span>Example_controller </span>extends </span>Controller </span>{
</span></span>    </span>function </span>__construct</span>() </span>{
</span></span>        </span>parent</span>::</span>Controller</span>();
</span></span>        </span>
</span></span>        </span>/* Need to initialize the EE2 core for this stuff to work! */
</span></span>        </span>$this</span>-></span>core</span>-></span>_initialize_core</span>();
</span></span>        </span>$this</span>-></span>EE </span>= </span>$this</span>-></span>core</span>-></span>EE</span>;
</span></span>        </span>
</span></span>        </span>/* This is required to initialize template rendering */
</span></span>        </span>require </span>APPPATH</span>.</span>'libraries/Template'</span>.</span>EXT</span>;
</span></span>    </span>}
</span></span>    </span>
</span></span>    </span>function </span>test</span>(</span>$ext</span>) </span>{
</span></span>        </span>echo </span>$ext</span>;
</span></span>    </span>}
</span></span>}
</span></span>
</span></span>/* End of file */
</span></span></code></pre>
Now, viewing "/example/12345" in your browser should bring up a page
that simply prints "12345". The noteworthy pieces of this happen inside
the construct method; there's a few pieces that we need to establish in
there so we have a reference to the EE2 components.</p>
Now, to use our template structures once more, we need to add in a
little magic...</p>
</span><?php
</span></span>    </span>
</span></span>    </span>// ...
</span></span>    </span>
</span></span>    </span>private </span>function </span>_render</span>(</span>$template_group</span>, </span>$template</span>, </span>$opts </span>= </span>array</span>()) </span>{
</span></span>        </span>/* Create a new EE Template Instance */
</span></span>        </span>$this</span>-></span>EE</span>-></span>TMPL </span>= new </span>EE_Template</span>();
</span></span>        </span>
</span></span>        </span>/* Run through the initial parsing phase, set output type */
</span></span>        </span>$this</span>-></span>EE</span>-></span>TMPL</span>-></span>fetch_and_parse</span>(</span>$template_group</span>, </span>$template</span>, </span>FALSE</span>);
</span></span>        </span>$this</span>-></span>EE</span>-></span>output</span>-></span>out_type </span>= </span>$this</span>-></span>EE</span>-></span>TMPL</span>-></span>template_type</span>;
</span></span>        </span>
</span></span>        </span>/* Return source. If we were given opts to do template replacement, parse them in */
</span></span>        </span>if</span>(</span>count</span>(</span>$opts</span>) </span>> </span>0</span>) </span>{
</span></span>            </span>$this</span>-></span>EE</span>-></span>output</span>-></span>set_output</span>(
</span></span>                </span>$this</span>-></span>EE</span>-></span>TMPL</span>-></span>parse_variables</span>(
</span></span>                    </span>$this</span>-></span>EE</span>-></span>TMPL</span>-></span>final_template</span>, </span>array</span>(</span>$opts</span>)
</span></span>                </span>)
</span></span>            </span>);
</span></span>        </span>} </span>else </span>{
</span></span>            </span>$this</span>-></span>EE</span>-></span>output</span>-></span>set_output</span>(</span>$this</span>-></span>EE</span>-></span>TMPL</span>-></span>final_template</span>);
</span></span>        </span>}
</span></span>    </span>}
</span></span>    </span>
</span></span>    </span>// ...
</span></span></code></pre>
This render method should be added to the controller example above; it
accepts three parameters - a template group, a template name, and an
optional multi-dimensional array to use as a context for template
rendering (i.e, your own tags). If the last argument confuses you, it's
probably best to read the EE2 third_party documentation on parsing
variables</a>,
as it's actually just using that API. There's really less black magic
here than it looks like.</p>
With that done, our final controller looks something like this...</p>
</span><?php
</span></span>    </span>if</span>(</span>!</span>defined</span>(</span>'BASEPATH'</span>)) </span>exit</span>(</span>'This cannot be hit directly.'</span>);
</span></span>
</span></span>    </span>class </span>Example_controller </span>extends </span>Controller </span>{
</span></span>        </span>function </span>__construct</span>() </span>{
</span></span>            </span>parent</span>::</span>Controller</span>();
</span></span>        </span>
</span></span>            </span>/* Need to initialize the EE2 core for this stuff to work! */
</span></span>            </span>$this</span>-></span>core</span>-></span>_initialize_core</span>();
</span></span>            </span>$this</span>-></span>EE </span>= </span>$this</span>-></span>core</span>-></span>EE</span>;
</span></span>            </span>
</span></span>            </span>/* This is required to initialize template rendering */
</span></span>            </span>require </span>APPPATH</span>.</span>'libraries/Template'</span>.</span>EXT</span>;
</span></span>        </span>}
</span></span>
</span></span>        </span>private </span>function </span>_render</span>(</span>$template_group</span>, </span>$template</span>, </span>$opts </span>= </span>array</span>()) </span>{
</span></span>            </span>/* Create a new EE Template Instance */
</span></span>            </span>$this</span>-></span>EE</span>-></span>TMPL </span>= new </span>EE_Template</span>();
</span></span>            </span>
</span></span>            </span>/* Run through the initial parsing phase, set output type */
</span></span>            </span>$this</span>-></span>EE</span>-></span>TMPL</span>-></span>fetch_and_parse</span>(</span>$template_group</span>, </span>$template</span>, </span>FALSE</span>);
</span></span>            </span>$this</span>-></span>EE</span>-></span>output</span>-></span>out_type </span>= </span>$this</span>-></span>EE</span>-></span>TMPL</span>-></span>template_type</span>;
</span></span>            </span>
</span></span>            </span>/* Return source. If we were given opts to do template replacement, parse them in */
</span></span>            </span>if</span>(</span>count</span>(</span>$opts</span>) </span>> </span>0</span>) </span>{
</span></span>                </span>$this</span>-></span>EE</span>-></span>output</span>-></span>set_output</span>(
</span></span>                    </span>$this</span>-></span>EE</span>-></span>TMPL</span>-></span>parse_variables</span>(
</span></span>                        </span>$this</span>-></span>EE</span>-></span>TMPL</span>-></span>final_template</span>, </span>array</span>(</span>$opts</span>)
</span></span>                    </span>)
</span></span>                </span>);
</span></span>            </span>} </span>else </span>{
</span></span>                </span>$this</span>-></span>EE</span>-></span>output</span>-></span>set_output</span>(</span>$this</span>-></span>EE</span>-></span>TMPL</span>-></span>final_template</span>);
</span></span>            </span>}
</span></span>        </span>}
</span></span>
</span></span>        </span>function </span>test</span>(</span>$ext</span>) </span>{
</span></span>            </span>return </span>$this</span>-></span>_render</span>(</span>'my_template_group'</span>, </span>'my_template'</span>, </span>array</span>(
</span></span>                </span>'template_variable_one' </span>=> </span>'SuperBus'</span>,
</span></span>                </span>'repeatable_stuff' </span>=> </span>array</span>(
</span></span>                    </span>array</span>(</span>'id' </span>=> </span>1</span>, </span>'text' </span>=> </span>'This'</span>),
</span></span>                    </span>array</span>(</span>'id' </span>=> </span>2</span>, </span>'text' </span>=> </span>'Will'</span>),
</span></span>                    </span>array</span>(</span>'id' </span>=> </span>3</span>, </span>'text' </span>=> </span>'Be'</span>),
</span></span>                    </span>array</span>(</span>'id' </span>=> </span>4</span>, </span>'text' </span>=> </span>'Repeatable'</span>),
</span></span>                </span>)
</span></span>            </span>));
</span></span>        </span>}
</span></span>    </span>}
</span></span>
</span></span>    </span>/* End of file */
</span></span></code></pre>Awesome! Now what?</h2>
Please go use a more reasonable programming
language</a> that enforces better practices.
While you're at it, check out one of the best web frameworks
around</a>, conveniently written in said
reasonable programming language.</p>
Of course, if you're stuck using PHP, then make the most of it I
suppose. If this article was useful to you, I'd love to hear so!</p>


Emitting Custom Events in Node.js
Sat, 16 Apr 2011 00:00:00 +0000

    Note the Following!</h4>
    This is an article I wrote for the March 2011th issue of (the now defunct)
    JSMag</a>. It was a great piece of literature
released monthly, and a great way to keep up to date on the latest news
in the Javascript community. Sad to see it go!
    </p>
</div>
Node isn’t the first approach to event based programming, and with its
explosion of interest it probably won’t be the last. Typical JavaScript
patterns for callback functions involve passing around references to
functions and managing odd scope levels. In many cases this is less than
ideal; that said, there’s another option when you’re in Node: emit your
own events, and let functions attach and respond to those. EventEmitter
makes this incredibly easy!</p>
The Typical Approach...</h2>
If you’ve written or even worked with JavaScript libraries before, you
probably understand the callback function scenario – that is, functions
that execute once a certain task is completed. A typical use might be
something like what you see in the following example:</p>
</span>var </span>x </span>= </span>1</span>;
</span></span>var </span>foo </span>= </span>function</span>(</span>callbackfn</span>) </span>{
</span></span>    </span>return </span>callbackfn</span>(</span>x </span>* </span>2</span>);
</span></span>}</span>;
</span></span>
</span></span>foo</span>(</span>function</span>(</span>x</span>) </span>{
</span></span>    </span>console</span>.</span>log</span>(</span>x</span>);
</span></span>}</span>);
</span></span></code></pre>
Here, we’ve defined a function that accepts another function as its main
argument and passes the callback function a doubled version of x</code>. Pretty
simple, and many libraries use this technique for Ajax calls. Let’s take
a minute and spin the globe, though – what if, instead of arbitrarily
accepting a function and having to worry about possible scoping issues,
we could just announce when an event of interest has occurred, and fire
an attached function at that point? This would be so much cleaner than
passing around function references everywhere.</p>
Enter: events.EventEmitter</h2>
The great thing about all this? We can actually do this in Node through
use of the events library. This, in many ways, is core to how things in
Node work. Everything is event based, so why shouldn’t we be able to
fire off our own events? To showcase what’s possible with this, let’s
build a basic library to connect to Twitter's Streaming API, which we
can then filter results from as we see fit.</p>
The Basics: exporting an EventEmitter instance</h2>
Before we get into anything Twitter-specific, we’ll demonstrate basic
usage of EventEmitter</code>. The code below shows how simple this can really
be – it’s a contrived example that constantly increases numbers by one,
and emits an event called “even” every time the number becomes even.</p>
</span>var </span>events </span>= </span>require</span>(</span>'events'</span>),
</span></span>    </span>util </span>= </span>require</span>(</span>'util'</span>);
</span></span>
</span></span>var </span>Foo </span>= </span>function</span>(</span>initial_no</span>) </span>{ </span>this</span>.</span>count </span>= </span>initial_no</span>; </span>}</span>;
</span></span>
</span></span>Foo</span>.</span>prototype </span>= new </span>events</span>.</span>EventEmitter;
</span></span>
</span></span>Foo</span>.</span>prototype</span>.</span>increment </span>= </span>function</span>() </span>{
</span></span>    </span>var </span>self </span>= </span>this</span>;
</span></span>    </span>setInterval</span>(</span>function</span>() </span>{
</span></span>        </span>if</span>(</span>self</span>.</span>count </span>% </span>2 </span>=== </span>0</span>) </span>self</span>.</span>emit</span>(</span>'even'</span>);
</span></span>        </span>self</span>.</span>count</span>++</span>;
</span></span>    </span>}</span>, </span>300</span>);
</span></span>}</span>;
</span></span>
</span></span>var </span>lol </span>= new </span>Foo(</span>1</span>);
</span></span>
</span></span>lol</span>.</span>on</span>(</span>'even'</span>, </span>function</span>() </span>{ 
</span></span>    </span>util</span>.</span>puts</span>(</span>'Number is even! :: ' </span>+ </span>this</span>.</span>count);
</span></span>}</span>)</span>.</span>increment</span>();
</span></span></code></pre>
Usage of EventEmitter</code> is pretty simple – you basically want to inherit
all the properties from EventEmitter</code> itself into your object, giving it
all the properties it needs to emit events on its own. Events are sent
off as keywords (‘even</code>’, ‘error</code>’, etc), called directly on the object.
You can extend the prototype chain further, and EventEmitter</code> should work
fine and dandy.</p>
Changing Tracks for a Moment...</h2>
Now that we’ve shown how EventEmitter</code> works, we want to go ahead and use
it for Twitter's Streaming API. For the unfamiliar, the Streaming API is
essentially a never ending flood of tweets. You open a connection, and
you keep it open; data is pushed to you, reversing the typical model of
“request/response” a bit in that you only really make one request.
EventEmitter</code> is perfect for this task, but to satisfy some basic needs
for interacting with Twitter's API, we’ll need a base library, like
what’s shown in the example below:</p>
</span>var </span>util </span>= </span>require</span>(</span>'util'</span>),
</span></span>    </span>http </span>= </span>require</span>(</span>'http'</span>),
</span></span>    </span>events </span>= </span>require</span>(</span>'events'</span>);
</span></span>
</span></span>var </span>TwitterStream </span>= </span>function</span>(</span>opts</span>) </span>{
</span></span>    </span>this</span>.</span>username </span>= </span>opts</span>.</span>username;
</span></span>    </span>this</span>.</span>password </span>= </span>opts</span>.</span>password;
</span></span>    </span>this</span>.</span>track </span>= </span>opts</span>.</span>track;
</span></span>    </span>this</span>.</span>data </span>= </span>''</span>;
</span></span>}</span>;
</span></span>
</span></span>TwitterStream</span>.</span>prototype </span>= new </span>events</span>.</span>EventEmitter;
</span></span>module</span>.</span>exports </span>= </span>TwitterStream</span>;
</span></span></code></pre>
Here we require the three main resources we’ll need (util</code>, http</code> and
events</code>), and set up a new Function Object that’s essentially an instance of
EventEmitter</code>. We’ll throw it over to exports</code>, too, so it plays nicely
when relying on it in outside code. Creating instances of our Twitter
object requires a few things – ‘track</code>’, which is a keyword to filter
tweets by, and a ‘username</code>’/’password</code>’ combination which should be self
explanatory (in terms of what they are).</p>
Why ‘username</code>/password</code>’, though? Twitter's Streaming API requires some
form of authentication; for the sake of brevity in this article, we’re
going to rely on Basic Authentication, but moving forward it’s
recommended that you use OAuth for authenticating with Twitter, as it
relies on the user granting you privileges instead of actually handing
over their password. The OAuth ritual is much longer and more intricate
to pull off, though, and would push the length and scope of this article
far beyond its intentions.</p>
Emitting a "Tweet" Event</h2>
Now that we’ve got the basic scaffolding for our library set up, let’s
throw in a function to actually connect, receive tweets, and emit an
event or two that other code can catch. Check out the following for a
prime example of how we can do this:</p>
</span>TwitterStream</span>.</span>prototype</span>.</span>getTweets </span>= </span>function</span>() </span>{
</span></span>    </span>var </span>opts </span>= </span>{
</span></span>        </span>host: </span>'stream.twitter.com'</span>,
</span></span>        </span>port: </span>80</span>,
</span></span>        </span>path: </span>'/1/statuses/filter.json?track=' </span>+ </span>this</span>.</span>track,
</span></span>        </span>method: </span>'POST'</span>,
</span></span>        </span>headers: </span>{
</span></span>            </span>'Connection'</span>: </span>'keep-alive'</span>,
</span></span>            </span>'Accept'</span>: </span>'*/*'</span>,
</span></span>            </span>'User-Agent'</span>: </span>'Example Twitter Streaming Client'</span>,
</span></span>            </span>'Authorization'</span>: </span>'Basic ' </span>+ new </span>Buffer</span>(</span>this</span>.</span>username </span>+ </span>':' </span>+ </span>this</span>.</span>password)</span>.</span>toString</span>(</span>'base64'</span>),
</span></span>        </span>}
</span></span>    </span>}</span>,
</span></span>    </span>self </span>= </span>this</span>;
</span></span>
</span></span>    </span>this</span>.</span>connection </span>= </span>http</span>.</span>request</span>(</span>opts</span>, </span>function</span>(</span>response</span>) </span>{
</span></span>        </span>response</span>.</span>setEncoding</span>(</span>'utf8'</span>);
</span></span>        </span>response</span>.</span>on</span>(</span>'data'</span>, </span>function</span>(</span>chunk</span>) </span>{
</span></span>            </span>self</span>.</span>data </span>+= </span>chunk</span>.</span>toString</span>(</span>'utf8'</span>);
</span></span>            </span>var </span>index</span>, </span>json</span>;
</span></span>            </span>while</span>((</span>index </span>= </span>self</span>.</span>data</span>.</span>indexOf</span>(</span>'</span>\r\n</span>'</span>)) </span>> </span>-1</span>) </span>{
</span></span>                </span>json </span>= </span>self</span>.</span>data</span>.</span>slice</span>(</span>0</span>, </span>index</span>);
</span></span>                </span>self</span>.</span>data </span>= </span>self</span>.</span>data</span>.</span>slice</span>(</span>index </span>+ </span>2</span>);
</span></span>                </span>if</span>(</span>json</span>.</span>length </span>> </span>0</span>) </span>{
</span></span>                    </span>try </span>{
</span></span>                        </span>self</span>.</span>emit</span>(</span>'tweet'</span>, </span>JSON</span>.</span>parse</span>(</span>json</span>));
</span></span>                    </span>} </span>catch</span>(</span>e</span>) </span>{
</span></span>                        </span>self</span>.</span>emit</span>(</span>'error'</span>, </span>e</span>);
</span></span>                    </span>}
</span></span>                </span>}
</span></span>            </span>}
</span></span>        </span>}</span>);
</span></span>    </span>}</span>);
</span></span>
</span></span>    </span>this</span>.</span>connection</span>.</span>write</span>(</span>'?track=' </span>+ </span>this</span>.</span>track);
</span></span>    </span>this</span>.</span>connection</span>.</span>end</span>();
</span></span>}</span>;
</span></span></code></pre>
If you’ve worked with Node before, this code shouldn’t be too daunting,
but we’ll summarize it just in case. We’re extending the prototype of
our Twitter object that we created before, and adding a method to start
the stream of tweets coming in. We set up an object detailing the host</code>,
port</code>, path</code> and method</code>, as well as some custom headers (notably, setting
‘keep-alive</code>’ and Basic Authentication</code> headers). This is passed to an
http.request()</code> call, and we then write our tracking data and end the
connection.</p>
The response function has some logic to handle putting together tweets
that are sent in by Twitter. The API dictates that a tweet object will
end on the two characters ‘\\r</code>’ and ‘\\n</code>’, so we basically walk the
built up JSON strings as they come in and separate them out. If a JSON
string is successfully pulled out, we emit a ‘tweet’ event, and pass it
the parsed JSON data. If something went horribly wrong, we emit an
‘error</code>’ event and pass it the associated object.</p>
Usage and Application</h2>
Alright, so now we should have a pretty functional library once we put
those two together. The code below shows how we can now use this library
in a simple script.</p>
</span>var </span>TwitterStream </span>= </span>require</span>(</span>'./twitterstream'</span>),
</span></span>    </span>util </span>= </span>require</span>(</span>'util'</span>);
</span></span>
</span></span>var </span>twitter </span>= new </span>TwitterStream(</span>{
</span></span>    </span>username: </span>'username'</span>,
</span></span>    </span>password: </span>'password'</span>,
</span></span>    </span>track: </span>'JavaScript'</span>,
</span></span>}</span>);
</span></span>
</span></span>twitter</span>.</span>on</span>(</span>'tweet'</span>, </span>function</span>(</span>tweet</span>) </span>{
</span></span>    </span>util</span>.</span>puts</span>(util</span>.</span>inspect</span>(</span>tweet</span>));
</span></span>}</span>);
</span></span>
</span></span>twitter</span>.</span>on</span>(</span>'error'</span>, </span>function</span>(</span>e</span>) </span>{ 
</span></span>    </span>util</span>.</span>puts</span>(</span>e</span>); 
</span></span>}</span>);
</span></span>
</span></span>twitter</span>.</span>getTweets</span>();
</span></span></code></pre>Wrapping Things Up</h2>
EventEmitter</code> is an excellent, easy to implement option for dealing with
cases where you might want to defer an action until data is ready.
Readers with further questions should check out the Node.js
documentation on EventEmitter</code>.</p>


Hacking the Human Brain
Sun, 06 Mar 2011 00:00:00 +0000
Back in 2008 I was frequently riding a train twice a day for a
ridiculous ~3 hour (each way) commute that nobody on this planet should
ever have to do. Needless to say, I did a lot of reading, particularly
issues of Wired Magazine. To this day, one article still stands fresh in
my mind, which essentially dealt with the concept of surrendering
your brain to an algorithmic approach to
memorization</a>.
The man behind the core of the theory is Piotr Wozniak, a gentleman out
of Poland who still somewhat astounds me to this day.</p>
I won't reproduce the theory in full here, as the Wired article does a
much better job writing things up, but the core things to take down are
that the human brain tends to have times when it memorizes better or
worse, and it's possible to capitalize on these moments to increase your
potential for solidly committing something to memory.
SuperMemo</a> is an effort to implement this
in software. It's cool and all, but I'm not sure I'm in 100% total
agreement.</p>
Hack Faster, Please.</h2>
You see the thing about the theory is that your core memory might work
on a two week cycle; learn something today, see it again in two weeks,
and if everything holds true you'll probably never forget it. However, I
disagree with the concept that short term memory commitment can't be
stronger for certain concepts.</p>
Take something like teaching yourself a new language. If it's something
truly foreign to you, the characters won't make sense, the
pronunciations will sound totally off, and there's a good chance that
anyone who's not forced through it will give up in about a week or two.
Long term memory won't have a shot in that case; maybe not due to any
particular flaw in the theory, but merely due to the lack of willpower
some people have. In addition you have to factor in the concept of age:
as we get older, our memory and the way it works through concepts
changes. Short term memory is nowhere near as slighted when up against
these two conceptual foes; are we certain there's no good middle ground
to hit?</p>
Can It Be Proven?</h2>
So let's provide a short bit of backstory here. This past week
(beginning of March, 2011), I got the awesome opportunity to work with
the folks at myGengo</a>, a company that builds
tools to help ease translation efforts. This required heading to Tokyo -
for the astute, I had visited Tokyo</a>
some months prior, so I wasn't a total stranger to what I'd experience
upon arrival. I do want to learn the language, though.</p>
A typical approach for character memorization would be to make flash
cards, sit down and repeatedly run through them. I won't lie, this
bores the hell out of me</em>. I'd much rather have something portable that
I can use on the train when I'm traveling in the mornings. To that end,
I just went ahead and built an Android application (app) to do this.</p>
Katakana on the Android
Market</a></p>
Now, since I was already creating an app for this, I figured I could
take some liberties. With the theory still lingering in the back of my
head, I began to muse: what's my own learning pattern like? Well, for
the past (roughly) seven years I've learned things incredibly quickly.
In some cases this was by design, in other cases... well, you get the
idea.</p>
The thing is that it's worked for me so far, and it's the same for many
other programmers I know. Programmers far and wide can attest to the
fact that while there's no doubt benefits to the long-term memorization
benefits, we consistently rely on short term to do our jobs. We accrue a
sometimes ridiculous amount of information in a short period of time
that will instantly come back to us when we need it. The key is, of
course, when we need it</em>, generally through a trigger (a linked piece
of information, for example).</p>
The Theory Itself</h2>
So this theory started formulating in my mind. What if I could apply
elements of Wozniaks theory to short term memory, and then rely on the
trigger to pick up the rest? Even in short term memory I found that I,
personally, had a few-minutes window where if I reviewed the same
concept, I'd commit it pretty quickly. The triggers, in this case, will
be as I walk down the streets of Tokyo or read a menu.</p>
I got down to building the app. The core details of building an Android
app are outside the scope of this article; the algorithm I threw in is
worth detailing a bit, though. In my mind, when you use an app on your
phone, you're going to use it, at most, for five minutes. The app
concept just lends itself to this, a bunch of miniature worlds that you
can hop in and out of at will. So with that in mind, I set the high
barrier for this experiment at five minutes - roughly the maximum amount
of time I expect someone to stay engaged.</p>
I'm assuming, based on my own use cases and the trials of a few friends,
that on average I can expect people to get through roughly three cards
in a minute. At five minutes, fifteen cards, not too bad. The question
of where to 're-appear' content then came up - for this, I first settled
on throwing it back in the users face every couple of minutes. The
number of minutes is variable; it starts off set at one minute, but will
adapt based on whether or not you answer correctly as things re-appear.
If you memorize things at the four minute mark, for instance, it'll edge
towards that - never 100% four minutes due to the relative inaccuracy of
Android's timing, mind you, but it gets the job done.</p>
I've been using the application myself for roughly two days now, and
it's easily topped any effort I put in with books or traditional methods
over the past two months. It's worth noting that I still can't write
Japanese to save my life, but that's also a two fold issue: characters
can be quite complex (kanji), and don't lend themselves well to a
trigger-based scenario for recall. However, if I'm looking at a
character screen, I can at least make some sense of what I'm seeing now.</p>
Taking This Further</h2>
My theories aren't proven, but then again, it's the human brain we're
dealing with. I released the Android app as a test of my take on
Wozniak's theory with a bit of my own magic; based on how well it does,
I'll release apps for Hiragana, Kanji, and anything else applicable. I
personally believe that the effects of memory commitment through short
term memory optimization can be optimized, and this is a pretty great
and open way to give it a whirl.</p>


The Everlasting Fight To Expand My Metaphorical Sight (Part 2)
Mon, 07 Feb 2011 00:00:00 +0000
Well, time certainly flies by quickly. Since the last entry in this
little mini-series, I've globe-trotted some more (London, New Jersey,
New York City, DC, San Francisco, Seattle... San Francisco again...) and
released some new projects that've been in the pipeline for some time.
What's next?</p>
On Traveling</h2>
London was a very, very interesting experience. I had the fun experience
of being stuck there well past my intended departure date due to a
massive snow storm that shut most of Europe down; London Heathrow, why
you refused the help of the Army to clear away snow is simply beyond me.
That said, the city of London itself is a nice place, one that I could
see myself spending more time in. The surrounding area is equally cool
and worth checking out! Yet again this was a country where public
transportation is pretty slick. Notice a recurring theme here?</p>
The rest of my travels have been pretty US-centric; nothing noteworthy,
sans shooting up to Seattle for a week to visit with my younger brother.
Now, enough of all this personal drivel, there's work to discuss.</p>
ProgProfessor</h2>
I think kids should be taught programming at a young age, but with
absolutely no initial focus on mathematics</strong>. People can fight it all
they want, but math doesn't interest kids, and a direct approach to
trying to make it interesting so more come into the subject field won't
work. Programming, if taught with a creative and artistic edge, is well
suited to fix this problem.</p>
At least, that's my theory, and the entire line of reason behind my
efforts with ProgProfessor</a>. This'll
be followed up soon with a few other new projects, stay tuned!</p>
FeedBackBar</h2>
When I got back into San Francisco, I met up with my good friend
Brandon Leonardo</a>. Awhile back he had conceived
of this pretty cool idea to distribute a "feedback bar" type widget,
where any site could sign up, throw some code on, and get immediate
feedback from users. It's an idea somewhat in the same realm as
UserVoice</a> or Get
Satisfaction</a>, but much more stripped
down and to the point. I thought it was pretty cool, and we managed to
hack it out in a night.</p>
FeedBackBar</a> is free and quick to
implement. Check it out and let us know what you think!</p>
pyGengo - Pythonic myGengo Translation API Library</h2>
The other notable release I've thrown out in the past month is
pyGengo</a>, a library that
wraps the myGengo API</a>.
myGengo is a cool service that offers an easy, reliable way to get text
translated into other languages by other humans</em>. Machine translation
alone can be notoriously incorrect, so having a human back it up is
quite the awesome technique to have up your sleeve.</p>
pyGengo is fully documented and has a test suite to boot. Issues can be
filed on the Github Issue
Tracker</a>, give it a
shot and let me know what you think!</p>
So... What's Next?</h2>
I've got a few projects coming up that should be pretty significant
releases, so at the moment I'm working towards those. You should follow
me on Twitter</a> to know when they're
released!</p>


The Everlasting Fight To Expand My Metaphorical Sight (Part 1)
Sun, 05 Dec 2010 00:00:00 +0000
For the past few weeks, I've had the incredibly fun experience of living
in Tokyo, Japan. I've already fielded quite a few questions as to the
"why" I decided to do this, and in an effort to not re-type the story
another hundred times, I figured I'd throw it down here along with my
experiences thus far. This post is not programming centric; for those of
you who follow the feeds for them, you'll have something soon, no
worries.</p>
The Backstory</h2>
Back in early November, I was at somewhat of a crossroads. I had
recently come to the conclusion that I'm not a huge fan of San
Francisco</a>.
I went ahead and checked out Chicago after that experience, and while
it's an incredible city in its own right (and certainly one of my
favorite US cities), I found myself wanting more. The funny part about
traveling in the US is that for all its regions and supposed
differences, at the end of the day you'll find largely the same things
no matter where you go.</p>
So I figured, alright, let's see what other countries have to offer. I
applied, and (somehow) got my passport within a week. The question then
became "where to?". I could've gone somewhere like England, France,
Germany... the standard "alright, let's backpack for a year and see the
world" destinations that are often suggested.</p>
Thing is, I'm not like that. I enjoy jumping off the deep end; the way I
see it, if I can survive the biggest changes and come out fine, then
anything else in between is a cakewalk. This is largely one of the
reasons I chose Tokyo/Japan; not only is the language incredibly
different than anything I know at the moment*, but it is literally on
the other side of the planet.</p>
(...though some would argue German is on the same level, if not
higher, but I digress...)</em></p>
One of the exciting parts of this journey is the path I've taken. I flew
off the west coast, came to Japan, and will head to England and/or The
Netherlands for about a week after this. From there, I fly back to the
east coast. I will have fully circled the globe by the age of 23, under
my own power</em>. This has been a goal of mine for quite some time now, and
it's really satisfying to see it come about.</p>
Initial Life In Japan</h2>
The minute the plane touched down (after a lovely 12 hour flight) was
interesting, because the culture shock hit me immediately. Not
"uncomfortable, get me out of here" style, but definitely "wow, there is
definitely something different here". I'll state up front that this has
been evident the entire time I've been here, too; back home, I obviously
grew accustomed to a lot of things, and the way they're done here is
almost always radically different in some way. It definitely took some
getting used to, but overall I've enjoyed it so far.</p>
I rented an apartment a little bit outside central Tokyo, in an area
known as Nishimagome. Trains into the central part from there are cheap,
and take about ~15 minutes, so overall it worked out incredibly well.
One part that I found very interesting was the feeling of being a
minority - while I'm sure this comes across as potentially ignorant to
some who'll read this, I've never actually felt that before in my life.
I've lived in areas as a kid where some might say I was, but there was
very little social divide in those scenarios. Being here incurred a
language barrier and a customs barrier (i.e, society here has their own
customs which the US doesn't necessarily follow), which sits on top of
the typical social divides that we as human beings tend to exhibit in
general.</p>
For the first two weeks, almost nobody in Nishimagome wanted to deal
with me. It was very fascinating; some appeared to do it out of a lack
of understanding in regards to my home culture (and believing that I
didn't understand theirs), whereas others seem steeped in what some have
described to me as the "old Japan" ways. It's very evident the way
foreigners are treated differently here; while I had read about it prior
to arrival, I wasn't quite sure what to expect. Getting over that
initial barrier in the area I was staying in required a lot of careful
conversations, as if walking on a field of landmines. At the time of
this writing (about 3 weeks in), this has largely disappeared, but it
definitely took some effort - a very eye opening experience indeed.</p>
Cleanliness Is Godliness</h2>
The streets of this country are incredibly clean</em>. To be completely
blunt, living here for a stint has made me feel like shit as an
American. Tokyo is an insanely huge city, and the amount of trash on the
ground pales</em> in comparison to that of New York City (NYC) or San
Francisco (SF). I believe that a large part of the reasoning behind this
is that you are literally looked down upon if you litter - in America,
we're far too accepting of waste and littering.</p>
The ironic part is that it's nigh impossible to find a trash can half
the time here. Your best bet is to, hey, recycle everything at the bins
you'll find around vending machines and food marts. On top of this,
having this mentality around you the entire time brings a sense of
wanting things to be clean to you. I'll say what a lot of Americans will
deny out of pride: much of the time, in the US, I feel as though it's
perfectly fine to litter because everyone else is doing it</em>. Here, I
can't bring myself to do it; the gravity of the act is taken to such a
higher level here.</p>
Say what you will about peer pressure and such; none of it will matter,
because you'd be arguing the wrong point here. That scenario exists for
many</em> Americans, and trying to solve things through peer pressure
dissolution efforts will go nowhere. Small scale deployments of the
Japanese recycling system in the US could potentially work, provided
people help to enforce and spread the effort around - I believe that
many recycling efforts in the US largely fail because people are given
the alternative</em>. Having one right choice doesn't make you a communist,
people, it just means it's the best fit for the task.</p>
Convenience Is Underrated</h2>
I've spent a decent amount of time in just about every American city,
and I can say with a relative amount of certainty that Tokyo easily
beats them all out when it comes to convenience. As I type this, it's 3
in the morning, and I have no less than 4 different shops open and 20
different vending machines</em> within a one mile radius, all giving me
access to coffee, food, emergency supplies, and whatever else I need.
NYC comes closest in this regard, but Tokyo's ability to provide at all
hours is staggering, and still surpasses anything I've seen in NYC.</p>
Cover Charges At Bars Are Annoying</h2>
Drinking in Tokyo can be quite an expensive task if you're not careful.
Most bars and clubs you'll hit up require a cover charge (anywhere from
$8 - $30, in my experiences), and if you're lucky that includes a free
drink up front. While I don't particularly care about this, it
inadvertently becomes a social barrier when out with a group - some
people aren't always game to pay for two drinks when they're only
getting one. In the US, the ability to just stroll into a bar and have a
drink with a friend is a nice luxury when compared with here.</p>
Public Transportation Rocks, But Should Stay Open Later</h2>
I find public transportation here to be a catch-22 of hilarious
proportions. The ability to get just about anywhere in the entire
country</em> by public transportation is incredible. This has nothing to do
with the overall size of the country, it's simply a situation where
they've paid attention and built the necessary infrastructure</em>. If
trains were open past midnight, I'd call it a perfect situation, but
having to choose to stay in central Tokyo or run to catch a train home
around midnight can be quite the bummer if you're having a blast.</p>
What's Next?</h2>
This is the first entry in a multi-part series, as I couldn't hope to
cover everything I've experienced in the past few weeks in one post. In
another week, I head to Europe for a stint, and then back into the US.
Traveling is an incredible experience, and I'll continue to do this as
long as it benefits me and helps me grow as a person.</p>
Keep an eye out for the next entry in this series!</p>


Emulating Ruby's "method_missing" in Python
Tue, 02 Nov 2010 00:00:00 +0000
I don't pretend to be a huge fan of Ruby. That said, I can respect when
a language has a feature that's pretty damn neat and useful. For the
uninformed, method_missing</code></em> in Ruby is something like the following:</p>
</span># Basic class, no methods, but method_missing love
</span></span>class </span>Rapture
</span></span>    </span>def </span>initialize
</span></span>        </span>@missing_msg </span>= </span>"Oh god, calling method_missing"
</span></span>    </span>end
</span></span>
</span></span>    </span># Called when a non-existent method call on an instance
</span></span>    </span># of this class is made.
</span></span>    </span>def </span>method_missing</span>(</span>method_name</span>, </span>*</span>args</span>, </span>&</span>block</span>)
</span></span>        </span>puts </span>@missing_msg
</span></span>    </span>end
</span></span>end
</span></span>
</span></span>bioshock </span>= </span>Rapture</span>.new
</span></span>bioshock</span>.</span>play
</span></span>
</span></span># play doesn't exist, so this will output
</span></span># "Oh god, calling method_missing"
</span></span></code></pre>
Obviously, this is a trick that should be used with caution. It can make
for some unmaintainable code, as a class with many methods could get
difficult to trace through and figure out just what the hell is
happening. It can be put to good use, though - take an API wrapper, for
instance. What's it consist of? Generally, nothing more than the same
function calls made over and over to various service endpoints.</p>
Cool, let's use this in Python!</h2>
I recently rewrote Twython</a>
to support OAuth authentication with Twitter (as of Twython 1.3). It
ships with an example Django application to get people up and running
quickly, and the adoption has been pretty awesome so far.</p>
The funny thing about the Twython 1.3.0 release is that it was largely a
rewrite of the entire library. It had become somewhat unwieldy, some odd
two thousand lines of code with each API endpoint getting its own method
definition. The only differing aspect of these calls is the endpoint URL
itself. This is a perfect case for a method_missing</code></em> setup - let's
catch the calls to non-existent methods, and grab them out of a
dictionary mapping to every endpoint.</p>
</span>method_dictionary </span>= </span>{
</span></span>    </span>"getPublicTimeline"</span>: {
</span></span>        </span>"endpoint"</span>: </span>"http://..."</span>,
</span></span>    </span>},
</span></span>}
</span></span>
</span></span>class </span>Twython</span>(</span>object</span>):
</span></span>    </span>def </span>__init__</span>(</span>self</span>, </span>params</span>):
</span></span>        </span>"""
</span></span>            </span>Store params and junk. Ordinarily more verbose.
</span></span>        </span>"""
</span></span>        </span>self</span>.</span>params </span>= </span>params
</span></span>    </span>
</span></span>    </span>def </span>__getattr__</span>(</span>self</span>, </span>method_name</span>):
</span></span>        </span>"""
</span></span>            </span>This is called every time a class method or property 
</span></span>            </span>is checked and/or called.
</span></span>            </span>
</span></span>            </span>In here we'll return a new function to handle what we
</span></span>            </span>want to do.
</span></span>        </span>"""
</span></span>        </span>def </span>get</span>(</span>self</span>, </span>**</span>kwargs</span>):
</span></span>            </span># Make our API calls, return data, etc
</span></span>        </span>
</span></span>        </span>if </span>method_name </span>in </span>method_dictionary:
</span></span>            </span>return </span>get</span>.</span>__get__</span>(</span>self</span>)
</span></span>        </span>else</span>:
</span></span>            </span># If the method isn't in our dictionary, act normal.
</span></span>            </span>raise </span>AttributeError</span>, method_name
</span></span>
</span></span># Instantiate...
</span></span>twitter </span>= </span>Twython</span>()
</span></span>
</span></span># Call an arbitrary method.
</span></span>twitter</span>.</span>getPublicTimeline</span>()
</span></span></code></pre>
The source above is fairly well commented, but feel free to ask in the
comments if you need further explanation. This resulted in a much more
maintainable version of Twython - for each function that's listed in a
hash table, we can now just take any named parameter and
url-encode/combine it. This makes Twython pretty API-change agnostic of
the entire Twitter API. Pretty awesome sauce, no?</p>


How to properly ask a girl to Homecoming
Thu, 14 Oct 2010 00:00:00 +0000
Before we get into this, I'll note that this post is actually about
mobile web development, not the romantic adventures of anyone in
particular. You've been forewarned.</em></p>
Sometimes in life, you feel as though doing things the "ordinary" way
just doesn't cut it. I've found this to be a common theme in my work,
and I'm not the only one who operates this way. One example is my
brother (one of them, at least). I recently dropped by my parents house
for a visit as I plan my next trip, and I was catching up with him as we
walked up to a store. We somehow ended up discussing his upcoming
Homecoming dance, and how there's some girl that he wanted to ask, but
in doing so go above and beyond the normal methods.</p>
I sat there and sarcastically threw ideas at him for about 5 minutes, as
I'm prone to do when I'm bored. One of them involved using a spare
iPhone I recently came into possession of to display some message to
her. He decided to take it one step further, and asked me if I could
help him craft a simple game that, upon winning, would ask her to the
dance.</p>
I found myself thinking the idea was pretty awesome. To make that</em> long
story short, we built it, she liked it, he's happy, I'm awesome, and the
world keeps on a-spinnin'. The game can be found at the following link -
best viewed on an iPhone, but should still be beautifully awesome on any
device (Android, PC, WebOS, etc):</p>
Give the game a whirl</a></p>
Oh hallo thar Mobile Safari</h2>
So, making the game was an interesting experience. I opted to build it
in a Webkit wrapper - HTML/CSS/Javascript are a much faster way to
prototype, and I wasn't looking to spend 12 hours on this project (I
somewhat did, but not for the reasons one would think offhand). The
process we took was pretty simple - sat down, sketched out the game play
and general UI, then started building; I, of course, actually
implementing things in the tech sense, and my brother handling the
artwork/color scheme/etc. Building the game, all said and done, took us
around an hour and a half from start to finish.</p>
At this point, I figured, let's Phonegap</a> it
up and call it a day. This would've worked, except for the fact that
Apple has apparently blocked newer i(Phone|OS) SDKs from running on
Leopard. I've since upgraded to Snow Leopard, but seriously, this seems
a bit overbearing to me.</p>
Of course, at that point, I wasn't going to upgrade my OS then and
there, as it was past midnight. I experimented with reverting the
firmware back to the 2.x series, which I'm able to build and target to,
but there were a myriad of problems there due (apparently) to some
earlier jailbreaking that had occurred with the device. Go figure.</p>
As a last resort, I decided to bookmark the app on the phone to
"install" it. The one caveat with this approach is that it'd require an
internet connection upon opening it up every time. What'd be ideal is if
we could jam the entire thing into the Mobile Safari cache - there's a
simple trick here that'll make life easier. I found that Mobile Safari,
by default, won't cache sites like you think it would, but you can
supply it with an HTML5 Cache Manifest that'll be respected by the
browser, forcing everything to get shoved in the cache.</p>
The cache isn't huge, though, and the initial load shouldn't be huge as
a principal. There are a lot of external scripts used here, mainly to
automate smooth CSS transitions so the device hardware accelerates
animations, so the entire app is roughly ~130kb. Small, in this case,
but the limitations were worth discussing.</p>
To get around cold cache loads, the single image used in the game (the
strawberry) is Base64 encoded into the html file itself, and all scripts
are also placed inline. Combine this with a few Apache directives, and
it loads quick enough the first time. The final trick is the following:</p>
</span># At the top of your file, specify the cache manifest (your_app.html)
</span></span><html manifest="dragonfruit.manifest">
</span></span>
</span></span># The cache manifest itself (dragonfruit.manifest)
</span></span>CACHE MANIFEST
</span></span>index.html
</span></span>apple-touch-icon-precompressed.png
</span></span>
</span></span># Needs to be sent back to the browser as a header for the manifest (.htaccess, etc)
</span></span>AddType text/cache-manifest .manifest
</span></span></code></pre>
In there, we modify three files. In the app itself, specify the location
of the cache manifest; the second set is an example cache manifest you
can borrow (the icon is used in the bookmark flow for the iPhone); the
final piece is a header that needs to be sent downstream to the browser
when the manifest is requested.</p>
Voila, we've installed an app onto the iPhone without compiling
anything. Shove it all into the cache, and it can sit there for quite
some time - if we were to combine it with some localStorage action, it's
an (almost) potent combination. It still doesn't beat the App Store for
distribution, but hey, it worked.</p>


...and what's the deal with San Francisco? (along with my travels)
Wed, 06 Oct 2010 00:00:00 +0000
It's been a good two months since I last updated this. Ordinarily I'd be
a little angry that I let it slide for that long, but in this case I
think it's warranted. For those interested, here's a summary of what
I've been up to, along with my thoughts on San Francisco in general.</p>
Since leaving Webs.com (see my previous
post</a> for more
information on that), I've been pretty much all over the United States.
About a week after leaving Webs, I embarked on an epic road trip with a
friend that went from North Carolina all the way to California. Driving
across the USA is a fun journey, one that I recommend everyone take at
some point. The midwest is a surprisingly desolate place; never before
have I seen so many sex shops randomly dotting the countryside.</p>
Out of all the states that we passed through, a choice few gave me some
of the best memories. Louisville, Kentucky, was a fun stop, as I got to
finally meet up with my long time friend (from my old IRC days) Zach
Winter</a>. We used to fight like brothers
back in the day, but he's become a pretty awesome web developer/designer
in the time I've known him, so between that and talking about old IRC
crap we probably wasted a good four hours there. Riverton, Wyoming was
pretty cool, as it's a totally small town in the middle of nowhere with
an indian casino. Driving through Yellowstone was something to behold,
and the same goes for the desert-esque areas. I could go on here, but
there's enough to write a small novel at this point.</p>
California was an interesting time period, and is actually the primary
reason I'm even writing this post. I enjoy getting out and trying new
areas of the world, traveling and exploring is a truly exhilarating
experience that, in many regards, can't be matched. As is (seemingly)
the norm, being a developer, I naturally headed to San Francisco. The
city (and the "Valley" in general) are routinely hyped as being an
incredible experience if you're in the industry. Living there taught me
two things: I have a lot of reservations about the "startup" industry as
a whole, and San Francisco as an area to live in</em> isn't all it's hyped
up to be.</p>
I'm putting my reservations on hold for another post, as I'd like to
more carefully formulate those into something more concise to read. In
terms of the living area, though, I'll put it bluntly: San Francisco is
a trashy, over-hyped city that masquerades as a clean, eco-friendly
environment where there's a seemingly open exchange of new ideas every
day.</p>
Before the inevitable shit storm starts here...</h2>
Let's pick apart that statement.</p>
Walk down any street in the Mission, SOMA, or even North Beach, and look
at the amount of trash on the ground. Now, with a straight face, tell me
that San Francisco is a clean city - I'll bet money that you can't do
it. This is counter to a city like New York City (NYC); with NYC, it's a
trash fest, sure, but nobody is going to try and tell you that it's
actually a clean city. After living in the DC area for most of my life,
and checking out Chicago, Boston, and Seattle (all of which are fairly
clean in their nicer areas</em>, which I'm comparing to the nicer areas of
San Francisco), I'd say the same sentiment goes for those cities.</p>
I'll cede the point that this issue can go either way depending on who
you talk to, but my experience was that most people tried to claim it's
a clean city, and it quite frankly astounded me. Your mileage on this
one may vary, and I invite you to judge for yourself.</p>
What follows is a dissection of some of the allures of San Francisco
living, at least from what I gathered through the various groups I hung
out with in my time there. We'll go one by one here. Feel free to grab a
snack if you're going to read any further, by the way.</p>
The tech scene</h2>
This one could be construed as a personal preference, so I'll keep this
short. The tech scene in San Francisco bothers me much more than I ever
thought possible. Perhaps I just went to the Valley at a low point in
history, but seriously, what the hell is with the amount of startups
building on top of something like Twitter's API? Beyond that, how many
god damn social networks need to re-invent the fucking wheel before
someone finally wakes up and decides that enough is enough?</p>
Hell, I can even deal with the existence of these things, but the fact
that you're taking funding</em> for such concepts? You do realize there are
more important things in the world than blowing a couple hundred grand
on sharing pictures through Twitter, right?</p>
There are a lot of cool ideas and new technologies being developed out
in San Francisco, but for every awesome idea, there's about four
ridiculous ones that are setting themselves up for failure by doing
something as stupid as relying on the API of a network that has a
history of letting people do all the discovery work for them, then
building their own version.</p>
Tech companies (both good and bad) can exist anywhere, but it's a myth
that only great tech companies exist (and can exist) in San Francisco.
Live where you actually enjoy living and don't feel pressured to accept
and praise an area based on a set-forth notion that it's the
end-all-be-all of an industry.</p>
The food scene</h2>
Huzzah, burritos. What's there to get for lunch? Oh... burritos. Oh,
wait, no, there's about three different French places all serving the
same stuff, too, so I suppose we could do that for lunch.</p>
Past nine o'clock? Nevermind half those places if you want a quick bite,
they're either closed or going to be closing at that time. So your
options then become... oh, go into a bar, order a pizza, or get another
burrito. Such incredible choices in a city supposedly known for its food
choices - I definitely never had those choices anywhere else! Why would
I ever leave this place?</p>
The people</h2>
I met a lot of awesome people in San Francisco, don't get me wrong.
Thing is, I've met a lot of awesome people in every</em> city I've been to.
This is just part of society in general - no matter where you go,
there's people you like, and people you don't like.</p>
With that in mind, let's take an objective look at San Francisco. 90% of
the people I met were transplants, and they all came for one of two
reasons: technology (the startup world specifically), or some artistic
venture that hasn't panned out and they heard that San Francisco is an
"accepting" city. This all ends up melding into a very "me too" culture,
where it's nothing but people clamoring for attention around their
newest idea.</p>
This wouldn't even be that big of a deal if it wasn't compounded by the
fact that everyone essentially circle-jerks one another on these
concepts to a ridiculous degree. Yeah, you think you can form a real
business around something like a Firefox browser extension? Please take
a seat over there, your head has been in the clouds for far too long (no
pun intended).</p>
Get to the point please</h2>
San Francisco feels incredibly fake, and gets a free pass due to the
overall net worth of the Valley. The city is an incredibly trashy place
to live, it has an incredibly overbearing "me too" culture, and almost
everything that's supposedly great about the city can easily be found in
other areas that are cleaner and provide a better overall living
experience.</p>
It's funny, really. If you try to explain any of this to anyone living
San Francisco, there's a good chance you'll send them into a mode where
they feel the need to defend the aforementioned points. The only other
city I've found where people get that extreme is - surprise, surprise -
New York City. San Francisco is like the punk kid in school who, even
though they're really no different, felt the need to dress completely
different and act out to feel individual.</p>
I suppose that's worked for people throughout history, though, so
there's not too much more to say on the matter. If you need me, though,
I'll be traveling around to cities that are a bit more pleasant and fun
overall (and, hey, if you enjoy living in San Francisco, more power to
you, but you just make me scratch my head).</p>


Moving right along...
Mon, 02 Aug 2010 00:00:00 +0000
For those who haven't heard the news, my last day at
Webs.com</a> was this past Thursday (July 29th,
2010). After three and a half years, I figured it was finally time to
move on.</p>
It's interesting to reflect on such a large portion of a lifespan. When
I joined Webs (then Freewebs) back in 2007, I was actually homeless, and
was working a part time job at a Blockbuster. I had gotten pretty tired
of that routine, and started cold-emailing companies. Out of all of
them, Freewebs was the one who responded and invited me out to interview
with them.</p>
I remember being shocked when, a few weeks later, I received an offer to
join up. Y'see, it's no secret that I'm pretty much self taught through
and through when it comes to web design - with no formal training, I was
surprised that anyone would consider me for a position in this field.
Accepting that offer led me down a long path that's definitely shaped a
lot of who I am today, both professionally and personally.</p>
Prior to joining Webs, I knew HTML and CSS well, but when it came to
actual programming I had just dabbled here and there, never gaining a
solid understanding of the craft in general. Working at Webs was, in
many ways, a great substitution for a college experience. The amount of
things I learned is staggering - data analysis, in depth design
techniques, and more.</p>
Granted, while all that certainly contributed to my growth, I worked my
ass off while I was there; I guess I'm simply stating that the
environment is easily one of the best possible places to ever work if
you're a developer. All those startup companies in San Francisco that
seem so great to work at? Good luck finding anything similar in the
Washington DC/Metro area... short of Webs.com</a>.</p>
So what's next?</h2>
I'm tired of Washington DC. It's a great city with a culture all its
own, but I've grown up around all of this, and I want to see more of the
world in general. The west coast is very appealing to me, so I'm most
likely headed out there. As my career situation develops, I'll update
this space accordingly.</p>
Besides all of that, I've got my open source work to maintain, as well
as some other cool projects in the pipeline. This isn't the end, but
moreso the beginning of an epic awesome adventure.</p>
I'm awesome.</p>


On Date/Time/DateTime in Ruby, and why they suck
Sun, 18 Jul 2010 00:00:00 +0000

    This is Old!</h4>
    I wrote this when I was much younger, and arguably, a bit of a jackass (pardon my French). I keep it up for personal reasons, and there might be some technical content of note here... so just please ignore the tone.
    </p>
</div>
Yeah, there, I said it - this is a stupid situation for a language to be
in. The concepts of Date</code>, Time</code>, and DateTime</code> are all pretty well related. Date</code> is a point in Time</code>, DateTime</code> is a really nice representation of
Date</code> and Time</code> mashed together.</p>
In a world that actually makes sense, you'd be able to easily convert
between these types (e.g: DateTime</code> should be able to easily convert over
to a Time</code> object). Some people might suggest patching the aforementioned
classes (like Rails does, for parsing relative dates), but this just
feels like an incredibly hacky solution.</p>
Now, normally, I'm not much of a Ruby guy, give me Javascript any day.
However, there are a lot of awesome projects written in Ruby, and it's
hard to deny that they've easily got the best packaging solution for any
language. As it so happens, earlier this week I was hacking on a little
Sinatra</a> side project.
DataMapper</a> was my ORM of choice here,
because it's just so beautifully plug and play.</p>
In the example app we'll look at, it's your basic Post/Comment scenario.
For each Post/Comment, we want to be able to render the relative time
ago that the item in question was submitted (e.g, "16 hours ago", etc).
Rails has conventions for this baked in by default (because they,
y'know, enjoy polluting namespaces, go figure). When you're outside of
Rails and want to do this, it's somewhat more difficult.</p>
Originally I started by storing the creation time as DateTime</code>; makes
sense, we should</em> be able to convert this to Time</code> to do easy
comparisons against Time.now</code>, right?</p>
Well, uhh, no. Definitely not that simple. After some digging around, I
discovered the dm-types</code></em> gem, which adds some extra types to
DataMapper. One of these types is known as EpochTime</code></em>, which is (you
guessed it) the time since Epoch that the entry was created.</p>
With that, we can pretty much stay within the realm of Time</code>. Ripping
apart ActionView</code> gives us a good base to work with on the act of getting
a relative string; putting it all together, we get the following Sinatra
app (two files - the main Sinatra app, and our custom date_helper</code>
library).</p>
</span>require </span>'rubygems'
</span></span>require </span>'sinatra'
</span></span>require </span>'dm-core'
</span></span>require </span>'dm-migrations'
</span></span>require </span>'dm-serializer'
</span></span>require </span>'dm-types'
</span></span>require </span>'date_helper'
</span></span>
</span></span>DataMapper</span>.</span>setup(</span>:default</span>, {
</span></span>    </span>:adapter </span>=> </span>'mysql'</span>,
</span></span>    </span>:database </span>=> </span>'database_name'</span>,
</span></span>    </span>:username </span>=> </span>'database_username'</span>,
</span></span>    </span>:password </span>=> </span>'database_password'</span>,
</span></span>    </span>:host </span>=> </span>'localhost'
</span></span>})
</span></span>
</span></span>class </span>Post
</span></span>    </span>include </span>DataMapper</span>::</span>Resource
</span></span>
</span></span>    </span>property </span>:id</span>, </span>Serial
</span></span>    </span>property </span>:username</span>, </span>String
</span></span>    </span>property </span>:entry</span>, </span>Text
</span></span>    </span>property </span>:created_at</span>, </span>EpochTime
</span></span>
</span></span>    </span>has n, </span>:comments
</span></span>end
</span></span>
</span></span>
</span></span>class </span>Comment
</span></span>    </span>include </span>DataMapper</span>::</span>Resource
</span></span>
</span></span>    </span>property </span>:id</span>, </span>Serial
</span></span>    </span>property </span>:username</span>, </span>String
</span></span>    </span>property </span>:entry</span>, </span>Text
</span></span>    </span>property </span>:created_at</span>, </span>EpochTime
</span></span>
</span></span>    </span>belongs_to </span>:post
</span></span>end
</span></span>
</span></span>
</span></span>DataMapper</span>.</span>finalize
</span></span>DataMapper</span>.</span>auto_upgrade!
</span></span>
</span></span># Requests/views/etc
</span></span>get </span>'/' </span>do
</span></span>    </span>erb </span>:index
</span></span>end
</span></span>
</span></span>post </span>'/post/new' </span>do
</span></span>    </span>@post </span>= </span>Post</span>.</span>create(
</span></span>        </span>:username </span>=> params[</span>:username</span>],
</span></span>        </span>:entry </span>=> params[</span>:entry</span>],
</span></span>        </span>:created_at </span>=> </span>Time</span>.</span>now</span>.</span>to_i </span># See? Epoch-goodness.
</span></span>    </span>)
</span></span>
</span></span>    </span>if </span>@post
</span></span>        </span># .create automatically saves the post; now override the created_at
</span></span>        </span># point before we pass back our JSON object to the view.
</span></span>        </span># "distance_of_time_in_words" is from date_helper.rb
</span></span>        </span>@post</span>.</span>created_at </span>=</span> distance_of_time_in_words(</span>@post</span>[</span>:created_at</span>]</span>.</span>to_i</span>)
</span></span>        </span>@post</span>.</span>to_json
</span></span>    </span>else
</span></span>        </span>{</span>:error </span>=> </span>true</span>}</span>.</span>to_json
</span></span>    </span>end
</span></span>end
</span></span>
</span></span># Get views for comments, posts, etc
</span></span></code></pre></span># Proudly (or shamefully, depending on how you look at it) ripped right out
</span></span># of ActionView and modified to base it all on the Epoch. Give credit where credit is due.
</span></span># from_time expects another judgement from Epoch (e.g, Time.whatever.to_i)
</span></span>def </span>distance_of_time_in_words</span>(</span>from_time</span>, </span>to_time </span>= </span>Time</span>.</span>now</span>.</span>to_i</span>, </span>include_seconds </span>= </span>false</span>)
</span></span>    </span>distance_in_minutes </span>= </span>(((to_time </span>-</span> from_time)</span>.</span>abs)</span>/</span>60</span>)</span>.</span>round
</span></span>    </span>distance_in_seconds </span>= </span>((to_time </span>-</span> from_time)</span>.</span>abs)</span>.</span>round
</span></span>
</span></span>case</span> distance_in_minutes
</span></span>when </span>0</span>..</span>1
</span></span>return </span>(distance_in_minutes</span>==</span>0</span>) </span>? </span>'less than a minute ago' </span>: </span>'1 minute ago' </span>unless</span> include_seconds
</span></span>
</span></span>case</span> distance_in_seconds
</span></span>when </span>0</span>..</span>5   </span>then </span>'less than 5 seconds ago'
</span></span>when </span>6</span>..</span>10  </span>then </span>'less than 10 seconds ago'
</span></span>when </span>11</span>..</span>20 </span>then </span>'less than 20 seconds ago'
</span></span>when </span>21</span>..</span>40 </span>then </span>'half a minute ago'
</span></span>when </span>41</span>..</span>59 </span>then </span>'less than a minute ago'
</span></span>else             </span>'1 minute ago'
</span></span>end
</span></span>
</span></span>when </span>2</span>..</span>45           </span>then </span>"</span>#{distance_in_minutes}</span> minutes ago"
</span></span>when </span>46</span>..</span>90          </span>then </span>'about 1 hour ago'
</span></span>when </span>90</span>..</span>1440        </span>then </span>"about </span>#{(distance_in_minutes / </span>60</span>).round}</span> hours ago"
</span></span>when </span>1441</span>..</span>2880      </span>then </span>'1 day ago'
</span></span>when </span>2881</span>..</span>43220     </span>then </span>"</span>#{(distance_in_minutes / </span>1440</span>).round}</span> days ago"
</span></span>when </span>43201</span>..</span>86400    </span>then </span>'about 1 month ago'
</span></span>when </span>86401</span>..</span>525960   </span>then </span>"</span>#{(distance_in_minutes / </span>43200</span>).round}</span> months ago"
</span></span>when </span>525961</span>..</span>1051920 </span>then </span>'about 1 year ago'
</span></span>else                      </span>"over </span>#{(distance_in_minutes / </span>525600</span>).round}</span> years ago"
</span></span>end
</span></span>end
</span></span></code></pre>


The perception of "Inception"
Sun, 18 Jul 2010 00:00:00 +0000
It's no secret that I primarily use this space to talk about programming
and the web at large. It's a huge part of who I am, but it's not all</em>
that I am. Sometimes I see something so incredibly cool and inspiring
that I just feel the need to talk about it; such is the case with the
movie "Inception".</p>

Please note: the following is full of spoilers if you haven't seen
the movie yet!</em></li>
Believe me when I say that this is a movie that you should avoid
having spoiled at all costs, because it's just such an incredibly fun
ride. This post will also make little sense unless you've actually
seen the movie. Seriously, go see the movie if you haven't already,
then come on back, this post isn't going anywhere.</em></li>
</ul>
What really happened in this movie?</h2>
I'll start by making sure this is noted right off the bat: I believe
that the Wikipedia
explanation</a> of
the ending of the movie is completely wrong. The article states that, in
the end of the movie, everyone wakes up on the plane just fine. The
genius part about this movie is that Christopher Nolan, the director,
rarely strayed towards one ending; everything throughout the movie is
meant to spark discussion about the final ending scene, where the top
may or may not have</em> fallen.</p>
Throughout the film, Nolan obviously took great care to make the
audience aware of the mathematics surrounding the way the levels relate
to one another. The idea with this is that, in the end, even though Cobb
is left underwater in the van, the time that he spent in the sublevels
beyond could be as little as a few minutes there, giving enough space
where he could've magically gotten back up through the levels.</p>
That's all nothing but a ploy, though. Here's the thing - in the ending,
I believe Cobb never actually woke up. Let's look at the film this
way...</p>
Cobb and his children</h2>
First off, the kids and the shot at the end. Did anybody else notice
anything strange about it? The kids never aged!</em>. Cobb goes back to his
place and it's as if he never left. We're purposely never given a
timeline as to when</em> Cobb and Mal had their little incident with Mal
having a bad case of PMS and jumping out a window. I'd say it's safe to
assume that this has to have been at least a few months to a year,
though; we're shown shots of Cobb talking to various psychiatrists,
attempting to persuade people that he did not, in fact, kill Mal. If
this is in relation to court proceedings of some kind... well, we all
know how long those acts can take.</p>
That said, we really don't even need to consider that, it's just a nice
piece to note. What we should really</em> be looking at is that, throughout
the film, every time Cobb sees his kids in a dream, they're the same
(just like in the end of the film). It's his last memory of his kids; in
some way, they're his inception.</p>
Keep this in mind, because the rabbit hole goes a bit deeper.</p>
Cobb and Saito: honoring the agreement</h2>
When the team is in the first sublevel, Saito takes a bullet to the
chest. There's a scene where he specifically states that no matter what
happens, he'll be sure to honor their agreement</em>. Of course, at that
point in time, we all have reason to believe that Saito is going to make
it out alright, Cobb will be able to get back into the US, and everyone
will go on their merry way.</p>
As the film continues, though, Saito's condition worsens, and he
eventually passes away in the third sublevel. This is a huge fact: Saito
is now in limbo</em>. Cobb, after finally killing Mal, stays behind in
limbo to find Saito to make sure he honors the agreement</em>.</p>
See a pattern here? In this case, there's more than one way to honor
their agreement. Cobb eventually does find Saito, when Saito is much,
much older. They speak of honoring their agreement, which is why Cobb
came, and Saito reaches for the gun</em>. This is the most notable piece of
their entire level of interaction throughout the movie - if dying in a
sublevel when you're that far under puts you in limbo, what happens when
you die in limbo</em>?</p>
Of course, we're never directly told. Tricky, tricky Nolan, but we'll
pin this down yet.</p>
On Heaven, Hell, and Unicorns</h2>
Mal's dead, no? What's funny about Mal inside Cobb's subconscious is
that she's located in the basement of his mind, an eternal hell</em> that
Cobb can't seem to get rid of, as if he was condemned to that fate for
his action against Mal (trying inception on her first). Eventually, when
they make it down to limbo, Cobb finally kills the idea of Mal - this is
his redemption.</p>
Cobb is essentially painted as a fallen angel throughout the movie,
barred from heaven. By atoning</em> for his sins, he's allowed back in and
everything is supposedly great. That said...</p>
What was really Cobb's Heaven? Real life, where he got back to see his
kids? His one goal was to go home, to be with his family, but it's made
apparent to us, the viewers, that when you're in limbo it's difficult
(or almost impossible) to get out.</p>
Bringing it all together</h2>
As I said before, Cobb never actually woke up. Saito reaching for the
gun is meant to imply that he kills Cobb, setting him free - not in the
sense of waking him up, but allowing Cobb to dream that which he's
wanted for ages, to be back with his family (hence why, when he goes
back to his kids, they're exactly the same as in every other shot</em>).</p>
Nolan again takes great care to make sure this is difficult to prove -
specifically, the scene where Cobb and Mal allow themselves to be run
over by a damn train. This is supposed to imply that simply dying in
limbo allows you to truly wake up. That said, unless Saito kills himself
and Cobb (which seems a little odd - Saito knew the rules of the game,
why wouldn't he just kill himself prior to Cobb finding him?), the final
scene really does seems like Cobb is dreaming forever.</p>
See, Saito supposedly woke up just fine, made the call, everything's
great. However, what guarantee is there that either of them woke up
normally from limbo</em>, the level that seriously messed up Mal? None.</p>
This all brings us to the final scene with the spinning top: it was a
great move on Nolan's part to end it right as the thing supposedly
topples, essentially forcing the entire discussion this article was even
written about. Sure, we could assume that it signifies Cobb is alive and
well, not dreaming.</p>
However, a friend of mine offered this suggestion, which I think really
ties it all together: she proposed that the top falling was Cobb giving
in to his dreams, accepting that reality as reality itself. This is
utterly genius, and makes an insane amount of sense.</p>
The other theory that comes to mind is that it was Mal's totem
originally, and she's now, for all intents and purposes, finally gone, a
demon purged from his mind, allowing him to dream peacefully forever.</p>
This movie was an incredible mental trip, and one I definitely intend to
watch again. What do you think? Feel free to leave comments below;
they'll be moderated to deal with spam and trolls, but healthy
discussion on this film is highly encouraged.</p>


Rendering emails with Django templates
Tue, 13 Jul 2010 00:00:00 +0000
I talk a lot about Javascript on this blog: client-side, server-side,
wherever the language can be used. It's not the only language I enjoy
working in, though; Python has always had a bit of a soft spot with me,
and with that comes some inevitable
Django</a> love.</p>
I use Django for a lot of my server side tasks where I don't feel I can
safely use something like Node.js</a>. On top of
being battle tested beyond belief, it's a veritable bag of magic tricks
just waiting to be used. Take this one case I ran into recently: I'm
building a service (stealth at the moment, stay tuned) that has to do
something as simple as send out an email when a new user signs up.</p>
Now, that email should ideally contain a few things. Let's assume that,
for a basic example, we're gonna just include their username, a brand
new password, and their full name (how we'll use each of these is shown
in depth below). Django makes sending mail pretty easy, using the
send_mail</code></em> function:</p>
</span># Make sure you import this, otherwise... well, you get the idea.
</span></span>from </span>django</span>.</span>core</span>.</span>mail </span>import </span>send_mail
</span></span>
</span></span># send_mail is pretty straightforward, as you can see.
</span></span>send_mail</span>(</span>'Title'</span>, </span>"Body"</span>, </span>"from_addy"</span>, [</span>"emails"</span>, </span>"sent"</span>, </span>"to"</span>], </span>fail_silently </span>= </span>True</span>)
</span></span></code></pre>
That's all well and good, but what if we want to do more than just</em> a
simple string for our body message? Ideally, we should be able to treat
this like any other Django template. In practice, this is actually
incredibly easy (and fun).</p>
The code should be fairly well documented, but for those who'd like a
little more verbose of a walkthrough, it's pretty simple: instead of
passing in a string, load up a template and pass it a rendering context.
See, what got me the first time around is that the render</code></em> method of
get_template</code></em> needs a Template Context to do the dirty work, not a
standard dict</em>.</p>
</span># We should all know what this is used for by now.
</span></span>from </span>django</span>.</span>core</span>.</span>mail </span>import </span>send_mail
</span></span>
</span></span># get_template is what we need for loading up the template for parsing.
</span></span>from </span>django</span>.</span>template</span>.</span>loader </span>import </span>get_template
</span></span>
</span></span># Templates in Django need a "Context" to parse with, so we'll borrow this.
</span></span># "Context"'s are really nothing more than a generic dict wrapped up in a
</span></span># neat little function call.
</span></span>from </span>django</span>.</span>template </span>import </span>Context
</span></span>
</span></span># Some generic stuff to parse with
</span></span>username </span>= </span>"fry"
</span></span>password </span>= </span>"password_yo"
</span></span>full_name </span>= </span>"Philip J Fry"
</span></span>
</span></span># Our send_mail call revisited. This time, instead of passing
</span></span># a string for the body, we load up a template with get_template()
</span></span># and render it with a Context of the variables we want to make available
</span></span># to that template.
</span></span>send_mail</span>(
</span></span>    </span>'Thanks for signing up!'</span>,
</span></span>    </span>get_template</span>(</span>'templates_path/email.html'</span>)</span>.</span>render</span>(
</span></span>        </span>Context</span>({
</span></span>            </span>'username'</span>: username,
</span></span>            </span>'password'</span>: password,
</span></span>            </span>'full_name'</span>: full_name
</span></span>        </span>})
</span></span>    </span>),
</span></span>    </span>'admin@moxlee.com'</span>,
</span></span>    </span>[</span>'users_email@gmail.com'</span>],
</span></span>    </span>fail_silently </span>= </span>True
</span></span>)
</span></span></code></pre>
With that, here's an example of an email template - it's literally just
a Django template, but ready for all your email attributes.</p>
</span>Welcome {{ full_name }}!
</span></span>
</span></span>Your username </span>is </span>{{ username }} </span>and </span>your password </span>is </span>{{ password }}</span>.
</span></span>
</span></span>- </span>Management 
</span></span></code></pre>
Django's templating system is incredibly flexible, and can easily be
used for more than just your generic views. If you have any questions or
suggestions, feel free to throw them in the comments!</p>


You got your Base64 in my CSS!
Thu, 17 Jun 2010 00:00:00 +0000
If you're a developer working on a website that's getting any traffic,
you'll inevitably come up against the problem of making sure you're as
performant as possible on the front-end. You'll probably compress your
Javascript and CSS, maybe refine the slower portions of your site after
profiling them, and maybe (if you're smart) sprite your images.</p>
You see, one of the chief goals in terms of a highly performant site is
to get the amount of HTTP requests as low as possible. Most people turn
to CSS sprites; they're a great technique for designers, and fairly easy
to understand. That said, they're not without their
downsides</a>.
They can become quite an unmaintainable mess if you're not careful -
change the location of a few images, and you have to change the
corresponding CSS declaration to match it. On a large site, you'll end
up repeatedly putting together a puzzle that's wasting your time.</p>
What if you're working on a team? How do you manage to keep one image</em>
in sync across 2 people? 5 people? At this point, you're probably
wondering why I'm even bothering to rant on this, since these points are
all fairly well known. Well, here's the thing - there's an alternate
solution, depending on how open to the concept you are.</p>
What the hell is Base64?</h2>
Just about every modern browser supports the concept of Data URI Schemes</a>. With this,
you can do the following:</p>
</span>body </span>{
</span></span>    </span>background</span>: </span>transparent </span>url</span>(</span>data:image/png;base64,
</span></span>iVBORw0KGgoAAAANSUhEUgAAAAEAAABnCAIAAABO2r+ZAAAA
</span></span>GXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAA
</span></span>AG9JREFUeNp8T9sNgDAIvJCu4Ay6rEO5hXEBP9yB0xLa0Fr9
</span></span>aLgHBxTrdgpIASB8HoiAXf/VaJmSbbj1df1jnpyn1qfViF+e
</span></span>31T3Rxw8yzSez4u4u89medWMtWiZB197jYP8t1dv878u85T2
</span></span>47oFGAC4z6tdlRsLNAAAAABJRU5ErkJggg==</span>) </span>repeat-x top left</span>;
</span></span>}
</span></span></code></pre>
A bit ugly? Yeah, you might say so. Effective? Definitely. The above
code simply generates a blue gradient that tiles perfectly. The really
long block of text you see there is a Base64 encoded string that
essentially gets transformed into your image. There's various different
ways to generate the Base64 representation you need; if you want a
really simple tool, check out this Firefox
extension</a>.</p>
The format of a Data URI is fairly simple to understand - in this case,
we're saying that this is a PNG, getting passed via Base64, and then the
Base64 string itself. If it helps, think of it as a glorified function
call.</p>
As I noted above, most modern browsers support this technique. The one
caveat worth mentioning is that Internet Explorer 8 is limited on the
size of a Data URI to around 32kb. It's not really recommended to use
this technique for anything above that size, but hey, your life, do what
you want.</p>
Oh, and Internet Explorer 6 and 7 have absolute zero support for this
method.</p>
Don't fret, we can make Base64 encoding work in IE6/7!</h2>
Internet Explorer (Explorer in general, really) supports another file
type that does</em> understand Base64: mhtml</strong>. We can use this trick to
make IE6/7 do some awesome magic:</p>
</span>/*
</span></span>Content-Type: multipart/related; boundary="_"
</span></span>--_
</span></span>Content-Location:1
</span></span>Content-Type: image/png
</span></span>Content-Transfer-Encoding:base64
</span></span>iVBORw0KGgoAAAANSUhEUgAAAAEAAABnCAIAAABO2r+ZAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAG9JREFUeNp8T9sNgDAIvJCu4Ay6rEO5hXEBP9yB0xLa0Fr9aLgHBxTrdgpIASB8HoiAXf/VaJmSbbj1df1jnpyn1qfViF+e31T3Rxw8yzSez4u4u89medWMtWiZB197jYP8t1dv878u85T247oFGAC4z6tdlRsLNAAAAABJRU5ErkJggg==
</span></span>--_--
</span></span>*/
</span></span>
</span></span>body </span>{
</span></span>    </span>background</span>: </span>transparent </span>url</span>(</span>data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAABnCAIAAABO2r+ZAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAG9JREFUeNp8T9sNgDAIvJCu4Ay6rEO5hXEBP9yB0xLa0Fr9aLgHBxTrdgpIASB8HoiAXf/VaJmSbbj1df1jnpyn1qfViF+e31T3Rxw8yzSez4u4u89medWMtWiZB197jYP8t1dv878u85T247oFGAC4z6tdlRsLNAAAAABJRU5ErkJggg==</span>) </span>repeat-x top left</span>;
</span></span>    </span>*</span>background</span>: </span>transparent </span>url</span>(</span>'mhtml:http://absolute_url.com/css_file.css!1'</span>) </span>repeat-x top left</span>;
</span></span>}
</span></span></code></pre>
What we're doing here is fairly simple, but hilariously hacky. Take a
look at the top of the file - it's a damn MIME header, with a little
"pointer" (content-location</em>) to our Base64 representation. We then
just do a second background declaration for IE only that points to the
same stylesheet</em>, but parses it as mhtml</em> instead. Our !1</em> is simply
an identifier pointing to our first declaration - subsequent encodings
could use 2, 3, "jackalope", whatever you want. Each "block" is defined
by a "separator" or "boundary" - in this case, we're using "_".</p>
I stumbled across this little trick while working on performance for
Webs.com</a>. However, it seems I can't take credit
for it - Stoyan
Stefanov</a>
posted on this awhile back. However, finding his work led me to one
barrier that I've yet to see a solution to.</p>
IE7 on Windows Vista - oh god, why?</h2>
It would seem that, due to some of the security settings on Vista (and
maybe Windows 7), IE7 refuses to load the necessary
styles</a>.
Stefanov advocates making the browser always</em> request the mhtml as a
new file. This is counter to the goal, though - we want that file
cached.</p>
Well, I happened to stumble on an easier solution (a combination of
reading the MHTML spec and rearranging formats out of madness). Just
make sure to end your IE hackery on a boundary declaration - the IE code
above already does this: notice the "--_--" right before the end of the
comment containing all the Base64 encodings for IE. This'll have IE7
parsing correctly everywhere, and we can all sleep soundly at night.</p>
Whew! Awesome, now what?</h2>
Well, that's for you to decide. This technique can be quite useful - at
Webs.com</a>, I was able to cut the size of our
sprite down immensely by relying on this trick for all the background
tiling gradients on the page. In my humble opinion, this trick is good,
but it works best when you combine it with a CSS sprite. I've found the
best method is to split the usage down the middle - constant, rarely
changing pieces become encoded, and the other pieces (testing-related,
generally) get sprited out.</p>
With any luck, this post can help someone else out. It seems like
there's a lot of information regarding this technique, but it's been
haphazardly organized over time. This isn't quite a "definitive" guide,
but it aims to be a kickass outline!</p>


Quit incorrectly passing functions in Javascript
Wed, 09 Jun 2010 00:00:00 +0000
In my line of work, I edit a lot of legacy code, and with that I see a
lot of the following:</p>
</span>// Bad practice. Can you see why?
</span></span>var </span>foo </span>= </span>function</span>() </span>{ </span>alert</span>(</span>"bar"</span>); </span>}</span>;
</span></span>setTimeout</span>(</span>"foo()"</span>, </span>2000</span>);
</span></span></code></pre>
That little piece of code is actually a really bad way of doing things,
and (to me) is illustrative of when someone is working in Javascript and
doesn't actually know what they're doing.</p>
For those who don't know (and would like to learn), setTimeout</code> (and its
sister, setInterval</code>) can accept a string of code to be executed as an
argument. Know what other method takes a string of code and executes it?
eval()</code> does. Generally, methods like these should be avoided, as they
leave ways for arbitrary scripts to run if you're not careful.</p>
So how could the above code be improved? Take the following:</p>
</span>var </span>foo </span>= </span>function</span>() </span>{ </span>alert</span>(</span>"bar"</span>); </span>}</span>;
</span></span>
</span></span>// Better practice. Note how the function is passed this time.
</span></span>setTimeout</span>(</span>foo</span>, </span>2000</span>);
</span></span></code></pre>
What's important to remember here is that *everything* in Javascript
is an object. This may seem like grade school material, but it's
surprising how many people miss it - since our function (foo</code>) is an
object, we can point to it like any other object. What we're essentially
doing now is, instead of telling setTimeout</code> "hey, evaluate this script
after this timer expires", just "run this function when this timer
expires". There's no need to invoke eval()</code> for such a simple operation.</p>
But what about my arguments?</h2>
Yes, you can still pass arguments with this form. Whereas before you'd
make up a whole string to be executed, you'd now just run it with an
anonymous function. For those of you using jQuery, this should feel very
familiar:</p>
</span>// Bad practice. Why concoct such an ugly string?
</span></span>var </span>delayedLol </span>= </span>function</span>(</span>laugh</span>) </span>{
</span></span>    </span>setTimeout</span>(</span>"alert('Laughing: " </span>+ </span>laugh </span>+ </span>"')"</span>, </span>2000</span>);
</span></span>}</span>;
</span></span>
</span></span>delayedLol</span>(</span>"bwahahaha"</span>);
</span></span>
</span></span>// Instead, pass around your argument (laugh) with anonymous functions.
</span></span>var </span>delayedLol </span>= </span>function</span>(</span>laugh</span>) </span>{
</span></span>    </span>setTimeout</span>(</span>function</span>() </span>{
</span></span>        </span>alert</span>(</span>'Laughing: ' </span>+ </span>laugh</span>);
</span></span>    </span>}</span>, </span>2000</span>);
</span></span>}</span>;
</span></span>
</span></span>delayedLol</span>(</span>"bwahahaha"</span>);
</span></span></code></pre>
Javascript is incredibly flexible. If you're going to work in it, take
the time to actually understand what's going on. You (and your users)
will be better off for it.</p>


jQuery Introduction, Refresh Fred May 2010
Thu, 13 May 2010 00:00:00 +0000
I had the awesome chance to give a presentation at the May 2010 meeting
of Refresh Fred</a>. The talk I gave was on an
introduction to jQuery (as well as some basic Javascript).</p>
The great part is that, since I opted to build the presentation in HTML,
CSS, and JS, it's easily viewable online. You can check out the
presentation
online</a>, or check
out the source on
Github</a>.</p>
The entire presentation is MIT licensed (of course, that goes as far as
a presentation even so much as *can* be licensed). Feel free to take
the code, remix it, extend it, or re-use it - go crazy and enjoy.</p>


Time for a revival
Mon, 10 May 2010 00:00:00 +0000
Alright, so while it's taken me a nine hour long sprint of coding and
design, I've finally revived Veno. This is pretty significant, at least
on a personal level - the last time I had a personal site and portfolio
online was around the beginning of 2007.
Several people have asked me why this took so long, though, and so I
figured I'd take a moment to jot down my thoughts on the matter.</p>
Full time jobs take... well, time</h2>
See, the biggest draw on my time over the past 3 years</strong> has been my
day job with Webs.com</a>. I wanted to take the time
to really dig in and better my skills in this craft, and there's really
been no better opportunity presented to me since. It's been grueling at
points (week long coding sessions without sleep to push a redesign out
the door, anyone?), but well worth it.</p>
Now, after three years, I've found that I missed having a personal
platform to do... well, anything I wanted to, in terms of the internet.
This led to a six month period of trashed redesign attempts for Veno;
after enough failed designs, I decided to just power through it in a
day, and this is the result. It's heavily CSS3-based, but should fall
back gracefully in just about every browser. I foresee myself refining
it over time, though - there's certain things I'm unhappy with, such as
the overall "tightness" of the layout. Expect to see it open up and
breathe a bit more over the next few weeks, as well as become more
personalized.</p>
The other drain... wait, Twitter?</h2>
Ah, the micro-blogging phenomenon known as
Twitter</a>. For a pretty long while, Twitter
dominated most of my "soapbox" needs. I could throw out a small note
about whatever I'm feeling, and it would instantly hit an incredibly
connected and thriving community. I've probably met and interfaced with
more developers and designers over Twitter than anywhere else!</p>
Of course, Twitter is limited to 140 characters. What if I wanna throw
up a Javascript or Python tutorial? That certainly can't be done over
Twitter (at least, not without annoying the hell out of everyone). By
re-igniting Veno, I can provide some much needed separation to my "web
2.0 social aspects", so to speak. Expect this space to be occupied by
deeper thoughts and more intricate material, whereas my Twitter feed
will remain filled with smaller pieces (updates to my open source
projects, etc).</p>
So there it is, all laid out. It's taken a few years, but I firmly
believe that this is a case of "good things come to those who wait".
It's good to be back - expect to see some awesome things here in the
next few months!</p>


Interviewing for front-end development
Mon, 25 Jan 2010 00:00:00 +0000

    This is Old!</h4>
    I wrote this at a much younger age, when I was honestly a bit of a jackass (pardon my french). I'm leaving it up because this is my personal space, and I periodically review my old work to see how far I've come. You probably shouldn't take too much away from this piece, though.
    </p>
</div>
Interviewing people can be one of the most aggravating things in this
industry. Just about everybody who walks through your door could be some
run of the mill engineer who's set in their ways.</p>
Now, I should be fair here - I probably see this more often, due to the
position I'm in. As a front-end developer, I can't begin to count the
number of times I've had somebody come in for an interview, expecting
their database skills and server-setup capabilities to translate into
web skills. It's maddening, at points, and a real problem in the
industry - we're only now beginning to get out of the era where
front-end development is treated as a necessary evil.</p>
Front-end development carries its own unique set of problems. Nobody
who's been doing database optimizations for the past five years is going
to be able to hit the ground running on UI work; the playing field for
this stuff is constantly changing. To that end, I've started trying to
come up with different interview questions that can help show how
someone attacks the kind of work we routinely face.</p>
Seeing as how I've been in Javascript-land for the past four months, the
most recent one I came up with is this:</p>
</span>var </span>t </span>= </span>{
</span></span>    </span>r: </span>{}</span>,
</span></span>
</span></span>    </span>b</span>: </span>function</span>() </span>{
</span></span>        </span>var </span>m </span>= </span>"%45%6D%61%69%6C%20"</span>;
</span></span>
</span></span>        </span>for</span>(</span>var </span>i </span>= </span>0</span>; </span>i </span>< </span>arguments</span>.</span>length; </span>i</span>++</span>) </span>{
</span></span>            </span>if</span>(</span>arguments</span>[</span>i</span>] </span>instanceof </span>Array</span>) </span>t</span>.</span>r</span>.</span>a </span>= </span>arguments</span>[</span>i</span>];
</span></span>            </span>else </span>t</span>.</span>r</span>.</span>f </span>= </span>arguments</span>[</span>i</span>];
</span></span>        </span>}
</span></span>
</span></span>        </span>for</span>(</span>p </span>in </span>t</span>.</span>r</span>.</span>a) </span>{
</span></span>            </span>if</span>(</span>t</span>.</span>r</span>.</span>a[</span>p</span>] </span>=== </span>decodeURIComponent</span>(</span>"%72%65%64%64%69%74"</span>)) 
</span></span>                </span>m </span>+= </span>"%72%79%61%6E%40%76%65%6E%6F" </span>+
</span></span>                    </span>"%64%65%73%69%67%6E%73%2E%6E" </span>+
</span></span>                    </span>"%65%74%20%74%6F%20%74%61%6C" </span>+
</span></span>                    </span>"%6B%20%66%75%72%74%68%65%72"</span>;
</span></span>        </span>}
</span></span>
</span></span>        </span>if</span>(</span>typeof </span>t</span>.</span>r</span>.</span>f </span>=== </span>"function"</span>) </span>t</span>.</span>r</span>.</span>f</span>(</span>m</span>);
</span></span>    </span>}
</span></span>}</span>;
</span></span></code></pre>
The problem is simple: figure out what arguments need to be passed to
t.b()</code> for it to display the proper message.</p>
I feel like this is a great problem to have someone solve, as it
illustrates a few things right off the bat. Are they scared away by
encoded characters? Do they even know how to decode those characters?
Can they tell, based off the arguments work being done, what types of
objects need to be passed?</p>
It helps to draw a clear line between someone who just manages to get by
with Javascript, and someone who can really dive in and tear things
apart if need be. The code is just ugly enough to make some people roll
their eyes back into their head, but it's deceivingly simple when you
get down to it, and that's why it succeeds at the job.</p>


Open source programming languages for kids
Fri, 19 Dec 2008 00:00:00 +0000

    This Entry is Archived!</h4>
    This article was originally published on December 19, 2008
(2:00:00 PM) over at Linux.com. A still-breathing version of the article
(broken links intact) can be found at Linux.com</a>.</p>
</div>
Scratch</h2>
The past couple of years have seen an explosion of open source
programming languages and utilities that are geared toward children.
Many of these efforts are based around the idea that, since the days
of BASIC, programming environments have become far too complex for
untrained minds to wrap themselves around. Some toolkits aim to create
entirely new ways of envisioning and creating projects that appeal to
younger minds, such as games and animations, while others aim to
recreate the "basic"-ness of BASIC in a modern language and
environment.</p>
Developed by the Lifelong Kindergarten group at MIT, Scratch is a
graphical programming environment implemented in Squeak that works in a
very Lego-like fashion. The basic premise is that you build programs by
snapping together colorful blocks of code. Scratch's custom interface
allows a programmer to bring in graphics and sounds and create basic
animations. All the basic programming constructs, such as loops and if
statements, are supported, and grouped into different block categories,
such as Motion, Sensing, and Sound.</p>
Scratch has implementations available under Microsoft Windows and Mac OS
X, but as of yet there's no (official) native Linux version to run. It
is possible to run Scratch through Wine, though in my tests most
audio-related Scratch programs ended up failing. There is a
Linux-runnable version of Scratch, though it's not actively developed by
the folks at MIT. The one problem with using this version is that
presentation mode, where your Scratch program can take over the whole
screen, doesn't work. This isn't really a show-stopper, as there are a
few different ways to view a Scratch program, but it's easy to see how
it could be a desired feature.</p>
One useful prospect that Scratch offers is the ability to upload your
programs to the Scratch Web site, where you can create an account, get
support, and browse programs that other Scratch users have uploaded. All
uploaded programs are open source, in the sense that you can download
and modify the source of any Scratch program that's been uploaded.
Scratch programs are also viewable from within a Web browser, for the
most part, through use of a Java applet called the Scratch Player.
Scratch itself is released under its own Scratch License, and all
uploaded programs exist under a Creative Commons Share Alike license.</p>
One issue I came across with Scratch was that the source code for a
program could become quite large when the program involved many graphics
or, more specifically, music. One program, a simple music player,
reached a strikingly large 93MB in size. Typically Scratch would choke
on loading any program greater than 60MB in size, usually erroring out.
The large size of a file may have something to do with how old the
source code is; repeated instances of saving and re-opening the same
file seemed to grow the size exponentially.</p>
Alice</h2>
Scratch deals well with 2-D graphics, text, and other somewhat "flat"
programming concepts. By contrast, Alice teaches programming
fundamentals in the form of 3-D movies and games. Alice is developed in
Java, and is somewhat like Scratch in that you build things in a drag
and drop interface.</p>
Alice, developed by a group of researchers at Carnegie Mellon
University, has releases for Linux, Mac OS X, and Windows, and is
released under an aptly titled Alice License. The environment is open
source in the sense that you can download and examine the source code,
but the creators prefer to work exclusively in-team, and don't take
outside contributions. Alice has been around since 1999, making it one
of the oldest and most developed environments for teaching children how
to program. It is because of this that it's used in schools all over the
world.</p>
Shoes</h2>
Originally created by a developer who goes by "why the lucky stiff," now
furthered by a large development community, and based on the already
user-friendly Ruby programming language, Shoes is an open source toolkit
that's a bit more in line with traditional programming methods. All
that's required to make a program in Shoes, besides its runtime
environment, is a basic text editor. On the project's Web site you can
find a free PDF guidebook that contains tutorials and examples for
Shoes. You can also order the guidebook in paperback form for $5.57.
Shoes 2 comes with an extensive built-in manual that users can access
via key commands.</p>
Shoes has similar syntax to Ruby, and has easy methods for creating
graphics and buttons, as well as displaying colors and text. It is
supported across multiple platforms, including Linux, Mac OS X, and
Windows. The toolkit works well across platforms, in that windows,
buttons, and dialogs look native to their environment, and do so
regardless of which platform the application was initially created on. A
benefit of Shoes being in Ruby is that it's given access to the many
different RubyGems packages that exist. Shoes 2 even includes support
for automatically installing a Gem on a user's system if it's not
already present.</p>
Shoes has a fan-supported Web site that showcases a gallery of
applications created with Shoes. As with Scratch, all the applications
that are uploaded can be downloaded, modified, and remixed. Shoes itself
is released under an MIT License, and is open to outside patching and
development.</p>
A multitude of other programming languages and environments exist to
teach children, such as Greenfoot, Phogram, and Microsoft's Small Basic,
though many of them exist as proprietary implementations. Scratch,
Alice, and Shoes are all open source, include support channels such as
forums or chatrooms, and have large, thriving communities. These three
environments are possibly the most open, mature, and easily accessible
environments that are geared toward teaching programming concepts to
young minds.</p>


Supercharge Firebug
Mon, 15 Sep 2008 00:00:00 +0000

    This Entry is Archived!</h4>
    This article was originally published on September 15, 2008
(9:00:00 AM) over at Linux.com. A still-breathing version of the
article can be found at Linux.com</a>.</p>
</div>
Yslow</h2>
While you can use Firebug to monitor network activity, you can take that
to the next level by adding YSlow, which checks your Web site against
Yahoo's best practices for a high performance Web site. Besides checking
your performance, YSlow can also show you graphs and charts that let you
inspect things such as expires headers, ETags, and the total amount of
HTTP requests -- all useful for optimization.</p>
Jiffy</h2>
Jiffy is a Firebug extension developed at Netflix that checks and
captures time measurements for JavaScript that loads on the page (via
jiffyweb, an open source Web site measurement suite), and provides a
graphical representation of the data, which is ideal for comparing and
reducing the effects on page load that are brought on by various
JavaScript libraries.</p>
FirePHP</h2>
If you're debugging HTML, CSS, or JavaScript, Firebug fits your needs,
but what if you want to go further? FirePHP is a Firebug extension that
lets you work with PHP5 and up as your server-side language of choice.
FirePHP requires that a PHP library be installed in order to function,
but once that's installed FirePHP can make use of special
"X-FirePHP-Data" headers to bring debugging into the Firebug pane. The
debugging data that's sent from the server to the client-side does not
interfere with the content of the page you're debugging in any way. For
more information, including a quick tutorial, check out the FirePHP
Homepage.</p>
Firecookie</h2>
The Firecookie Firebug extension allows you to view all the cookies
currently being used on a page or search for a specific cookie, monitor
any existing cookies on the page, and add or delete cookies at will.
With Firecookie you can check out information on any cookie, such as the
name, value, domain, expire date, or path. You can also use the
extension to change your settings for accepting or denying cookies
straight from within Firebug.</p>
Pixel Perfect</h2>
Firebug can provide more than just developer functionality. If you're a
designer, check out Pixel Perfect, a Firebug extension that allows you
to overlay a semi-transparent image, or mockup, of your page design. Tou
can then use Firebug to line up every element on your page with the
overlay. Pixel Perfect is still an experimental add-on, but in my tests
I found it to be perfectly stable.</p>
If you like the features of Pixel Perfect and would like to use it in a
cross-browser setting, check out OverlayComp, an open source script that
accomplishes much of the same functionality, albeit with lesser
convenience.</p>
Rainbow for Firebug</h2>
Firebug's default script panel can feel somewhat like working in a plain
text file at points. To get around this, check out another experimental
add-on. Rainbow for Firebug adds syntax highlighting to the script
panel, displaying intuitive, color-coded text for variables, objects,
functions, and more. There are alternatives to the default highlighting
colors -- to see more coloring options, or possibly create your own,
check out the Rainbow for Firebug homepage.</p>
Rainbow utilizes the parser from CodeMirror.</p>
All the aforementioned extensions work best with Firefox 3 and some form
of Firebug 1.2. Rainbow in particular requires Firebug 1.2 -- if it's
installed alongside an older version of Firebug, that version will cease
to function.</p>
Firebug by itself is an immense asset to any Web developer, but if you
extend it with any of these add-ons, you'll have a tool that can reduce
the time it takes you to implement and debug your sites.</p>


Easy blogging with Pivot
Tue, 18 Sep 2007 00:00:00 +0000

    This Entry is Archived!</h4>
    This article was originally published on September 18, 2007
(9:00:00 AM) over at Linux.com. A still-breathing version of the
article can be found at Linux.com</a>.</p>
</div>
The GPL-licensed Pivot blogging software stands out among blogging
applications because it requires no database, no extra libraries, and
minimal installation effort. While it's still in an early stage of
development, its flexibilty and the ease with which it can be set up
make it ideal for those new to maintaining their own blogging Web sites.</p>
To use Pivot, you need a server that's running PHP 4.1.0 or higher.
Unlike WordPress or Movable Type, Pivot requires no MySQL database; it
stores most of its data within XML files. Pivot also strives to use no
extra libraries so as to be available and usable by as many people as
possible.</p>
The simplest way to install Pivot is by using Pivot Setup. Download the
setup zip file, unzip it, and open the resulting pivot-setup.php script
in a text editor. Set your password and save the file -- nothing else is
needed. Upload the script to your blog directory, which must have
permission (chmod) settings of 777. Open the direct link to the script
in a browser. If your server is ill-equipped, or needs something
changed, Pivot should alert you first thing, as it checks before
anything in the script is run. If you're good to go, just follow the
instructions for an easy and successful installation. Pivot should
automatically pull the files it needs from SourceForge.net and set
itself up for you.</p>
If for some reason you can't get the aforementioned method to work, you
can set up Pivot manually by downloading the entire package (1.40.3
Dreadwind is the latest version as of this article), uploading it to a
Web server, and configuring it to your needs. The project provides a
pretty well-written guide to the manual installation process.</p>
Pivot has many of the features you'll find in other blog systems. Users
can register and log in to an account, reply to a blog post, or reply to
another commenter through use of a threaded comment system. Pinging and
trackback capabilities are included, as well as a simple search that
indexes all blog posts. Since it's still young, Pivot lacks the number
of free templates that WordPress and Movable Type have, but there is a
growing archive at PivotStyles.</p>
Pivot supplies RSS feeds without any extra work, though you can only get
a feed for all posts, not just, say, one category. RSS feeds can be made
available in either RSS or Atom format.</p>
You can find a few plugins and extensions for Pivot, but as with some of
the documentation, they can be hard to locate. A good list of the basic
ones can be found in the Pivot Documentation.</p>
Drawbacks</h2>
Pivot is, of course, still young and in development, and with that there
are bound to be a few drawbacks. There's currently no support for any
form of a static page, which restricts users to just writing the blog --
any other pages must be created by hand. Some users within the
community, however, seem to have found ways around the issue. Getting
technical support can be difficult at times, as there's really no
designated support portion of the project. There is an active community,
as well as a recently started Pivot Documentation Project that helps to
alleviate some of the problems.</p>
Another issue is that recently Pivot's servers seem to have gone through
long bouts of downtime, which makes getting any support virtually
impossible.</p>
If you're looking for a lightweight blog application, Pivot may just fit
your bill. It has by far the easiest installation I have encountered for
a piece of blogging software, and it offers much of the functionality
and usability that most other blogging applications have. If you're
running a high-traffic site, you probably want to look instead at a more
traditional blog that uses a database back end, as using XML files to
store data in that situation may put too much of a load on your server.
For a smaller site, though, Pivot's definitely worth a look at.</p>


Keep users informed with PHPList
Tue, 31 Jul 2007 00:00:00 +0000

    This Entry is Archived!</h4>
    This article was originally published on July 31, 2007
(9:00:00 AM) over at Linux.com. A still-breathing version of the
article can be found at Linux.com</a>.</p>
</div>
If you've ever considered throwing together a mailing list to keep the
members of your group, project, or organization informed, you'd be
hard-pressed to find a better application for that purpose than PHPList,
a free and open source newsletter manager.</p>
PHPList is a Web-based application written in PHP, and relies on MySQL
databases for storing information. If you're leery of setting up PHP,
MySQL, and a Web server, you can opt to pay for a hosting package with a
service that offers PHPList preinstalled and configured, such as Host
Color or SiteGround.</p>
However, setting up PHPList isn't that difficult. You can download the
software as either a ZIP or a tarball, depending on your needs, and
basic documentation is included within the downloadable PHPList package.
If that doesn't cover your needs, there are other places to turn, such
as the more extensive online documentation or the PHPList forums. Make
sure you have a Web server and PHP installed, and a MySQL database to
throw all your data in. Depending on how your site is hosted, you may
have a basic database already set up -- check with your provider to make
sure.</p>
Once the prerequisites are in place, simply download and unpackage the
contents of the archive. Edit the PHPList config.php file and make sure
all the variables --username, password, database ID, and default
language -- are set. The configuration file is pretty well documented
with comments concerning what each option is. Save the file, then open
the PHPList installation page (www.siteaddress.com/lists/admin/) in a
browser. The installation procedure asks for some general configuration
settings, such as whether to offer RSS feeds with your lists.</p>
Once the software is installed, you can tailor your signup page to your
needs. PHPList offers many different options for obtaining information
from users at signup, which can then be used in the mailing process. For
instance, you can ask for users' country of origin, and then down the
road, if you'd like to send a newsletter to all users from a particular
country, it's a snap -- that data is already stored.</p>
Integrating PHPList signup and address management pages into a Web
site's existing design is simple, since PHPList templates are fully
customizable. You can even apply different templates to different
messages and signup pages.</p>
Using the Free PDF Library, PHPList can automatically create and attach
messages as PDF files to ensure that formatting and graphics are kept
intact.</p>
PHPList lets you track the messages you send, so you can tell how many
of your users actually opened a message. You can also specify a certain
time or date for a newsletter to be sent, and PHPList will wait until
that moment to send it.</p>
The software includes some email bouncing tools that try to prune unused
and nonexistent email addresses. In my time using the program, it
managed to kick out 95% of the fake addresses I tossed in there. There
are options for some advanced bounce handling tools, which help
distinguish between situations such as "this email address has never
existed" and "this email address may be experiencing some slight
downtime."</p>
Users too can control PHPList's behavior. For example, at any time a
user can choose to opt out of receiving a newsletter. Users choose to
receive messages in full HTML or text-only mode. They can also change
almost all of their information on record -- name, location, interests,
even their email addresses.</p>
I've found very few disadvantages with PHPList. Some could make the
argument that users should be able to reply to any of the newsletters,
but then you're getting more into the territory of Mailman, which is an
actual email discussion application, somewhat different from PHPList. I
found the bounce handling a bit confusing at first, but looking at the
different documentation resources proved to be a help. There's a slew of
FAQs and documentation, as well as an entire community of people to ask
for support. After exhausting those resources, you can resort to the
paid support from tincan, the product's sponsor.</p>
All in all, PHPList is a versatile and easy-to-use application for
managing newsletters and mailing lists.</p>


Simple polling with LimeSurvey
Tue, 05 Jun 2007 00:00:00 +0000

    This Entry is Archived!</h4>
    This article was originally published on June 05, 2007
(8:00:00 AM) over at Linux.com. A still-breathing version of the
article can be found at Linux.com</a>.</p>
</div>
Setting up a survey on your Web site can be a simple task with
LimeSurvey, a flexible and easy to set up tool for conducting a survey.</p>
The LimeSurvey project began in 2003 as PHPSurveyor. Last month the
project was renamed LimeSurvey in order to make licensing easier by not
including PHP in the title.</p>
You can try a demo of LimeSurvey or download the full application.</p>
A typical LimeSurvey installation requires a server with PHP installed,
as well as a MySQL database to store the data in. If you're wary of
going setting it up yourself on a server, many hosting companies offer
LimeSurvey installations, such as Hummingbird Hosting or UCHosting. Both
of these hosting services allow users to set up a survey script with
minimal work.</p>
To manually set up LimeSurvey, you must have a server that has PHP 4.2
or later installed, along with the mbstring (Multibyte String Functions)
library, and a MySQL (4.1 or later) database for LimeSurvey to store
data in. To take advantage of LimeSurvey's token system, you need to
have the LDAP Library installed in PHP. The script itself takes up about
10MB of disk space.</p>
Installing LimeSurvey just requires uploading the survey software to a
directory of your choice, editing the project's config.php file and
making sure all the necessary fields -- such as database name, location,
and email settings -- are filled in. Once they're set, run a simple
installation script by navigating to it with your Web browser.</p>
If you're familiar with HTML, you can easily create custom templates to
give your surveys a similar look and feel to the rest of your site. If
you're not, there is a template editor function built in to LimeSurvey
that allows you to create a custom template for your surveys.</p>
LimeSurvey's flexibility is its main driving point. The software is
offered in a total of 19 different languages. With LimeSurvey, you can
have out an unlimited number of surveys at any time. You can set
different surveys to be public or private, and allow users to take a
survey multiple times or only once via a "post once" token. LimeSurvey
supports many different question types, ranging from the simple Yes or
No variety to choices such as 10-point scales, open-ended answers, or
dropdown choices.</p>
With most of the question selections, you can opt to include a field for
users to describe why they chose the answer they did. You can branch a
survey out by setting certain choices and questions to appear in
response to earlier decisions. There is no limit to the number of
questions you can include in a survey, and the program also offers ways
to automatically email, notify, or invite users to a survey, or to
remind them to take it if they've not already done so.</p>
You can view your data and results from within LimeSurvey, or you can
back up the data by exporting it to simple text, CSV, or Excel files.
Exporting to an XML format is not yet available, though it is listed on
the road map for LimeSurvey version 2.</p>
Users can choose to stop the survey and continue at a later time,
keeping their data intact and ready upon their return.</p>
My testing didn't uncover any large faults in the software, but if you
need it, you can get support in a number of ways. The project provides
an online documentation wiki. You can visit the project's online forum
to ask a question, where most likely a developer or knowledgeable user
can help you out. You can also visit IRC channel #limesurvey on
irc.freenode.net, which many users frequent, and many are willing to
help out. If your need for support is more pressing, you can email a
member of the project, but if you do this they ask that you donate a
small sum to the project.</p>
If you're in the market for a survey tool, LimeSurvey is one of the best
choices around. It has excellent usability and support, and when you
take into consideration that some hosting companies offer packages with
it pre-installed, as well as it's large list of features, it becomes
apparent that LimeSurvey is quite possibly the most flexible, easy to
use choice to make.</p>


Review: Moneydance 2007
Wed, 02 May 2007 00:00:00 +0000

    This Entry is Archived!</h4>
    This article was originally published on May 02, 2007 (8:00:00
AM) over at Linux.com. A still-breathing version of the article can
be found at Linux.com</a>.</p>
</div>
Linux users have a multitude of choices for personal finance
applications, including GnuCash, KMyMoney, Kapital, and others, not to
mention being able to run Quicken under WINE. One good alternative that
runs on multiple operating systems and manages finances with ease is
Moneydance.</p>
Moneydance isn't free, but it does run on Windows, Mac OS X, Linux,
Unix, and Solaris, due to it being coded in Java. It offers all the
basic features most users need, such as checkbook balancing, basic
exchange rates, and easy importing from Quicken, while also offering
some more interesting and useful tools to judge the state of your
finances, such as graphs that can indicate your net worth over a period
of time, and easy reminder setups to make sure you're almost always in
control.</p>
You can download a free trial version of the software that's limited to
100 transactions, with some of the features disabled. The Linux
downloads come in two versions: with or without Java prepackaged. If you
want to unlock the software's full potential, you'll need to purchase it
for $30.</p>
To install Moneydance in Linux, open a terminal window, navigate to the
directory where you downloaded Moneydance, and run
./moneydance_linux_x86.sh if you already have Java installed, and
./moneydance_linux_x86wj.sh if you downloaded the version bundled with
Java. The Java-less installation checks to make sure you have Java
installed before going through with the installation, and if not will
automatically download Java for you.</p>
The first time you run the program, you're presented with three options:
you can create a new file to record all your transactions in, open an
existing file, or import a file in QIF, OFX, or OFC format. When you
create a new file, Moneydance uses its own format, with the extension of
.md. If you import a QIF file from Quicken and save your data, it takes
the Moneydance format. Upon my first attempt at importing a QIF file, I
found that Moneydance duplicated some of my prior transactions from
Quicken. A quick visit to their forum explained an easy workaround. I
had to set up each of my accounts, checking and credit card, manually,
and then import the information from the QIF. This wasn't too big of an
issue, and the problem seems to stem from how much data is actually
available from the imported files. In short, filetypes won't always play
nice with each other, but it can be made to work.</p>
After you create a file, you choose what your primary currency is.
Moneydance offers 44 different choices. Next, choose whether you want to
run in a standard or minimal account set. A standard account set
includes checking accounts, loan accounts, liability accounts, as well
as general income and expense accounts. Minimal account sets include
just checking and savings, and leave you to import your data from other
financial management programs.</p>
Setting up accounts is pretty simple. You need to enter standard bank
account information, such as the account and routing numbers, for
Moneydance's check printing and online banking functions. If you're
setting up a credit card account, you can enter a card's annual
percentage rate, while liability accounts ask for your initial
liability.</p>
Once your data is set up, you can begin entering transactions. If you're
security-conscious, you can encrypt your data with a choice of either
56-bit DES or the somewhat slower Triple DES. If you ever need to get
your information out of Moneydance, you can export it to .QIF or
Moneydance XML files.</p>
If you have finances in multiple currencies, you can view the current
exchange rates in other countries. This is updated via a list from
Moneydance, as long as you have a current Internet connection. If you
have multiple accounts set up, Moneydance will also automatically
calculate your net worth. If you own stocks, you can grab an extension
that will automatically synchronize with the latest Yahoo! stock lists.
You can set reminders that will automatically alert you of an upcoming
transaction or bill. The interface to the program is intuitive -- in
just minutes I had all of my information entered.</p>
Moneydance supports online banking, but in order to get it set up you
have to do some legwork. First and foremost, you need to make sure that
your bank supports direct OFX connections. Setting up an online banking
account or bill payment is easy -- for either, go into the transaction
register of your account, and in the top left you should see a tab for
online transactions. Drop the tab down and click on either "Set up
online bill payment" or "set up online banking," depending on your
needs. Moneydance works with a large list of banks; if yours isn't on
the list, you can manually set up an account after you get your bank's
OFX ID and URL. After you've configured your bank, you need to input
your user ID and PIN that your bank gives you.</p>
If you have some form of Web-based banking with your bank, Moneydance
can import your settings and transactions from there, provided the bank
supports OFX. I was not able to import the settings from the Web site
successfully, but I was able to obtain a downloadable file (.OFX) from
my bank, which Moneydance accepted with ease.</p>
Moneydance also offers advanced budgeting and monitoring tools for your
finances. You can have up to 10 budgets going simultaneously, and
Moneydance can even calculate an initial budget based on your previous
transactions. To create a new budget, open the Budget manager from the
dropdown menu located at the top of the program. If you'd like to review
your budget, select View -> Show Budget Status in the top menu, and
you'll be presented with a graph in the top of the main toolbar. You can
also create a budget report for a specific time period, and Moneydance
will show you how over or under budget you were.</p>
Moneydance can manage loans easily. You can set up a wide variety of
loan options, varying the APR, the amount of payments per year, and the
total amount of payments you'll be making. The software automatically
calculates your monthly payment, but you can set a specific payment as
well.</p>
Moneydance will print on pre-printed checks, but will only print the
date, amount, and the payee. It can't print your routing and account
numbers, but you can opt to print your address. Printing checks itself
is simple -- you go through the register and mark whatever transactions
you intend to be checks as "to be printed," then select the Actions
dropdown in your transaction window, and set it to print your checks.
Here Moneydance worked out well for me -- I don't write checks a lot,
but for setting up mass bill payments it was easier to use the software
than to write each individual check out.</p>
Moneydance also offers its core API so that users can develop their own
extensions through Python and Jython. It includes sample code, necessary
libraries, and an ANT build file to allow compiling and signing of
extensions. The project's developer page also includes sample
extensions, as well as links to a mailing list for Moneydance
development and common issue resolving. When in Moneydance itself, you
can obtain a list of available extensions via an Internet connection
from the Extensions menu in the top bar, or by clicking the "Check for
new updates/extensions" link below all your account information. An
extension that I found particularly useful was one that imports Yahoo!
stock quotes.</p>
If you need support for anything Moneydance-related, you have a couple
of options. Read the User Guide first, as many times it can answer your
question right off the bat. You can also try the online support forum,
with topics ranging from installation and configuration to Moneydance
development, and even general finance talk. There is also a mailing
list, as well as a Yahoo! discussion group. For matters of a more
private nature, the company offers email support.</p>
Of course, when you first find that you need help, you can always turn
to the Help section of Moneydance itself -- 16 chapters of tips, tricks,
and tutorials ranging from simple transaction input to a full-on guide
to configuring your online banking experience.</p>
Moneydance isn't without its drawbacks, one chiefly being that it's not
free software. As a personal finance application, though, Moneydance is
worth checking out. Its intuitive interface and easy setup should be a
welcome choice for any new Linux users looking for personal finance
software, and the ability to develop extensions may attract seasoned
users looking to get the most out of their experience.</p>


Review: Dreamlinux 2.2
Tue, 27 Mar 2007 00:00:00 +0000

    This Entry is Archived!</h4>
    This article was originally published on March 27, 2007
(8:00:00 AM) over at Linux.com. A still-breathing version of the
article can be found at Linux.com</a>.
    </p>
</div>
When it comes to choosing a Linux distribution, people tend to stick
with the major players, such as Ubuntu, SUSE, or Fedora. However, every
once in a while a distro comes along that offers a look at Linux in a
new and fun way. One such distribution is Dreamlinux, a Morphix-based
implementation of Linux that can be run from a single CD or installed on
a hard drive. Dreamlinux 2.2 aims to offer a full range of desktop
applications while providing a wealth of multimedia tools for easy
production of professional-grade media.</p>
Dreamlinux installs easily. For a basic Dreamlinux installation, you'll
want to have at least 128MB of RAM, 3GB of free space, and a processor
that runs at at least 500MHz. Depending on your hardware, you may have
to edit your BIOS settings to force a boot from CD. Dreamlinux should
automatically detect all the hardware, but if for some reason it cannot,
it will present a list of more basic options to get started, and you can
tune and set up the rest upon installation. During the installation,
Dreamlinux prompts you to select English or Portuguese as your language
of choice, but you can configure it to install with a different
language.</p>
Once the system is up and running, you have two options: you can
continue running with a live CD, or you can do a full installation. If
you plan to just try out Dreamlinux, the live CD offers an excellent
look at the system and can guide you through much of how it works, and
lets you store data on a USB storage device.</p>
If you want the entire experience, a full installation is recommended,
especially if you intend to work with the XGL 3-D interface, which takes
advantage of newer graphics cards to produce some great graphical
features for the X Window System. XGL works only when the distribution
is installed on the hard drive. A function within the Control Panel,
aptly titled HD Install, handles the hard drive installation.</p>
Dreamlinux runs with Xfce as the default window manager, and it is full
of style cues from the Mac OS X environment, the most notable nod being
the Application Panel, which is handled by an independent version of
Enlightenment's Engage. The distro comes with a simple set of
applications suited for the average user, including OpenOffice.org
2.0.4, Firefox 1.5, Icedove (unbranded Thunderbird) as an email client,
and aMSN 0.97 for instant messaging.</p>
Dreamlinux has excellent support for multimedia, in terms of both
creating and viewing. It comes pre-installed with XMMS for playing
music, Grip for playing and reading CDs, Audacity for recording, Kino
for editing video, Blender for modeling, and GimpShop for basic
graphical work. In terms of multimedia support, it comes ready and set
up with all the necessary codecs to play MP3s and DVDs. All of these
applications make Dreamlinux a good choice for a multimedia system.</p>
While Dreamlinux shares many likenesses with other modern Linux
distributions, it has a few tools of its own that stand out -- most
notably Mkdistro, a collection of four shell scripts for building and
remastering distribution ISOs. MKdistro was developed by Nelson Gomes da
Silveira, one of the cofounders of the Dreamlinux project, with the
intent of letting users with any level of technical knowledge edit,
design, and create a Linux distro suited specifically for themselves.
This is likely the reason why the developers chose to adopt a
Morphix-like philosophy -- that is, aiming to make the system as modular
and changeable for the end user as possible.</p>
Some restlessness</h2>
While much of the software works like a dream, not all is perfect.
Dreamlinux is still relatively new, and as a result its community is
still in its own developing stage. The distribution's developers are
Brazilian, and the community seems a bit divided due to a language
barrier.</p>
In using the software, I ran into some small hindrances. Upon first
running the system, Internet connections are not automatically
configured, which can throw some new users off. A graphical interface
guides you through the connection process, but it would be more
efficient to have Internet connectivity automatically configured, and
keep the GUI around just to allow users to make modifications as
necessary. aMSN also had difficulty starting up correctly at points, and
one time refused to even start at all. I downloaded Gaim and used it as
my instant messaging client instead with no problems.</p>
Nevertheless, the distribution itself looks good and functions well. The
Mkdistro tool will be useful for users who want complete control of
their systems, and the overall ease of installation and use Dreamlinux
offers is good enough that the average user can download and install the
distribution and jump right in.</p>


Easy discussions with Simple Machines Forums
Wed, 17 Jan 2007 00:00:00 +0000

    This Entry is Archived!</h4>
    This article was originally published on January 17, 2007
(8:00:00 AM) over at Linux.com. A still-breathing version of the
article can be found at Linux.com</a>.
    </p>
</div>
Many Web sites host discussion boards to bring together people with
common interests, to help diagnose problems, or to gain a following for
a project. Popular discussion board software includes phpBB, Invision
Power Board, and, on the low end, PunBB. One system that is growing in
popularity is Simple Machines Forum (SMF), which offers extended
features while keeping to a minimalistic approach.</p>
SMF forked from a project called YaBB SE to add advanced templating to
the original software. It is free (as in beer) and distributed under its
own license. It claims to have minimal server impact while providing the
features and abilities that larger forum systems carry around. The
software itself is written in PHP, and uses MySQL databases to store
user profiles, post counts, and so on. Its use of server-side includes
also allows the forum system to be easily integrated into Web sites.</p>
SMF is lightweight, easy to use, but still full of features. Besides
basic community features, such as private messaging, user icons, and
individual profiles, SMF has a unique package management system that
allows board administrators to update or install modifications with a
few clicks. With many other forum systems, the process involves manually
editing key files and reuploading. Security issues are not prevalent,
but when they pop up, the developers are quick to nip the issues in the
bud.</p>
The software logs most major functions, such as an administrator
changing a template piece or reordering a page, with the time and the IP
address under which they were done. Administration may be "time locked,"
wherein the action is restricted to only so many tries within a certain
time period. Login attempts to regular user accounts from any one IP
address can be time locked and limited too.</p>
Simple Machines offers administrators several different courses of
action for dealing with troublesome users. The system allows for three
different types of bans: a full ban, in which the user is kicked off the
board; a "no-post ban," which allows the user to view the board and read
topics, but not to post replies; or a timed ban, where a user can be
banned for anywhere from an hour to days, or longer.</p>
Simple Machines boards support Wireless Application Protocol (WAP) as
well. When someone accesses a page using a WAP, WAP2, or I-mode
protocol, the software detects that and displays a page that's reduced
in size, without unnecessary elements such as borders, larger graphics,
or other media. You can view replies, make replies, and browse; however,
in my experience, posting new messages and the log in/out functions
don't always function properly in a WAP setting. They work fine in
WAP2/I-mode, though, which are both essentially equivalent to the WAP
environment.</p>
All in all, Simple Machines Forums works well. The system can cater to a
large or small community. It's versatile, secure, and easy to set up. If
you need help, you can read a list of Frequently Asked Questions at the
software's Web site, and communicate with an entire community of other
Simple Machines users that can help and answer questions. An online
manual gives an overview of almost every function you could need. With
helpful developers, a secure system, and tons of possibilities, Simple
Machines Forums is a good choice for a community setup.</p>


KToon: Simple 2D animation
Thu, 14 Sep 2006 00:00:00 +0000

    This Entry is Archived!</h4>
    This article was originally published on September 14, 2006
(8:00:00 AM) over at Linux.com. A still-breathing version of the
article (broken links intact) can be found at Linux.com</a>.
    </p>
</div>
If you are running Mac OS X or Microsoft Windows, you have access to
many different animation applications, ranging from Adobe Flash to Anime
Studio. That is not so for Linux. While many think of animation in Linux
as a lost cause, there are alternatives. The relatively new KToon calls
itself "the open source animation revolution." KToon has a small
learning curve and an intuitive interface, making it an excellent choice
for simple animation within Linux.</p>
KToon was designed for animators by the animators at Toonka. To use
KToon, you need a CPU speed of 800MHz or more, at least 256MB of RAM,
and 5MB of free space, as well as Qt 4.1.1 or higher. If you really want
to create, those numbers should probably be higher. I have found that a
processor that is faster than 1GHz with at least 512MB of RAM does well.</p>
With a recent release, you can now burn an ISO image of KToon to a CD
for a portable live version of KToon that can be booted on any computer.
This is a useful method for trying the program if you are not running
Linux.</p>
Ktoon is still in its early stages, so it is not the most functional
piece of animation software there is yet, but it is excellent for simple
animations. It has the beginnings of great tools for animation, such as
the ability to create multiple brushes for complex animations, as well
as the ability to create keyframes. These serve as tools for not only
organization, but also as a means to help out in the animation process.
Ktoon has a feature called "onion paper," in which the frame that is
being modified can be transparent, allowing the animator to see the same
general outline that the previous frame had, which in turn allows subtle
changes between frames to be created with less time and effort. Most
commands are easy to find and experiment with.</p>
Disadvantages</h2>
KToon also has its share of bugs that need to be ironed out. For
instance, the recommended way to start the program requires opening a
terminal window, getting to the directory where KToon is installed, and
manually initiating it there. If KToon is not started in this manner,
there is a possibility that you will not be able to save any of your
work.</p>
KToon comes with the ability to store to a .SWF file type, otherwise
known as Flash. However, to do so, it really just exports the animation
in bitmap format, frame by frame, which makes for a very large file. If
this is changed in later versions, it might make the program more
popular, since there are not many viable Flash alternatives in the Linux
environment.</p>
I have yet to have KToon crash on me, but other users of the program
have lost work due to program crashes. Save your work frequently.</p>
The advantages that KToon has to offer do outweigh its bugs, for the
most part. It is an excellent tool for simple 2D animation, and it is
easy enough to get into. The interface is intuitive enough that
newcomers can pick it up and work it without too much trouble, and it is
a pretty lightweight package.</p>
KToon also has an informative documentation portal, with information
relating to both use and development of the program. The information is
presented in a variety of different languages, and includes tutorials on
making your first animation, creating different themes for KToon,
general tips, and frequently asked questions.</p>
KToon is not without competition. The open source vector animation
program Synfig is in an early stage too. It takes after the animation
studio formerly known as Moho, now known as Anime Studio. There is also
the program known as Plastic Animation Paper; however, it is not free.
KToon may see a bit more of a faster development cycle, due to its
backing by Colciencias, the Colombian institute for the Development of
Science and Technology, as well as ParqueSoft, a technological
organization that gives backing to startup technology groups.</p>
KToon is free software under the GPL. While today it runs only on Linux,
the developers have stated that they will develop versions for Windows
and Mac OS X in the future. The community behind KToon is helpful. You
can find discussion boards as well as fairly helpful tutorials and
support, such as frequently asked questions and mailing lists, on the
project's home page.</p>


Kino makes video editing simple
Fri, 19 Aug 2005 00:00:00 +0000

    This Entry is Archived!</h4>
    This article was originally published on August 19, 2005 over
at the (now defunct) Newsforge.com. A still-breathing version of the
article (broken links intact) can be found at Linux.com</a>.
    </p>
</div>
The Linux enviroment offers two major packages for creating and
editing digital media. Cinelerra is a media powerhouse, while Kino
works well for beginners who need to create simple digital video. It's
a speedy editor, lightweight, and it seldom crashes. Its simplicity,
ease of use, and small learning curve make it an excellent alternative
for creating and editing digital media in the Linux enviroment.
Kino does not require as much powerful hardware as Cinelerra; you can
get good results with about 128MB of memory and a 1GHz processor.
You'll need a bit of disk space for digital video editing -- about
40GB should do just fine.</p>
Kino takes video to the disk in AVI and raw DV format. When you finish
editing a video, Kino lets you export it in a number of formats, such as
MPEG and MP3. Kino also features incredible support for IEEE-1394,
otherwise known as FireWire, which allows it to communicate with
different video hardware, and also supports most USB drive input. Kino
has easy tools for filters, general effects, and video transition,
ranging from kaleidescope to a general background generator. Kino also
comes equipped with audio tools, such as filters and audio transitions,
which include useful "fade in/out" and "mix" features.</p>
The program is organized well, with a storyboard style view that allows
you to see each of your scenes in a mini pane. You can drag and drop to
rearrange frame order and movie flow. You can undo and redo changes up
to 99 times, so you can learn by making mistakes and correcting them.</p>
Kino's excellent "dvgrab" interface, the tool that allows you to capture
digital video to the disk, makes it ideal for importing digital media,
even if you're doing the majority of your editing with another digital
video editor.</p>
Kino's user interface is available in English, Danish, Swedish, French,
Spanish, and Czech. It provides online help for troubleshooting issues.</p>
Disadvantages</h2>
Despite its many pluses, Kino is a low-end video editor, best suited for
doing quick editing jobs or inputting digital feeds. Kino does not
support multiple layers or tracks of audio and video, which means that
it's not suitable for video work that requires complex audio and video
effects.</p>
For those using a video camera to record their work, be aware that you
will be able to connect via FireWire only if you're using a digital
video camcorder. A digital camera, meaning digital stills, will not
work, whether it has a FireWire interface or not.</p>
Fortunately, Kino's advantages outweigh its disadvantages. Even if your
project is a task of amazing proportions, Kino can be useful in one way
or another, especially for inputting digital media and outputting it to
a desired format. If you're a beginner, it provides an easy entrance
into the field of digital video on a Linux system.</p>
Kino is free software under the GPL. The community behind Kino is
helpful, too. You can find discussion boards, as well as excellent
tutorials and support, such as Frequently Asked Questions and User
Guides, on the project's home page.</p>


My Workstation OS: VidaLinux
Fri, 29 Apr 2005 00:00:00 +0000

    This Entry is Archived!</h4>
    This article was originally published on April 29, 2005 over
at the (now defunct) Newsforge.com. A still-breathing version of the
article (broken links intact) can be found at
Linux.com</a>.</p>
</div>
My computer is my life, but I'm fairly new to the world of Linux. I
started with SUSE Linux 9.1 Professional. It's a fairly nice and easy
system, but I wanted to try some other distributions, to see what I
liked and disliked. I wanted something that felt not too advanced, but
also not too limited. That's what I found in the VidaLinux operating
system (VLOS), the perfect combination of what I wanted.</p>
Many call VidaLinux a "simpler Gentoo." It uses many of Gentoo's
features, such as the Portage software distribution system, but also
manages to make it all seem less intimidating. For instance, it uses Red
Hat's Anaconda installation system. Anaconda is a graphical interface,
which many find easier than Gentoo's command-line installation. Vida's
system components also come prebuilt and ready for installation, whereas
Gentoo's installation requires everything to be built from the command
line, which intimidates some people.</p>
Some people have reported issues with Vida's networking and sound card
configuration. While the sound card wasn't an issue for me, networking
was. Thankfully, I was able to fix my problem easily by referring back
to the MadPenguin article that introduced me to Vida. After that little
escapade, I moved on to configuring my system.</p>
I use my computer for Web site management, helping out at sites such as
The Mega Man Network and Metroid HQ. In addition to sitting on IRC most
of the time, I tend to use AIM to contact some people. Vida comes set
with what I need to get the job done. Firefox, generally the ideal
browser for any Web designer, comes pre-installed, with many plug-ins
already set, like MPlayer and Java. The GIMP is a fine image
manipulation program, and works well for Web design. For music playing
purposes, the system offers Xine, a fine music application. It covers
chat too, with an easy installation of X-Chat and an included version of
GAIM. When I need to get a professional project done, I've got
OpenOffice.org right there. Vida's main window system is GNOME 2.8.0,
and the default icon set, with an uncanny similarity to Mac OS X's,
brings the desktop to life.</p>
VidaLinux runs well, and the Portage system makes it even more fun. The
Portage application itself is called Porthole, and it's pretty useful.
It allows users to choose new applications to install on their system,
as well as old ones to get rid of. Apparently, some people have had
issues with it suddenly shutting down on them, but that hasn't been an
issue for me. The Vida community itself is very helpful, and getting
support has been no problem.</p>
All in all, I thoroughly enjoy VidaLinux. It's a stable operating system
that caters to both advanced and beginning Linux users. What I need my
computer to do, it does. I can work on Web pages, listen to music, and
play my games with ease. The system itself is friendly, versatile, and
workable. I know my way around it, and I'll be sticking with it for
awhile.</p>

RYMC

Forgejo index.js woes

Connecting tokio-postgres over an SSH tunnel

Crates We Need</h2> There's really only two or three crates that we need to be dealing with here.</p>

UUIDv7 TypeIDs in Diesel

ORM-ish Diesel Helpers

Pagination in Async Diesel

Plant-Based Berlin Recommendations

Shop</h2> Veganz grocery store. It's easy to find - right off a large train station - and you can't miss it. Fun to walk through if you like seeing what other vegan options are available outside the USA.</li> </ul>

DriverKit, /Applications, and Quarantine

Debugging Broken Signed/Notarized Apps on macOS

Special Character Issues...?</h2> These are files used in showing what stage a game was played on. The app uses the filename as a key to display the appropriate image... and for whatever reason, the accented é</code> causes issues in signature verification.</p>

Cacao: Building macOS (and iOS) Apps in Rust

Cross-Platform GUI Framework</h3> My dream for a Rust GUI framework is simple:</p>

What Melee Gave Me

You Did Not EARN IT

Wobbling in Rust

Hey, listen! This is a Footgun.</h4> The docs do point out that you should not use this as a general try/catch mechanism. They're right.</strong></p>

Decoupling, or: where's my data?

So what happened here?</h2> If we try to trace this, a few things become apparent:</p> Couple launches in 2012, under four cofounders.</li>

Automatic Old Reddit Redirect Safari Extension

On Sign-In with Apple

One Last Ride

Vim, ALE, Docker, and Per-Project Linting

The Shell Script</h2> This is much simpler than you'd think! Somewhere in your project, edit and throw the following:</p>

Rust, Cargo, lcrypto/OpenSSL, Mac, and You

Dynamic Images in iOS Push Notification Extensions

Using a Custom JSONEncoder for Pandas and Numpy

Wrapping Up</h2> Now, returning and serializing Pandas and Numpy-specific data types should "just work"</em>. If you're the Django type, you could optionally subclass DjangoJSONEncoder</code> and apply the same approach with easy serialization of your model instances.</p>

My 2018 Reading List

2019</h2> Most of these titles were, sadly, only read in the last six months. I'm hoping to make a bigger push in 2019, with a wider range of topics to boot. If you have any recommendations for titles similar to the above, feel free to let me know!</p>

Forcing PNG for Twitter Profile Photos

Getting around the problem</h2> Before I explain how to fix this, there's a few things to note:</p>

Swipeable NSCollectionView

Just Give Me the Code...</h2> If you're the type who'd rather dig around in code,

Taking It Further</h2> While the above implements swiping, it's not... great </p>

Rust, or: What's the Deal with GUIs?

A Deep Dive into PL/v8

JavaScript in PostgreSQL: The Basics</h2> Creating a function using PL/v8 looks like any other PostgreSQL function, with the exception of a language specifier change. Take the (basic) example below: we're simply incrementing each int in an Array by 2, and returning it as pure JSON.</p>

RedNoise, a Django-centric WhiteNoise addon

Recording Live Audio Streams on iOS

We are the New Blue Collar

Where is Ryan now? (tl;dr: Quit myGengo)

Using Javascript to control the Nintendo Wii

Using the myGengo Translation API with Python

More Power to ExpressionEngine URLs

Please Excuse the Tone. :(</h4> I wrote this when I was younger and, arguably, an asshole (pardon my French). There may still be technical content of note in here, so I'm keeping it up, but please ignore the harsh and unnecessary tone.</p> </div>

Shop</h2>

Veganz grocery store.
It's easy to find - right off a large train station - and you can't miss it. Fun to walk through if you like seeing what other vegan options are available outside the USA.</li> </ul>

Wrapping Up</h2>
Now, returning and serializing Pandas and Numpy-specific data types should "just work"</em>. If you're the Django type, you could optionally subclass `DjangoJSONEncoder</code> and apply the same approach with easy serialization of your model instances.</p>`

2019</h2>
Most of these titles were, sadly, only read in the last six months. I'm hoping to make a bigger push in 2019, with a wider range of topics to boot. If you have any recommendations for titles similar to the above, feel free to let me know!</p>

Just Give Me the Code...</h2>
If you're the type who'd rather dig around in code,

Taking It Further</h2>
While the above implements swiping, it's not... great
</p>