Programs

Made this dude earlier this year when I had to make a TON of stub extension methods. It started out as a fairly standard-ish code generator; however, it has since transformed into a bit of a language extension.

I don't really feel like this dude is ready for distribution, so I'm not going to post the executable just yet.

Finally a program to allow the downloading of information directly into your brain-o-tubes. P.S. not really: I did absolutely no research about how people read; however, I took a speed reading course a while back, and this does a fair approximation of what was taught in the course.

Load up some text, set your reading speed, press start, and prepare for a word by word subliminal stream of info.

The text excerp above was taken from Robert Chambers' "The King In Yellow" made available by Project Gutenberg

Why did I make this? A week or so ago, I thought that it was about time that I make my learning go super nova; however, like most of my good intentions, I instead made a cop-out program and called it good.

"MOOOOAAAAR SPEED!" Bellowed the barbarian chieftain. I flinched, as did my companions, at the guttural cry. We were already pushed to our limits, and now the chief wanted more? How could we? The structure upon which we worked was now a towering Goliath, a complex machine where inefficiency could easily hide anywhere. To root it out would take time, and as I looked up at the barbarian chieftain and saw him menacingly sharpening his blade, I knew that time was a resource that we did not have.

Hope, at the moment, seemed distant; an unrealizable dream.

That's when all of the sudden, a came from and . At first we , but then we saw that was ! We couldn't stop screaming as   . I until , but to no avail, for never stopped biscuits. I because you know? Then        and I was all like " " .

The moral of the story? Sudden cravings for "MOOOOAAAAR SPEED!" may be satisfied in part by use of CillyRabyte.exe.

Side effects include, but are not limited to:

• Sudden realizations of optimization opportunities.
• Ridiculous data throughput and/or FPS increases.

CillyRabyte.exe is not a substitute for ingenuity and/or experience. CillyRabyte.exe is a powerful program, please use responsibly. Ask your doctor if CillyRabyte.exe is right for you.

What's that you say? You want an actual feature list? Fine...I was done anyway.

• Intelligently avoids instrumentation of methods that only propagate to internal/private methods, so only the most relevant methods are profiled.
• Results are show in call tree format, showing percentage of total processing and parent processing etc., enabling one to easily find bottlenecks.
• Additionally, there is a processing time over time view for every call, allowing for the locating of spikes in processing.
• A number of settings are exposed to the user to allow for profile detail vs profile overhead tuning.
• As a static instrumentation profiler, this dude is able to profile CIL dlls (Mono CIL supported)
• It works with the free version of Unity3D. I don't mean that it technically works with Unity3D. I mean that it stone cold, on complex/well coded projects, actually collects actionable data while maintaining a frame rate that is entirely playable. This is what I created the profiler for.

Wrote this dude when I was redesigning this website. I wanted a utility that would quickly and easily replicate changes made to my local solution to the server. I think the program may kick a little ass right now, but I don't think I'm quite ready to release it just yet.

The program is composed of three modes controlled by two different json configuration files. The modes are as follows:

• Mirror - Loads configuration from puppet_mirror.json in the working directory and replicates and transforms the directory structure of the current directory as specified within puppet_mirror.json to the destination server.
• MirrorChanges - Loads configuration from puppet_mirror.json in the working directory and begins monitoring the local working directory such that any changes in the directory will be quickly replicated on the destination server.
• Backup - Loads configuration from puppet_backup.json in the working directory and neatly transforms and compresses the directory as specified in puppet_backup.json

What I really like about this system is the awesomeness that is contained within the json files. Take this puppet_mirror.json file for example:

{
    "host_name" : "destinaction.com",
    "user_name" : "my_username",
    "home_directory" : "/home/",
    "private_key_filename" : "C:/my_private_key",
    "preserve_filenames" : [
        "logs",
        "tmp",
        "access-logs",
        "mail"
    ],
    "elements" : [
        {"filename" : "includes"},
        {"filename" : "tests"},
        
        {"filename" : "Application.php"},
        {"filename" : "execute_job.php"},
        
        {"filename" : "credentials-production.php", "target_filename" : "credentials.php"}
    ],
    "initilization_commands" : [
        "php execute_job.php Every5Minutes"
    ]
}

When running the program in Mirror mode, the program first asks for the passphrase to decrypt your private key, and then the awesome begins:

1. Enumerates all the files in your destination home directory.
2. Any enumerated file not contained within the list of "preserved_filenames" is recursively deleted on the destination server.
3. A local archive is made composed of all the files listed in "elements". Additionally, each element within this list may specify a specific regular expression pattern to only upload filenames conforming to specific rules. Furthermore, and this is the really good bit, you can specify a "target_filename" for files or directories so that the directory structure is modified in transfer to the destination server.
4. The local archive is transferred via SCP to the destination server.
5. The now transferred archive is then decompressed and the archive is deleted.
6. Each entry in "initilization_commands" is passed directly to the SSH stream, allowing for additional commands to be ran after upload to tidy up things.

When running the program in MirrorChanges mode, the program basically runs just like in Mirror mode, except no deletion takes place and only changes that occur while the program is running will be uploaded; however, all transformations defined within puppet_mirror.json will occur as though the files had been uploaded via Mirror mode.

The Backup mode I added to automate the process of backing up the project in an automated fashion that would be careful to not include credentials and/or other sensitive information.

A week or so ago I needed to convert a bunch of slides that were in a format readable only by an Android App. An hour or so later I had an instance of Android running in a virtual machine and a hackneyed screenshot utility that I threw together to rapidly take screenshots of a predefined region of my screen. Then there was a whole lot of clicking, but I eventually emerged victorious.

You probably don't need to convert a bunch of slides, but I thought I would post it anyway. Maybe you can use it to slay dragons or something?