On July 14th Hive76 will be hosting a class on piezo transducers! What’s so cool about peizo transducers? They let you turn anything into an electric instrument that you can amplify, record, and experiment with! These nifty little devices turn vibrations into usable electrical signals -and the nice thing is that they’re dirt cheap and easy to work with.
Basically microphones that work by touch, they can be used to electrify guitars, make drum boxes, or listen to sounds you can’t hear with your ears. Essential to the musical tinkerer and sonic experimenter.
The class will include a brief lesson on the science of music, sound, and practical applications of piezo transducers (music or otherwise). Participants will build their own contact microphones and leave ready to start making their own noise. If you have any cool old tins, boxes, or things that vibrate in an interesting way, bring them and turn them into instruments.
Please RSVP by commenting below with the number of seats you’d like to reserve.
When: July 14th, 2pm
Who: Open to the public
Where: Hive76, 915 Spring Garden Street
How Much: $10 at the door
Difficulty: Basic as basic can be
(Parents, please accompany minors under 18)
You must register for this class on Meetup; Limited seating available.
Wednesday, April 17, 2013
You will learn:
How to use a breadboard
What capacitors are
How to use capacitors for filtering power
How to use capacitors for basic debounce/timing circuits
Connect a 555 timer circuit for blinking an LED
This will require the purchase of a breadboard and some more expensive parts that last time (I’m thinking it will be about $15 — I may need to adjust this after I buy the parts). I will bulk-order and get everyone more parts that you need.
700pt breadboard (Like this: )
A few voltage regulators (LM317, 7805) in TO-220 packages
A few 555 timers (DIP-8)
A couple potentiometers (5k, 10k, linear taper)
More resistors (assortment)
Some capacitors (.1uF, 1uF, 10uF)
I’ll update this as I develop the slides.
You will need to bring:
1 power supply – can be a wall transformer that is between 9 and 15 VDC and greater than 200mA output. You should be able to salvage on of these from any number of places.
22ga Solid Core wire (for connecting to you breadboard)
Some kind of wire cutters. I got some of these the other day:
(Small version – will handle anything that can fit on a breadboard)
Some kind of wire strippers. I like these but any kind that can strip 22ga solid wire is fine.
The parts kit from the last class (need the resistors, LEDs, and multimeter from it) or you can buy a kit for $5 (we may not have more multimeters available if you wait too long)
Either $15 or all of the parts that I listed in the parts section above.
This article is cross-posted
It’s no secret that I’m not impressed with the current state of University education. I’ve spent a long time griping about the various issues, and pointing out ways I would do it differently. None of that makes any difference, however, until I actually do something about it.
While my issues are with post-secondary education generally, my primary expertise (especially of late) is in Computer Science and Software development. So, I developed a curriculum, found a community, and started teaching a class.
Teaching one class does not constitute a solution, but it does provide a learning experience for me. The class is over half done now, and in the rest of this post I will be examing things I have tried and what I have learned.
Since my approach is focused entirely on education, I did not assign any exercizes early on. I provided students with the tools needed to play with the concepts on their own, and set them free to hack. This turned out to be too open-ended. When encountering a new concept for the first time, many students simply had no concept of what direction they should take their explorations in.
I am now providing some concrete exercizes to the students, but really I need to find a way to integrate more hands-on learning into the class itself. This is made more difficult because of the pacing I chose for this version.
Probably the biggest experiment in this first version of the course is the pacing I am using. The class is an overview of Computer Science from both the perspective of functional abstractions and low-level machine implementation. It is designed to give students a flavour of what parts of Computer Science they might find interesting for further study. I am doing the whole thing in 8 weeks.
The amount of material I am covering would normally be covered in two or more semesters at a University. Why am I doing this? For two reasons: so that students have less time to get bogged down on individual details (since, as an overview course, this is not about depth), and also to find out how fast one can reasonably progress without hopelessly confusing students.
While I cannot be sure without more experiments, I am also beginning to suspect that the pacing increases student engagement (at least for the sorts of students I have solicited). New material every single class means that students do not have an opportunity to tune out because “we already talked about this”.
While the pacing is definitely hurting the students’ ability to deeply absorb the subject matter, I conduct informal experiments periodically to determine understanding. Students in general seem to be grasping concepts, and find themselves coming back up to speed on items they failed to retain quickly enough to demonstrate a level of penetration.
For this course, primarily because of the pacing, I solicited students with prior knowledge of computer internals and programming. I started out with a good mix of students from various backgrounds, but certain students (about half of the 10 I started with) dropped the course fairly early on.
Students who stuck with the course were precisely those students who had both enough knowledge of computer internals to handle the pace, and enough of a deficiency in prior experience with Computer Science-related material to be interested in an overview. I hope to run both slower and more in-depth courses in the future in order to serve other sorts of students.
While prior knowledge of the basics seems to be helping the students’ ability to comprehend new material, it also occassionally poses a distraction, since I cannot present any idea as strictly new. I need to improve my ability to communicate an idea that is “new” in the context of a course, without speaking as though no one present has ever heard of it before.
From the Top and Bottom
The concept of my particular curriculum for this course is to start at the “most” abstract and “most” machine-specific concepts, and work inward. This is in stark contrast to most first-year Computer Science courses, which start out in practical programming, move on to machine specifics, and then later on do algorithms and (maybe) more abstract (actual) Computer Science.
Students have indeed struggled with the seemingly-abstract concepts, especially early on when they may not yet even have a basis on which to understand “why they care” about the abstractions that are possible. This is partly because of my failure to spur adequate hands-on learning, and partly because of the ordering. On the other hand, the juxtaposition of abstractions and related implementation details has already more than once resulted in realizations about the nature of the abstractions (“that product type is just like a struct!”)
I still have to finish teaching this class, and will report more at that time. Some of my students (and also other members of the Kwartzlab community) have expressed interest in an Operating Systems implementation course, based on my Writing a Simple OS Kernel series of posts. I hope to run this course mid-summer, and structure it purely as a project course. This should give me more experience with the ways that hands-on learning can be effectively brought directly into a class.
I am also excited about the idea of running other more in-depth courses, based on community interest. From a “Computer Science for Programmers” side I would like to run a course I’m calling “Advance Abstractions” (dealing with advanced concepts in control flow and data modelling) and also a non-course structured as various talks by various contributors on specific data structures and algorithms.
I would also like to run the “slow version” of this same course, targetted at complete beginners. The problem with this version is that it requires participants to have more time to dedicate to the course. We’ll see where that goes.
There is limited seating available so Please register if you wish to attend. Wed, March 20th.
Part 1. Ohm’s law and Watt’s law
This class will teach the basics of voltage, current, and power. A lab will be included that will demonstrate how to calculate the proper value of resistor to connect LEDs to power.
Parts and equipment may be borrowed from the hackerspace or you can purchase a multimeter (http://www.harborfreight.com/7-function-digital-multimeter-92020.html), a few LEDs, a few resistors, clip leads, and a 9V battery for $5. Alternatively, you can bring your own.