Projects
Home - Projects - Kerberized NFS HOWTO - Donate Life - What's my IP? - Resume - Contact

Here is a list of projects that I have involved myself in at one point or another. This list is incomplete (indeed, you might find that a recurring theme on this page), but you might find it useful for getting an idea of things that I'm interested in. This is roughly sorted from most recent to most ancient.

Also, I apologize for the way this web page is formatted. I'm not a CSS guru; maybe one day I'll figure out how to constrain the width to something more readable. In the interim, I might recommend resizing your browser to a smaller window for better reading...

see also: my local Gitweb setup, my GitHub page, an old revision of this page.

• patchfork - fork of the excellent Pitchfork MPD client (January 2010; Linux, MPD, PHP, webdev, hate myself)
  
  When the original author of Pitchfork, Roger Bystrøm, disappeared from the Internet, I took over maintaining Pitchfork, since I absolutely love it. It was starting to bit rot, and was not compatible with newer versions of MPD. It now lives in my git repositories.
  
  Also, I hate PHP, JavaScript, and most everything about webdev.
  
  on the web: git.joshuawise.com/patchfork.git
  
  
• monitor wall - a 3x3 grid of monitors running Xdmx (October 2009; hardware, wood, Linux, X11, hack)
  
  Around when the 15-412 lab moved to the new Gates Building at CMU, the lab also acquird about 12 machines from the Wean 5207 cluster that was being upgraded. Along with the machines came their monitors, which connected by DVI, and curiously, could be detached from their mounts.
  
  Obviously, the correct course of action was to arrange nine of them in a 3x3 array, and run Xdmx on them.
  
  built in collaboration with Jacob Potter and Chris Lu
  images: xeyes, glxgears.
  
  
• e3lua - an Ext3 filesystem framework written in Lua (July 2009 - September 2009; Lua, Ext3, RAID, Linux; ~700 LOC)
  
  At some point during the e3tools effort, I discovered that I was going to have to write a lot of datastructure code, which is a task that I despise doing in C. I realized that I was going to keep a lot of tables around, and that I was going to need to do a lot of string manipulation if I wanted to write a small command line interface for my toolset. What better language for the task than Lua? I used the Lunary serialization toolkit to reformat the data that I read from disk. In the end, the library was capable of reading directories using customized "alternate read" parameters; it also provided a simple command line interface using readline to allow a user to explore the filesystem and determine how intact directory structures are.
  
  on the web: github/jwise/e3lua
  
  
• ambien - kernel extension for Mac OS X to prevent sleeping when clamshell is closed (June 2009; C++, kernel, OS X, ~100 LOC)
  
  When I bought my MacBook Pro 13", one of the problems that I found was that the system went to sleep automatically when I closed the lid (and there was nothing I could do to disable that behavior). This is probably fine for most use cases, but I usually keep multiple SSH sessions alive with substantial amounts of state while I carry around my laptop, and sleeping the laptop could result in my sessions timing out (or worse, my IP changing when I reobtain my lease!).
  
  You may be curious at the name; those knowledgeable in pharmaceuticals might note that Ambien actually is for helping one sleep. The name was derived from the original anti-sleep kext, "Insomnia"; Insomnia was unmaintained, closed-source, and would not allow the Mac to sleep even on requests from the Apple menu. Ambien, then, was written to resolve one's problems with Insomnia. (I know. The pun does kill.)
  
  on the web: Disk image with installer; compatible with both Leopard and Snow Leopard
  on the web: git.joshuawise.com/ambien.git
  
  
• exncall - call/cc implemented in C by copying the stack (May 2009; C, PL, setjmp, insane, hack, ~250 LOC)
• e3tools - an Ext3 filesystem framework specializing in "no-assumptions" recovery (May 2009 - August 2009; C, Ext3, RAID, Linux, ~2500 LOC)
  
  In mid-May, there was a gigantic data loss incident on a system that I administrate (mostly brought on by a series of mistakes). Since the machine contained a fair bit of data that I cared about, I decided to write some tools to determine how much of the filesystem was salvageable (the basic method was to determine what "looked bad", and try to look in alternate spots for the data). A significant amount of investigation was done with this toolset; it would be adaptable for other uses, but such adaptation would require writing a nontrivial amount of code. This project was superceded by e3lua.
  
  on the web: github/jwise/e3tools
  
  
• FireARM - a first attempt at a pipelined ARM-like core on a FPGA (December 2008 - March 2009; Verilog, CPU, ARM, ~2700 LOC)
  
  Really needs to be burned to the ground and redone using the knowledge gained in 18-447. A collaboration with Christopher Lu.
  
  
• snipe - C-like compiler written in SML from when I actually did know squat about compilers (written with Chris Lu) (September 2008 - December 2008; SML, compiler, x86, 15-411, ~4500 LOC)
• NetWatch - a "lights-on lights-out box" running in system management mode, including a VNC server (September 2008 - December 2008; C, SMM, x86, lwIP, ~6000 LOC)
  
  NetWatch is a System Management Mode (SMM) monitor for off-the-shelf x86 hardware. The project was written for 15-412 class credit in collaboration with Jacob Potter. As a continuation from my work at Google on smash!, we ported the 3c905 network driver from the Linux kernel, wrote a framework for running code in system management mode, wrote a keyboard emulator, wrote a VNC server, and countless other tidbits to make it all work together. The neat thing about NetWatch is that it works while the host operating system is running, even if the host doesn't have its network interface running.
  
  This project was a spiritual successor to smash!, which was a similar project that I worked on at Google. Thanks to Tim Hockin for helping to get me permission from Google to continue along the lines of the work I started there.
  
  on the web: github/jwise/netwatch
  on the web: git.joshuawise.com/netwatch.git
  on the web: NetWatch project blog
  on the web: presentation slides
  
  
