Livings computers indeed

Just back from a long trip to Seattle. I had a great time seeing family, friends, old and new. Of course, there are always a few nerd-stops along the way.

I had the pleasure of visiting the Living Computers: Museum + Labs on the south side of Seattle. Just take the Sound Transit Link light rail system to the SODO station, walk a few blocks west along South Lander Street to First Avenue, and walk a few blocks north from there.

Seattle area public transportation is excellent. Be sure to pick up an ORCA transit card. Senior citizens can ride pretty much anywhere for $1!

Living Computers is both a hand-on museum and educational lab space. It’s another Paul Allen venture like the Museum of Pop Culture (once known as “EMP,” now “MoPOP”). The goal is hands-on experience with current and vintage computing technology, not static displays.

The first floor exhibit space is relatively new — about one year old. (The museum itself is about five years old.) The space is open and very nicely appointed. The first floor has many interesting interactive exhibits including self-driving car, telepresence robot, programmable robots, neural nets, Cubelets, and more. (Cubelets are super high tech processing blocks that plug together.) The staff is very friendly and knowledgeable.

The first floor also has teaching labs which are nicely equipped. The museum sponsors one day courses and events to help people get started and to work on projects of their own. (Watch out for events, too.) The staff hold open office hours on Thursday afternoons between 3PM and 5PM. I dropped in during office hours and had a fun chat with the teaching staff. The museum has established and is building a close relationship with local school systems and educators.

On to the second floor! Half-way up the stairs, is a mini Internet of Things (IoT) lab where you can quickly assemble a demo IoT system. I put together an Alexa-controlled buzzer. The hardware consisted of an Amazon Echo Dot, a handful of littleBits modules, and a Samsung tablet running the littleBits app. Once assembled, Alexa starts a ping-pong of network messages that eventually turn on the buzzer. Cute.

The second floor began life as Paul Allen’s computer collection. Paul Allen is a preservationist who wants people to experience vintage computing, not just look at old stuff. The second floor is filled with vintage personal computers, mini computers and mainframes. (Please see the museum site for a detailed list.) The PDP-10s, -20s, -8s, 029 card punch, etc. are old familiar tech from my youth. There were a few pieces that I had not touched before such as a PLATO terminal. The micros and minis are in a large exhibit space while the mainframes are running in an air conditioned cold room. You can get an on-line account to the mainframes, BTW.

It was a kick to see SYSTAT, again. Ah, many cold nights spent in the machine room at C-MU as a computer operator. Now there’s an obsolete job title for you! I got in a few rounds of Missile Command on the Atari 400, inspiring me to drag out my old 400 at home.

I would have pictures of the museum and labs, except it was raining cats and dogs when I visited and I didn’t want to drag my iPad into the weather. My day pack is not exactly waterproof. (Ironically, I have since trashed by 1st gen iPod by throwing it into the washing machine with the laundry.)

After taking it easy for a day, I dropped into the 2017 ACM SIGCSE computer science education conference at the Seattle Convention Center. The highlight of my day was Erik Brunvand’s presentation about his course Making Noise: Sound Art and Digital Media.

Erik is an old friend of ours from grad school days at the University of Utah, where he is now a professor of computer science. Erik’s course is like a trip through my own psyche and his lab is indistinguishable from our dining room which serves as my electronics shop. He has quite successfully melded electronic music, computing and electronics into a one semester, project-oriented course. Students slam into art/music and technology from all directions. Students get a taste of everything including circuit bending. Hats off to Erik!

Welcome CS teachers and students!

[Be sure to visit Living Computers in Seattle. SIGCSE 2017 attendees are admitted free during the conference. I visited the museum today and it was a lot of fun! K-12 teachers will enjoy the hands on exhibits.]

The annual ACM Special Interest Group on Computer Science Education (SIGCSE 2017) Technical Symposium is next week (March 8 – 11) in Seattle, Washington. The symposium brings together educators at all levels (K-12 and higher ed) to exchange and discuss the latest methods, practices and results in computer science education.

