now in ruby!
simple ruby application in a docker container for shipping logs to loggly. uses docker socket, 0 features.
hilarious little web app for using twilio to notify other teams of your deploys
lua in nginx, hydrates json objects. experiment in nginx + async lua socket work
i hate migrations, lets not. a very neat little state store. k/v storage using event sourcing and schema chaining (ex: rranshous/blog_tracker
container which archives tumblr image blogs. expirement in container as application abstraction
disk backed blob storage w/ meta data. was playing w/ TDD. foundation for rranshous/dropbox_clone
trying my hand at scraping email addresses from forum for random guy
slowly working on a dropbox api compatible clone to use locally. tdd'in it up.
mixin for giving objects ability to easily bind to sockets and send messages over the network. was playing w/ concurrent design (all Queue based)
mixin for adding dnssd advertising / finding / message passing.
stab at making some sort of ad-hoc fault tolerant storage thingy more an outline than a running program per-se atm
event driven web scraper. scrapes images from tumblr blogs. expirementation in contexts (rranshous/bubbles
). not horizontably scalable out of the box yet. working on identifying visually similar images. mongo backed, though that may change. pretty interesting project. part of it is based on the yet to be open sourced altalang/revent
library, sooo sry.
lib for building sets of inter-related event handlers. an expirement in sharing state and building event driven systems.
plugin based socket server. ended up implimenting a k/v store backed by memory -> disk -> s3. pretty fun. haven't used it in a while but it's in my back pocket as reference when i need to build the next thing.
holes i've attempted to fill
there are a lot of things i find myself doing all over the time. there are generally existing solutions (often in the python stdlib) but they are .. ugly or cumbersome. Some i've attempted to fill.
hole = state storage for evented apps in ruby
Eventstore (C# event sourcing store) client + library for creating stream workers
hole = capturing callback results
super simple web app which will return in a GET what you sent in a POST
hole = finding files / dirs on the disk by pattern
globs and shit all over the place (of course iterators)
hole = simple to use but powerful config system
can do type (prod / debug) and app type (sub configs) to dicts. config file format is same as the stdlib format. leans on rranshous/configsmash
hole = dependency injection
lib for building "contexts" basically a sharable namespace sort of thing. an expirement at this point. Makes the organization of code interesting. Also interesting uses (though not used here) for scoping requests and such things
tiny things of possible interest!
based of a learning python subreddit thread, a multiplayer implimentation of the the game war. My version turned out readable but I really liked the other implimentation in the thread. It's a great solution.
iterative draw something (the game) solver including basemetal wsgi app using an early version of the rranshous/bubbles
context library in the wsgi.py file. pretty interesting.
when i get my first SSD i wanted to test it's performance w/ a flat file k/v store. this is the result. i've ended up using it in a couple of things and improving it along the way. it pretty much works!
something like the linuxtuple server, but in python. uses asyncore with a custom protocol. server and client. was an experiment in tuple spaces
a lib for following chains of possibly existing attributes. very useful, would love to see this type of feature in the language (along w/ many other things).
there is plenty of other projects in various states public on github. trends include: events, genetic algs, using the disk, comments, python, web, distributed systems
other awesome people
Justin Barber is a god damn finisher. He can not help himself, it will get done and it will be solid.
Joe Freedom. He'll DSP the shit out of some .. other shit. Android? Embeded? He writes algorithms that melt faces.