“STEAM: Creating A Maker Mindset” by @vvrotny and @speterson224

As parents and teachers, we encourage our kids to become well rounded people who love learning.   In our world of cell phones, ipads, and computers, it’s easy for kids to become passive consumers of media and technology.   We, however, want are kids to be active, curious, and creative.   Since I’m a musician and a software engineer, I hope that my kids learn to express themselves emotively and become creative thinkers.   We’re trying to foster a family culture where we are active, encourage tinkering, and building physical things with our hands.   

With these ideas in mind, I wanted to share a great video I found by Vinnie Vrotny and Sheryl Peterson entitled “STEAM: Creating A Maker Mindset.”   In this conference talk from the K12 Online Conference in 2013, they share their experiences encouraging a “maker” mindset in the Quest Academy .   Their school has a very unique class teaching design thinking to kids.    It’s giving me lots of ideas for building a maker environment for our family.    In this class, Sheryl encourages her students to invent a creative design problem and solve it.   With the tools and support of the teacher, the kids are encouraged to build their design.    In some cases, the kids ask Sheryl to assign a problem to them.    The kids aren’t used to having creative freedom to design and make.    In these cases, Sheryl encourages the students to keep thinking.   🙂

Here are some of the key ideas that I enjoyed from the session.

How do you encourage the mindset of a maker?

  • What is a maker mindset?  Makers are people who have a persistent tinkering mentality.    While makers love to learn, they also enjoy transforming their new ideas into physical artifacts.    A makers mindset encourages continuous growth and a love of learning.
  • Values: In the design of their teaching style and environment, Sheryl celebrated the design values of Ideo, a prominent design and innovation firm.  
  • Model the “Maker” Spirit: The speakers noted that it was important to model the “maker” mindset for the students.   Instead of purchasing a professional “green screen” for the class space, Sheryl made one.   Sheryl took great care to construct their classroom environment and build many of their tools.  Students learn “DIY” by seeing their teacher do “DIY.”

Teaching style

  • Blending the best of many: The design class blends aspects from other class room experiences and environments:
    • Shop class
    • Art class
    • Computer lab
    • Project based learning
    • Science Lab
  • Environment is key: I see similarities between creating an effective educational maker space and the ideas from Montessori education .    While the students have freedom to decide on the goals of their design project and freedom to drive their activities, the environment is designed to foster student creativity and curiosity.   Like Montessori education, the intentional environment fosters learning and enables the students to personalize their learning.    The environment naturally encourages the students to collaborate too.
  • Maker spaces don’t need to start big and expensive.   The speakers shared that some maker spaces started $200.00 and very simple materials that you might find in an art classroom: tape, glue, cardboard, recycled equipment, etc.    Start simple and grow!

Resources and References:

It’s exciting to hear students say that the design class was their favorite class.   From pictures of their maker space, the students have tons of fun tools to explore: 3D printers, Scratch, electronics, art materials, etc.   This video is motivating me to clean up a corner of house to make it a mini-maker space for our kids.  Cool stuff!     

Using Ruby and Code Generation To Save Time


Working in information systems as a programmer, you often find yourself writing boring repetitious code over and over again. Think about it. Let’s imagine you are writing code to access the following table. How many times will you type those property names?

id VARCHAR(50) ,
user_name VARCHAR(50) ,
first_name VARCHAR(140) ,
last_name VARCHAR(140) ,
zip VARCHAR(20) ,
email VARCHAR(140) ,
enable_flag INT ,
password VARCHAR(140) ,
created_by VARCHAR(50) ,
updated_by VARCHAR(50) ,
created_at INT ,
updated_at INT ,

In typical business applications, you will repeat the column names of this table in a data transfer object, a repository class, unit test code, validation code and controller classes. It’s not the most exciting code, it, however, needs to get done. Inspired by talks by Kathleen Dollard, consultant and code generation promoter in the .NET community, I decided to build a small code generation tool for myself that would help save me time. I wanted to share parts of my code generation experiments with you. I hope the case study helps you in designing your own code generation strategy.

Building a Simple Code Generation Tool

To give myself a simple start, I decided to express my entities using XML Schema Definition(XSD), an open XML standard for describing the structure of information. XSD is pretty easy to code by hand. In the .NET world, it’s pretty simple to generate a XSD from your database using DataAdapters or other methods.

For this example, we will store the XSD in a file called “user.xsd.”

