Teaching computer architecture as a hands-on engineering course to approximately 250 MIT students per semester requires a large, dedicated teaching staff. This Spring, a shortened version of the course will be deployed on edX to a potentially far larger cohort of students, without additional teaching staff. To better support students, we have deployed developmental versions of three learner-sourcing systems to as many as 500 students. These systems harvest and organize students' collective knowledge about debugging and optimizing solutions. We plan to deploy and study the next iteration of these systems on edX this Spring.

6.002x is the first electronic circuits course to be taught online to tens of thousands of students. The goal of the 6.002x experiment was to explore ways to use computer assisted instruction to surpass the quality of traditional residential teaching. By providing superior on-line content delivery and assessment, we hope to both be able to educate people without access to education, and to improve residential education by allowing professors to focus on higher value tasks. We improved on the classroom experience in several ways. Students can actively monitor their current levels of mastery and to self-pace in response. They can identify and break through misconceptions before moving on to more advanced material. The massive scale of the classroom has participants on-line 24/7, allowing students to ask questions and receive peer answers in almost real-time. The platform allows for substantial data collection on testing, allowing us to incrementally and scientifically improve courses. Finally, the amount of effort that can be invested into a course is much greater when it can be amortized across tens of thousands. In order to achieve this, we had to overcome a number of challenges: finding mechanisms to allow automated grading, overcoming the lack of in-person interactions, and overcoming the lack of student access to laboratory equipment. The course was shown successful in both residential and mass-scale settings.

We present a middleware platform for assembling pervasive applications that demand fault-tolerance and adaptivity in distributed, dynamic environments.Unlike typical adaptive middleware approaches, in which sophisticated component model semantics are embedded into an existing, underlying platform (e.g., CORBA, COM, EJB), we propose a platform that imposes minimal constraints for greater flexibility.Such a tradeoff is advantageous when the platform is targeted by automatic code generators that inherently enforce correctness by construction.Applications are written as simple, single-threaded programs that assemble and monitor a set of distributed components.The approach decomposes applications into two distinct layers: (1) a distributed network of interconnected modules performing computations, and (2) constructor logic that assembles that network via a simple block-diagram construction API.The constructor logic subsequently monitors the configured system via a stream of high-level events, such as notifications of resource availability or failures, and consequently provides a convenient, centralized location for reconfiguration and debugging.The component network is optimized for performance, while the construction API is optimized for ease of assembly.

We describe an approach to automate certain high-level implementation decisions in a pervasive application, allowing them to be postponed until runtime. Our system enables a model in which an application programmer can specify the behavior of an adaptive application as a set of open-ended decision points. We formalize decision points as Goals, each of which may be satisfied by a set of scripts called Techniques. The set of Techniques vying to satisfy any Goal is additive and may be extended at runtime without needing to modify or remove any existing Techniques. Our system provides a framework in which Techniques may compete and interoperate at runtime in order to maintain an adaptive application. Technique development may be distributed and incremental, providing a path for the decentralized evolution of applications. Benchmarks show that our system imposes reasonable overhead during application startup and adaptation.

The rapid increase in the number and variety of consumer-level electronic devices without the corresponding development of device management technology has lead to a configuration nightmare. We propose to use goal-oriented programming over a substrate of network-portable objects to help reduce the amount of configuration users must do in order to have their applications use their devices efficiently. We detail an architecture and describe a prototype system using existing pervasive computing technology that plays music on the most appropriate devices without requiring user interaction and configuration

The adaptivity demands of ubiquitous computing motivate applications structured around implementation choices that are (a) made at runtime, reflecting available resources; (b) reevaluated and potentially changed during application operation, accommodating failures and resource discovery; and (c) locally extensible beyond choices anticipated (and fixed) by central application code. To this end, we explore a new organization for adaptive applications involving the formalization of Goals as representations of abstract services and a universe of Techniques which compete to provide them. In our model the selection of Techniques to satisfy each Goal is performed by an application-generic runtime process which continues so long as the Goal remains active, allowing applications to adapt to runtime changes in available resources. The set of available Techniques is potentially open, distributed, and incrementally extensible, providing paths for the decentralized evolution of applications.

Contemporary pervasive computing environments demand mechanism for coherently addressing high-level user needs despite changing availability of resources. We propose the formalization of goals as the semantic basis for this mechanism, and sketch a system architecture that separates policy-rich goals-level planning code from a policy-neutral component assembly model.

The interactive learning environment (ILE) is designed to combine the traditional resources of a textbook with the "hands-on" design experiences that are vital to a real understanding of basic engineering principles. The ILE builds on the technology developed for the World Wide Web to provide a learning environment that can be easily accessed from any browser. In addition to browseable text, JAVA-based computer-aided design (CAD) tools can be accessed through interactive figures embedded in the text, where students can investigate circuit behavior under the guidance of focused tutorials.

An MIMD multiprocessor digital signal-processing (DSP) chip containing four 64-b processing elements (PE's) interconnected by a 128-b pipelined split transaction bus (STBus) is presented. Each PE contains a 32-b RISC core with DSP enhancements and a 64-b single-instruction, multiple-data vector coprocessor with four 16-b MAC/s and a vector reduction unit. PEs are connected to the STBus through reconfigurable dual-ported snooping L1 cache memories that support shared memory multiprocessing using a modified-MESI data coherency protocol. High-bandwidth data transfers between system memory and on-chip caches are managed in a pipelined memory controller that supports multiple outstanding transactions. An embedded RTOS dynamically schedules multiple tasks onto the PEs. Process synchronization is achieved using cached semaphores. The 200-mm/sup 2/, 0.25-/spl mu/m CMOS chip operates at 100 MHz and dissipates 4 W from a 3.3-V supply.