I don’t often advertise it, but the Sand, Software, Sound site has many resources for educators and students alike. You can browse these resources by clicking on one of the WordPress topic buttons (Raspberry Pi, PERF, Courseware, etc.) above. You can also search for a topic or choose from one of the categories listed in the right sidebar.

Here are a few highlights.

I taught many computer-related subjects during my career and have posted course notes, slides and old projects. The four main sections are:

  • CS2 data structures: Undergraduate data structures course suitable for advanced placement students.
  • Computer design: Undergraduate computer architecture and design which uses a multi-level modeling approach.
  • VLSI systems: Graduate course on VLSI architecture, design and circuits which is suitable for undergraduate seniors.
  • Topics in computer architecture: Material for a special topics seminar about computer architecture (somewhat historical).

Please feel free to dig through these materials and make use of them.

Software and hardware performance analysis formed a major thread throughout my professional life. I recommend reading my series of tutorials on the Linux PERF tool set for software performance analysis:

The ARM11 microarchitecture summary is background material for the PERF tutorial. Program profiling is a good way to bring computer architecture to life and to teach students how to analyze and assess the execution speed of their programs.

There are two additional tutorials and getting started guides for teachers and students working on Raspberry Pi:

Music technology and computer-based music-making have been two of my chief interests over the years. The Arduino section of the site has several of my past projects using the Arduino for music-making. You should also check out my recent blog posts about the littleBits synth modules and littleBits Arduino. Please click on the tags and links at the bottom of each post in order to chase down material.

You might also enjoy my tutorial on software synthesizers for Linux and Raspberry Pi. The tutorial is a getting started guide for musicians of all stripes — music teachers and students are certainly welcome, too!

Topics in computer architecture

A new courseware page — topics in computer architecture — is now available. This page covers a wide mix of topics from RISC vs. CISC to non-von Neumann languages and architectures. You might just find an interesting lecture or two for a special topics seminar about computer architecture.

Way back when in the early eighties, I had a chance to work with Al Davis at the University of Utah. Al was a proponent of data-driven dataflow computers. His ideas showed me that there are alternatives to centralized synchronous control, sequential programming and the von Neumann memory bottleneck. The topics page has links to information about some of this interesting work.

Looking back, I’m struck at how mired we are in the von Neumann architecture! Sure, there are a few projects underway to investigate alternatives like quantum computing, functional programming languages, and so forth. However, the world remains dominated by the centralized, sequential von Neumann model and programming languages in which parallelism is glued on through a (class) library or two. General purpose GPU (GPGPU) computation is not really that radical. Yes, GPGPU computation is data parallel, but the underlying model is the sequential execution of SIMD instructions. Speculative execution is a bit of a kludge to allow conditional execution in highly sequential SIMD programs. Further, data transfer from memory to execution units remains a limiting factor in performance.

I think we need to introduce students to a wide range of computing models. Hopefully, some young, clever soul will find a way to pull us out of our rut!

VLSI systems course

The syllabus and notes for my VLSI systems course is now available in the courseware section of the site.

This is a “Mead and Conway” course on VLSI systems and CMOS circuit design. Mead and Conway led the world with their approach to VLSI design. Instead of focusing on device electronics and physics, this approach spans system-level design down to layout and fabrication. It is particularly well-suited for computer science majors who may not have much background in electronics.

I approach VLSI system design like computer design. Heck, a computer is just another digital system to be implemented in CMOS! Thus, students build and test a series of successively more detailed models for a VLSI (digital) system, eventually implementing a circuit layout which is suitable for fabrication. At the time, student designs were manufactured by the MOSIS fabrication service (which is still in business, by the way).

Both the computer design and VLSI systems courses relied quite heavily on simulation. System- and register transfer-level models were written in a stylized C/C++. Logic- and switching transistor-level simulation was handled by IRSIM. Electronic circuit-level simulation was performed through SPICE. It’s good to see that IRSIM is open source and is still available. And, of course, SPICE is still an industry standard.