Using IronRuby, I created a class that would convert an entity expressed in XSD into code. IronRuby is an open source implementation of the Ruby language for the .NET framework. The IronRuby project enables programmers to blend the capabilities of the .NET framework and Ruby. When the “CodeGen” class is constructed, you provide a schema file, table name, a template, and namespace references.

#!/usr/bin/env ruby
load_assembly "System.Data"
include System::Data
require 'erb'

class CodeGen
def camel_case(s)
s.gsub(/(?<=_|^)(\w)/){$1.upcase}.gsub(/(?:_)(\w)/,'\1') end def initialize(schema_file, table_name, template_file, ui_namespace, model_namespace) if schema_file == NIL raise ArgumentError.new("schema_file is NIL") end if table_name == NIL raise ArgumentError.new("table_name is NIL") end if template_file == NIL raise ArgumentError.new("template_file is NIL") end if ui_namespace == NIL raise ArgumentError.new("ui_namespace is required.") end if model_namespace == NIL raise ArgumentError.new("model_namespace is required.") end if !File.exists?(schema_file) raise ArgumentError.new("Schema file does not exist: #{schema_file}" ) end if !File.exists?(template_file) raise ArgumentError.new("template_file does not exist: #{template_file}" ) end # read schema file.... @data_set = System::Data::DataSet.new() @data_set.ReadXml(schema_file) #get table ref.... @table = @data_set.Tables[table_name] @entity_name = @table.TableName.capitalize @table_name = @table.TableName @ui_namespace = ui_namespace @model_namespace = model_namespace @last_col = @table.Columns[@table.Columns.Count - 1].ColumnName #load ERB templates .... # http://stackoverflow.com/questions/980547/how-do-i-execute-ruby-template-files-erb-without-a-web-server-from-command-line @template = ERB.new File.new(template_file).read, nil, ">"


def generate()
return @template.result(binding)

def get_human_db_ref(strDbRef)
strDbRef.capitalize.gsub("_"," ")


I do acknowledge that we could have built this code generation framework using other technologies like T4, another template technology available for .NET. I, however, enjoyed getting to learn Ruby and ERB. Ruby is just a fun dynamic language! It’s nice that you can quickly edit the templates without compiling.

In the following lines, we create a “DataSet” object to read the schema data into memory. This enables the code generation templates to know the columns defined for the entity and their respective data types.

@data_set = System::Data::DataSet.new()

Our templates that we will write depend upon several pieces of data: the schema data, entity name, table name, and other properties. We store these elements as properties on the “CodeGen” object. By doing this, the properties become available to the ERB template system.

@table = @data_set.Tables[table_name]
@entity_name = @table.TableName.capitalize
@table_name = @table.TableName

In the following line, we use a ERB template to convert the table data into code.

@template = ERB.new File.new(template_file).read, nil, ">"

The following code, shows a code template for generation an entity class in C#. The ERB template utilizes the standard ADO.NET methods available on a DataTable class.

using System;

namespace <%=@model_namespace%>
public class <%= @entity_name %>

<% for col in @table.Columns %>
<%= col.DataType.to_s() %> <%= camel_case(col.ColumnName.to_s()) %>{get; set; }
<% end %>

public <%= @entity_name %> ()


#!/usr/bin/env ruby
require 'CodeGen'
require 'fileutils'

def rscg(schema_file, table_name, template_file, output_file, ui_namespace, model_namespace)
code_gen = CodeGen.new(schema_file, table_name, template_file, ui_namespace, model_namespace)
output = code_gen.generate()
aFile = File.new(output_file, "w")

rscg("user.xsd", "user", "buildEntity.erb", "c:\\output\\#{table}.cs", "MyUINameSpace", "MyModelNameSpace")

RSCG stands for “real simple code generation.” To execute the code generation process on one entity, you need to provide the XSD file, a table name, a template file name, an output file, and name space references.

rscg("user.xsd", "user", "buildEntity.erb", "c:\\output\\#{table}.cs", "MyUINameSpace", "MyModelNameSpace")

In researching this blog post, I discovered many more potential code generation solutions. The listing include commercial offerings and open source options.


On my weekend programming projects, this simple code generation idea has saved me lots of time. I’m currently adjusting my framework to generate unit test stubs, repository classes, entity classes, user interface, I hope you find the ideas helpful on your own projects.

Featured Posts on InspiredToEducate.NET

Photo from http://netdna.webdesignerdepot.com/uploads/2013/02/featured20@wdd2x.jpg

Easy Recipes for Building Android Apps using MIT App Inventor

MIT App Inventor