• MandelFPGA - a fully pipelined realtime Mandelbrot set renderer on a Xilinx FPGA (December 2008 - March 2009; Verilog, math, ~500 LOC)
  
  Although the code style isn't great, I'm proud of this. This worked really well, and shows off the power of what an FPGA can do compared to a general purpose processor. A collaboration with Christopher Lu.
  
  on the web: Chris's writeup of the project. Well worth a read.
  
  
• xvmouse - small application to get "nice" mousekeys behavior on X11 (June 2008; C, X11, Linux, ~150 LOC)
  
  on the web: git.joshuawise.com/xvmouse.git
  
  
• sb16 driver for Pebbles - Sound Blaster 16 driver for my 15-410 Pebbles kernel (December 2007; C, systems, kernel, sound, ~400 LOC)
  
  This project was done when I was taking a break from work on the Project 4 that I was supposed to be writing (a memory-mapped filesystem). Ironically, it actually became a Project 4 for one semester when I started TAing.
  
  on the web: the presentation I gave introducing the project
  on the web: the handout I wrote documenting the card and project (I'm pretty proud of having written that; it was at least correct and clear enough for the majority of our students to successfully implement a Sound Blaster driver.)
  
  
• jwcc - small C-like compiler written in Lua targetting BlargCPU from when I didn't know squat about compilers (August 2007; Lua, compiler, BlargCPU, ~1200 LOC)
  
  It never worked very well; I ran into issues with register allocation that I never resolved. I maintain that Lua was probably a good language for hacking that out in, though. Maybe I'll come back to it some day.
  
  on the web: git.joshuawise.com/jwcc.git
  
  
• smash! - system management mode post mortem debugger (written for Google, Inc.). Precursor to NetWatch. (July 2007 - August 2007; C, SMM, x86, Linux, debugger, Google)
• maildir-archive - small utility to archive a Maildir INBOX by date (December 2006; C, Linux, Maildir, Dovecot, ~275 LOC)
  
  on the web: git.joshuawise.com/maildir-archive.git
  
  
• blargcpu - small RISC CPU designed to be implementable in hardware (with binutils port) (2005 - 2006; C, CPU, BlargCPU, ~1200 LOC)
• makepong - silly little trick to play pong on an oscilloscope using X-Y mode mapped to the red and green channels of a VGA port (late 2005; oscilloscope, C, Linux, SDL, ~350 LOC)
• glPresent - OpenGL presentation/slideshow rendering engine (December 2004; Linux, C++, OpenGL, GLUT, ~2000 LOC except it's C++ so it's inflated from class definitions)
  
  I had to give a presentation for some class (I think World History in high school), and doing online research in class was boring and frustrating since the high school's computers at the time were incredibly slow (and ran Netscape 4.51 or some such). So, I spent the time in class for working on the presentation writing a presentation layout engine. (It actually produced some nice looking output, rendered by OpenGL -- the only major issue was that the fonts were pretty bad.) The presentations were hardcoded into the source; there was no runtime configurability.
  
  on the web: glpresent.tar.gz
  screenshot: the only presentation I ever used it for. My presentation skills appeared not to be as strong back then.
  
  
• softfan - a small PWM controller for fans attached to the parallel port (...yeah) (October 2004; Linux, hardware, bit-banging, parallel port, ~150 LOC and a transistor)
  
  on the web: joshuawise.com/code/softfan
  
  
• debrick/hamcop - reverse engineered JTAG interface for HAMCOP companion chip (NAND controller) on iPAQ h2210 (September 2004; Linux, PXA250, iPAQ, JTAG, ARM, reverse-engineering, hardware, ~3000 LOC)
  
  on the web: handhelds.org CVS, module debrick/hamcop
  
  
• clang - Forth-like language intended for TI-83+. has functional interpreter, incomplete JIT for x86, incomplete TI-83+ port (mid-late 2004; Z80, assembly, C, clang, language, JIT, ~2000 LOC)
• fastjtag - Mechanism to reprogram the flash on a dead PXA250-based device in a novel fashion (January 2004; Linux, PXA250, ARM, JTAG, hardware, ~2200 LOC)
  
  The neat thing about this, anyway, was that it loaded the smallest possible stub on the PXA250 using boundary scan -- just enough to have the PXA wait for further instructions to be directly loaded into its instruction cache over JTAG. (Later versions didn't even need the boundary scanned bit, but were rather timing sensitive as to when the chip was reset.) This 'first stage' allowed for up to about 4K of code to be loaded in, which was enough to use the PXA250's debug registers to allow arbitrary memory reads and writes, and "burst" reads and writes to contiguous addresses. I can't remember the exact performance figures, but I seem to remember that it was at least an order of magnitude, if not two, better than boundary scanning an entire image in to flash.
  
  on the web: handhelds.org CVS, module debrick/fastjtag
  
  
• X-Plane Linux port - port of Laminar Research's X-Plane flight simulator to Linux (2003 - 2007; C, C++, CVS, OpenGL, X11, Linux, Laminar Research)
• ...and more...

		You are connected via IPv4.
confused?	confused?	confused?