Most academic courses have switched to VHDL or Verilog for system- and register transfer-level modeling. Both languages and associated simulators can be applied to the logic-level, too. I would strongly consider or recommend either option today. Depending upon tool support, students may also be able to synthesize their designs in field programmable gate array (FPGA) technology. Logisim and SmartSim look like terrific alternatives, too. I saw a LogiSim demo at SIGCSE last March and it’s a pretty spiffy tool. SmartSim runs on the Raspberry Pi — what could be better than that?

Unfortunately, VHDL and Verilog are not the most approachable, easily understood languages. I’m not the only person with this opinion. Please see “FPGA Programming for the Masses” in the April 2013 issue of CACM. I’ve seen advertising that calls Verilog “C-like.” I disagree.

My ulterior motive is to reach and teach digital systems at the high school level. VHDL and Verilog, unfortunately, are not as easily learned as C/C++ or Java. I’m hoping to gain more hands-on experience when I get rolling with Papillio — maybe find a way to bridge Java/C/C++ to VHDL and open the door to a broader community of students.

Wanna design a computer?

The next installment in the courseware section — computer design — is now available.

This course shows how to design a computer starting with an abstract specification of the instruction set architecture (ISA) and ending with a gate-level implementation. The course teaches a method which successively translates a higher-level representation for the machine into a lower-level representation. For example, the ISA is translated to a datapath consisting of large-grain building blocks and a control graph annotated with register transfer statements. Then, the datapath and control graph are mapped into gate-level building blocks and control store. Different datapath and control styles (clocking, pipelining and microprogramming) are discussed. Computer science students should be comfortable with the representations — no scary electronics.

I taught this course for several years at Case Western Reserve University. It’s an undergraduate level course that assumes a prerequisite course in basic logic design. So, if you already know about gates, flip/flops and simple sequential logic, you’re ready to dive right in! Course material includes draft chapters for a book on computer design and slides.

I hope that you will be able to use this course for background knowledge once I begin to experiment with and write up Papillio projects. I would probably base class projects on Xilinx FPGAs (Papillio) if I were teaching this course today. Papillio makes hardware design personal and affordable. I would love to see more computer science students take up hardware design, especially in high school. Perhaps this course will help you out.

Courseware is here

Finally, the courseware section of the site is open for business!

The first course is undergraduate data structures. I taught this course twice at Tufts University. Topics include the most important elements of the old ACM 2001 “CS2” curriculum along with a basic introduction to software engineering. The course is compatible with the “new” ACM 2013 curriculum which distributes computer science topics across one or more courses. Most of the hours are devoted to data structures with software engineering and algorithms/complexity playing secondary roles.

The main web page provides a rationale for the course design. It lays out the syllabus for a one semester course (15 to 16 weeks). The syllabus links to a full set of lecture notes. These notes should be a gold-mine for any instructor — high school or college — who needs to develop and deliver a course on data structures. I tried to meld and blend the best information I could find on each topic, usually from multiple textbooks. Of course, if you are a student, please dive in and browse, too!

The main course page also has links to the projects. I drew inspiration from my background as a system programmer, so the projects are not your usual “search tree this, search tree that.” The projects include lexical analysis, expression evaluation and discrete event simulation among other subjects. For the more advanced projects, I provided a source code framework/infrastructure to the students to help get them started. They were required to design to an interface specification and then integrate their implementation into the framework. This approach allowed my students to attack larger problems with more substance and purpose.

The course uses C++. Quite often, however, the code examples were translated from Java. So, it shouldn’t be too hard to translate back to Java. The examples do not use STL, Boost or templates that would hinder translation to Java or reuse.

Please take a look! For your convenience, here are links to a sampling of topics: stacks,
linked lists, trees, debugging, algebraic datatypes (ADT) and testing.

I will be rolling out additional courses during the month of August. These courses will be hardware-oriented: computer design, VLSI systems and computer architecture. If you ever prep’ed a course, you know how time consuming it can be to simply organize course material. Blog posts will be a little less frequent until I complete the courseware section.