To help make Android App building more accessible to EVERYONE, researchers at MIT have released a wonderful tool to empower makers and students to quickly build apps using a puzzle metaphor of programming.  Everyone can play with puzzles.   Right!?   MIT App Inventor, originally developed by Google, enables beginners to create applications in hours.  (not days)   The MIT App Inventor enables you to test your apps in real-time using your Android device.   Additionally, you do not need to install special tools on your system since the development environment is browser based.  To learn more about this tool,  visit http://appinventor.mit.edu or AppInventor.org .   If you love Scratch and the work of MIT’s life long kindergarten, you’re going to love this!

The following videos by David Wolber of AppInventor.org, help you quickly learn how to design a small drawing application for your Android device.   David also offers a pretty nice book on App Inventor on his website.

Building the user interface:

Programming using Puzzle Pieces:

To help inspire you to build your own Android Apps with MIT App Inventor, we’ll introduce a few short recipes that you can include in your own designs.   These recipes will show you how to use the following device features:

  • Speech To Text
  • QR Code Scanning
  • Simple Canvas Drawing
  • Device Geo-location
  • Web browser

Let’s get cooking!    


Speech To Text App
“Speech To Text” app converts the voice the user into text by simply pressing a button and speaking.

Ingredients for App:

  • 1 Button
  • 1 Text Box
  • 1 Speech Recognizer

Here’s the program:

When the user clicks the “recognize_button”, then the speech recognizer tool gets called.   After the speech recognizer receives a result, we append the text to “TextBox1.”

QR Code Scanner App

This app enables the user to scan QR codes.   If the QR code represents a valid website link, the site will be loaded in the browser.

Ingredients for App:

  • 1 Button
  • 1 Bar Code Scanner
  • 1 Web Browser Control

Here’s the program:

The program is started when the user selects “scanButton.”   After the scanner has recognized the QR code, then the system commands the web browser to load the web site link.

Drawing App

This recipe enables you to create a drawing application for your Android device.

Ingredients for App:

  • 1 Button
  • 1 Canvas

When the user drags their finger over the canvas, a small green circle is drawn.  While dragging your finger on the canvas, the system will set the color of the paint to green.   The program draws a small circle at the (X,Y) coordinates of the dragging event.   When the user clicks the “clear_button” button, the device clears the drawing canvas.

Here’s the code:

Location Finder

This recipe shows you how to discover your current address using your location and place it on a Google Map.

Ingredients for App:

  • 1 Button
  • 1 Text Box
  • 1 Web Browser

Here’s the code:

When the user clicks “getAddress”, the system fetches your current location and finds your address.   Your address is placed in the “address” text field.   After that, we combine the Google maps search tool URL with your address.   This recipe isn’t perfect since it’s hard for Google to infer your street address perfectly.    It, however, shows you how to build mini-programs that use your current address or your current latitude and longitude. 

This post only scratches the surface.   App Inventor also includes puzzle pieces for Lego mindstorm, recording sound, taking pictures, and interfacing with Twitter.

We enjoy hearing from our readers.   If you build something cool with App Inventor, please let us know what you built!    

Featured Posts on InspiredToEducate.NET




Johnny Lee: Free or cheap Wii Remote hacks


Some research and development requires big and expensive equipment, resources, and sensors.   It’s awesome when innovators make cool technology more affordable, accessible and available to young students and hackers.   As a student at Carnegie Mellon University (CMU), Johnny Lee explored ways to use the remote control devices of a Nintendo WII in his human computer interaction(HCI) research.  (Check out his cool blog here.)   It isn’t commonly known that WII remote controls or “WIIMotes” can be connected to computers/Android devices through Bluetooth.   By sharing his Wiimote experiments using video and social media in 2008, Johnny Lee spawned a movement of experimentation and software tinkering.   Mr. Lee has provided a brief introduction to his work on the following TED talk. 

In contrast to other programmable sensor devices, a WIIMote probably costs you $40.  It provides accelerometers, gyroscopes, an infrared camera, and common game controller features.  You may have a Wiimote already in your house.  Brian Peek has published a wonderful open source library to empower .NET developers to use WIIMote sensors in their applications.  The various aspects of the WiiMote are exposed using C# events.  The code to get started is very simple.   The community experimentation based on Johnny Lee’s work has been delightful.   Check out some of the cool hacks and experiments created by the Johnny Lee, Brian Peek and the community.

Want to get started with building your own WiiMote innovations?  Check out the following links:

Featured Posts on InspiredToEducate.NET