I looked something like this in January, 2001

Advisor

Laboratory

Research

Selected Publications

• Execution Context Optimization for Disk Energy. J. Hom and U. Kremer. International Conference on Compilers, Architecture, and Synthesis for Embedded Systems, October 2008.
• An Execution Context Optimization Framework for Disk Energy. J. Hom. PhD thesis, Rutgers University, May 2008.
• Inter-program Optimisations for Disk Energy Reduction. J. Hom and U. Kremer. International Journal of Embedded Systems, 3(1/2):8-16, 2007.
• Inter-Program Optimizations for Conserving Disk Energy. J. Hom and U. Kremer. International Symposium on Low Power Electronics and Design, pages 335-338, August 2005. © ACM, 2005. This is the author's version of the work. It is posted here by permission of ACM for your personal use. Not for redistribution. The definitive version was published in Proceedings of the 2005 International Symposium on Low Power Electronics and Design.
• Code Transformations for Energy-Efficient Device Management. T. Heath, E. Pinheiro, J. Hom, U. Kremer, and R. Bianchini. IEEE Transactions on Computers, 53(8):974-987, August 2004.
• Inter-program Compilation for Disk Energy Reduction. J. Hom and U. Kremer. Power-Aware Computer Systems, volume 3164 of Lecture Notes in Computer Science, pages 13-25. Springer, 2004.
• Energy Management of Virtual Memory on Diskless Devices. J. Hom and U. Kremer. Compilers and Operating Systems for Low Power, pages 95-113. Kluwer Academic Publishers, 2003.

Miscellaneous

• The more we learn, the more we realize how little we know.
  R. Buckminster Fuller
  (1895-1983)
• "The Ten Secrets of Embedded Debugging"
  Embedded Systems Programming (10/04) Vol. 17, No. 10, P. 21; Schneider, Stan; Fraleigh, Lori

  Experience dictates 10 lessons that must be followed for successful debugging of embedded systems. The first lesson is that programmers must be familiar and proficient with a diverse array of tools that includes source-level debuggers, in-circuit emulators, data monitors, operating system monitors, profilers, memory testers, execution tracers, and coverage testers. Lesson 2 is to detect memory problems--classified as leaks, fragmentation, and corruption--early on, while lesson 3 demonstrates that code efficiency can only be maximized by understanding how the CPU is executing the code via performance profiling. The fourth lesson is to clearly indicate suspicious or potentially problematic code at the outset to avoid searching for it later, as well as to regularly scan for errors as a preventative measure; the fifth lesson is to reliably recreate the problem and then isolate it by keeping detailed logs of any changes noticed during testing; and the sixth lesson is to furnish a backwards-traceable record of the embedded system development process so that future problems will be understood as they crop up. Lesson 7 mandates the use of coverage testing to determine and confirm the thoroughness of the test suite, with the level of required testing dictated by the application. Lesson 8 is to test and scan for problems as you go to avoid much more costly and time-consuming end-cycle debugging, while lesson 9 is to use dynamic debugging tools such as operating-system monitors, data monitors, and profilers to analyze programs while they are in operation. The tenth and final lesson of successful debugging recommends that the coder refresh his perspective of a problem by taking time off, in order to prevent a close-mindedness that can set in during long debugging sessions.
  Click Here to View Full Article

• Making the World Better
• The Heat