The principles that guide my creations include:

1. Polymath Mindset

Explore. Experiment. Cross boundaries.
Curiosity-driven making that blends disciplines without permission.

2. Tradigital Craftsmanship

Honor traditional skills. Embrace new technology.
A deliberate fusion of past and future. Hand tools and digital fabrication as equals.

3. Tools Are Extensions, Not Hierarchies

A laser cutter is just a hammer with better marketing.
No tool is sacred. CNC, code, chisels. They’re all means to create.

4. Anti-Gatekeeping Creation

Reject and prevent professional priesthoods.
Making is not exclusive. Everyone has the right and ability to build.

5. Creation as Human Expression

Make to celebrate being human. It is a ritual.
Not everything needs utility. Creation itself has intrinsic value.

6. Sustainable Pragmatism

Maximize reuse. Minimize consumables.
Design with material awareness and long-term responsibility.

7. Intentional Maximalism

More is more when it means something.
Rich, layered, expressive design that reflects lived experience.

8. Modular & Evolving Systems

Nothing is ever finished.
Design for iteration, adaptability, and continuous transformation.

9. Interactive by Nature

Objects should invite engagement.
Tactile, responsive, and participatory experiences over passive ones.

10. Radical Transparency

Show the process. Show the flaws.
Expose how things are made. No black boxes.

“Yeah. Yeah, but your scientists were so preoccupied with whether they could that they didn’t stop to think if they should.”

— Jurassic Park (Dr. Ian Malcolm)

I think about this line more often than I probably should.

Not because it’s clever, or because it’s a pop-culture shorthand for “ethics in tech,” but because it captures something I’ve seen repeatedly in real engineering work: the quiet way momentum replaces judgment.

We live in a moment where technical capability is advancing faster than our willingness to sit with its consequences. Speed, scale, and disruption are treated as virtues almost by default. If something can be built, deployed, and grown quickly, that alone is often taken as evidence that it should exist. Reflection, restraint, and responsibility are framed as friction—nice ideas, but luxuries we can’t afford under real deadlines.

The result is a landscape full of systems that are impressive on paper and fragile in practice. They function, but only within narrow assumptions. They scale, but not gracefully. And when they fail, they tend to fail in ways that feel less like accidents and more like inevitabilities we declined to notice.

Most of the serious failures I’ve seen aren’t the result of incompetence. They come from narrow framing. From incentives that reward delivery over durability. From design conversations that never quite make room for uncomfortable questions early enough to matter.

Engineering decisions don’t happen in a vacuum. Every system encodes values—sometimes deliberately, often accidentally. When we focus only on can we build it, we quietly defer harder questions:

Who bears the risk when this system fails?

What assumptions are we making about users, operators, or downstream communities?

What happens when this technology scales beyond its original context?

What tradeoffs are being hidden behind efficiency, automation, or abstraction?

Those questions aren’t philosophical in the abstract. They’re architectural. They shape interfaces, defaults, error handling, and escalation paths. They determine whether a system fails loudly or silently, locally or globally, recoverably or catastrophically.

I’ve come to believe that ethics, when applied seriously, isn’t a brake on engineering—it’s a design constraint. Like gravity, material limits, or latency. Ignoring it doesn’t make it go away; it just guarantees it will show up later, under worse conditions and with fewer options.

Trust, for example, isn’t something you add at launch with messaging or polish. It’s an emergent property of systems that behave predictably, transparently, and fairly over time. If trust isn’t designed into the architecture—into how decisions are made, how failures are handled, how edge cases are treated—it won’t survive contact with reality.

What worries me most is not that we sometimes get things wrong. Engineering has always involved uncertainty. What worries me is how often we avoid asking should we because the answer might slow us down, complicate the roadmap, or force tradeoffs we’d rather postpone.

But postponing those questions doesn’t eliminate them. It just externalizes the cost—to users, to communities, to environments, or to the future.

I don’t think the answer is less technology. I don’t think it’s fear or paralysis or nostalgia for simpler systems. I think it’s better engineering—engineering that acknowledges consequence as part of the work, not an afterthought.

That means treating ethics as an input, not a post-mortem.

It means respecting abstractions without worshiping them.

It means being willing to say “we don’t know yet” when scale outruns understanding.

It means remembering that elegance often shows up as restraint.

The question isn’t whether we can build powerful systems anymore.

We’ve answered that.

The harder question—the one that doesn’t go away—is whether we’re willing to be accountable for what we set in motion.

Circuitsmith

A Circuitsmith is a modern craftsperson who shapes electricity the way a blacksmith shapes metal. They design and build physical systems that live in the real world—circuits, sensors, kinetic mechanisms, interactive objects. Their work happens at the intersection of engineering and craftsmanship.

Core ideas:

• Works with matter and electrons

• Builds hardware with a soul

• Blends electronics, mechanics, and design

• Values hands-on experimentation

• Sees circuits as expressive materials—not just functional

What they do:

• Prototyping with microcontrollers and analog components

• Building interactive sculptures or devices

• Repairing and repurposing old tech

• Exploring physical computing

Closest real-world analogs: hardware engineer • creative technologist • interactive artist • maker • electrical craftsperson

Bitwright

A Bitwright is a digital craftsperson—an artisan of logic and information who shapes behavior rather than matter. Like a playwright arranges scenes, a Bitwright composes software, code systems, and algorithms that give ideas form and function in the digital space.

Core ideas:

• Works with logic and code

• Designs behavior, systems, interaction flows

• Crafts clean, expressive code

• Sees software as storytelling through structure

• Believes code is a creative medium

What they do:

• Write embedded firmware or system logic

• Sculpt algorithms and interaction models

• Build custom tools or creative software

• Translate human intention into machine behavior

Closest real-world analogs: embedded software engineer • computational artist • systems designer • creative coder

1. Tradigital Exploration and Experimentation – Fuse traditional craft with emerging digital technology through hands-on experimentation.

2. Sustainable Re-Creation – Transform broken, discarded, or obsolete materials into meaningful new forms.

3. Modular Evolution – Build systems that adapt, upgrade, and change over time—art as a living process.

4. Human Connection Through Interaction – Invite participation to provoke reflection, emotion, and discovery.

5. Radical Transparency, Don’t Hide The Lines – Reveal the process of how things are made, celebrate imperfection, and honor the honest character of materials.

I, a human (I think), asked ChatGPT the following question:

Prompt:
How can the lessons learned of the photography versus painting as art debate inform the discussion around human and AI made art?

ChatGPT Said:
Great question. The 19th-century fight over whether photography “counted” as art maps surprisingly well onto today’s human vs. AI-made art debate. Here’s a tight set of lessons you can lift directly from that history—and how to apply them now.

1) “New tool” ≠ “no art”

Then: Early critics called photography a merely mechanical process; artists proved authorship lived in choices (framing, exposure, printing, retouching).
Now: With AI, authorship similarly rests in intent + constraint + iteration (dataset curation, prompting strategy, model fine-tuning, selection, editing, presentation).

Takeaway: Evaluate artistic decisions, not just the tool. Ask: What problem was the artist solving? What constraints were set? What was rejected and why?

2) New media find their own aesthetics

Then: Photography won legitimacy by leaning into what it did uniquely well (movement, candidness, seriality, reproducibility), not by imitating painting.
Now: AI art’s strengths are scale, combinatorics, probabilistic variation, and fast iteration.

Takeaway: Don’t judge AI only by how well it mimics human mark-making. Judge how it extends the visual/semantic space beyond human-only throughput.

3) Process transparency matters (but doesn’t define value)

Then: Pictorialists vs. straight photographers debated manipulation; both gained acceptance once processes were named and understood.
Now: Disclose model, dataset sourcing (at least categories), prompt/fine-tune steps, and post-processing.

Takeaway: Create a process label (like a wine label):

• “Human-only, analog/digital”

• “Human + AI (curated data; directed prompts; hand-edited)”

• “AI-primary (automated batch; minimal human selection)”

4) Indexicality, aura, and the “hand”

Then: Walter Benjamin’s “aura” vs. mechanical reproduction reframed value around context, not just uniqueness. Photography still developed forms of aura (vintage prints, signed editions, process rarity).
Now: AI outputs are infinitely reproducible, but aura can re-enter via provenance, editioning, performance/installation context, and live generation.

Takeaway: Build aura with edition control, cryptographic provenance, performance-based display, or time-bound generative runs.

5) Skill shifts, not skill disappearance

Then: Skill moved from brushwork to optics, chemistry, darkroom craft, sequencing.
Now: Skill shifts to data ethics, model steering, prompt engineering as design brief, multimodal compositing, curation.

Takeaway: Update curricula and juries to read AI craft (dataset design, failure-mode management, long-loop iteration logs).

6) Democratization + gatekeeping

Then: Cheap cameras broadened who could make images; institutions adapted with new canons and genres.
Now: AI lowers barriers even further; expect volume explosions and new folk/vernacular genres.

Takeaway: Curate with new rubrics (original problem setting, iterative risk-taking, conceptual coherence) instead of pedigree or tool purity.

7) Economic + labor questions must be addressed head-on

Then: Photo threatened portrait painters; new markets (editorial, advertising, art photography) emerged.
Now: AI threatens illustration and stock markets; new roles appear (model custodians, data curators, AI art directors).

Takeaway: Build fair-use norms, licensing schemes, and revenue-share models for training data; commission frameworks that explicitly price human direction.

8) Legal and ethical clarity enables cultural acceptance

Then: Copyright for photography matured; authorship became clearer.
Now: Clarify authorship (human intent), rights in training data, consent, credit, and disclosure.

Takeaway (policy sketch):

• Disclosure: Identify AI involvement and process level.

• Consent/Credit: Respect opt-out datasets; credit notable sources when practicable.

• Provenance: Attach verifiable metadata (CID/hash, model/version).

• Review: Flag sensitive content and bias audits for juried shows.

9) Hybridity becomes the mainstream

Then: Photo + paint, collage, photogram, mixed media flourished.
Now: Expect AI + photography + 3D + robotics + performance.

Takeaway: Stop binary framing. Curate hybrid categories: “Generative Assemblage,” “Performative Generation,” “Algorithmic Documentary,” etc.

A practical evaluation rubric (usable by juries, galleries, or teams)

1. Intent & Concept

• Clear inquiry or thesis? Novel question or perspective?

2. Process & Craft

• Demonstrable human direction (logs, iterations, dataset rationale)?

• Mastery of AI’s failure modes and constraints?

3. Form & Aesthetics

• Does it leverage the medium’s native strengths (variation, scale, recombination) rather than copy analog looks?

4. Context & Ethics

• Transparent provenance; considered stance on data use and bias.

5. Impact

• Resonance, originality, and contribution to discourse or practice.

Score each 1–5; publish the rubric alongside the show or portfolio.

Implementation quick-start (for creators and orgs)

• Creators

  • Keep an iteration journal (key prompts, forks, rejects, edits).

  • Ship with a process label + provenance file (model, version, seed if relevant).

  • When possible, license or self-source datasets; document consent posture.

• Galleries/Competitions

  • Require a disclosure card (tools, datasets, human role).

  • Judge with the 5-part rubric; allow hybrid categories.

  • Offer editioning guidance for AI works (caps, on-chain proofs, or time-windowed generation).

• Educators

  • Teach dataset ethics and prompt as design brief.

  • Assign projects that force medium-native exploration (e.g., controlled variation studies).

Bottom line

From photography’s path we learn: legitimacy arrives when we judge by artistic intent, process rigor, and medium-native contribution—not by tool purity. If we build clear norms around authorship, disclosure, provenance, and ethics, the culture will absorb AI as another powerful—sometimes radical—art medium, just as it did photography.

End ChatGPT Response
=========

What are your thoughts, fellow human?
The image above, human or AI? Why do you think that?

For the last several years, I have used an ArcDroid in conjunction with a plasma cutter and a water table. It does great, but my use case is for much thinner metals that a plasma cutter tends to destroy. For the record, I am at best an amateur machinist and even less of a welder. Earlier this year, I procured Xlaserlabs’ X1 Pro laser cutter/welder/cleaner.

Out of the box, it worked great as all three, albeit by hand. What I really wanted is a CNC laser, however. The Xtool Metal Fab rolled out shortly after, and while I love Xtool and own many of their lasers (P2, F1 Ultra, M1 Ultra), the Metal Fab is just too big for a basement machine shop like mine.

The marketing material for the X1 Pro mentioned it was possible to use it for CNC use cases, but provided limited details. After some research and testing, here is how I got my ArcDroid and X1 Pro to play nicely together.

Here is the wiring diagram:

First thing we need to do is to change out the DB25 external control cable. I purchased a breakout DB25 connector from Amazon (https://www.amazon.com/dp/B07DPCGMLN). I ran two pairs of 20AWG stranded wire, one to the external emergency stop. Do NOT just short the e-stop! The second pair of wires ran to torch connectors on the rear of the ArcDroid. As far as I know, polarity doesn’t matter for either connection.

• Pins 5 and 6 connect to the external e-stop.

• Pins 3 and 4 connect to the ArcDroid external torch control on the rear of the ArcDroid.

I purchased the ArcDroid Extended Torch Mount (https://arcdroidcnc.com/collections/arcdroid-accessories/products/extended-torch-mount) to mount the laser gun. Ensuring a slight 2-3 degree offset from vertical to prevent the laser beam from reflecting up into the gun. This means perfect round or straight cuts will be a challenge, if not impossible, so this might limit you to more artistic cuts versus strict tolerance parts.

UPDATE: I have designed a mount for the X1 Laser to attach to the ArcDroid. I am selling the STL file for a nominal fee over on Etsy.

Next, let’s talk about kiln shelves.

Lastly, I drained the water table, removed the slats, and cleaned up the rust. I placed shelving typically used in kilns (https://www.amazon.com/dp/B0FG8DTXN8) under the sheet metal I am cutting. This, in theory, will protect the bottom of the water table from getting cut by the laser. This will be useful when I need to convert it back into a water table for materials that require cutting with the plasma cutter. Whether or not this is the best, or even a safe, option is still undergoing testing. I sometimes even place sacrificial aluminum or steel bars on top of the kiln shelf to elevate the sheet metal closer to the torch head.

This is the result!

I am also using a California Air Tools 10020C 2.0 HP Ultra Quiet and Oil-Free Air Compressor, 10 Gallon Steel Tank with Wheels (https://www.amazon.com/dp/B0188XBTLY)

The settings for this cut of 1/16” stainless steel are as follows:

• 55% power

• 1000 Hz

• 100% Duty Cycle

• 90psi compressed air

I loaded up a .DXF file on the ArcDroid and made some settings changes (definitely test different values depending on material and thickness). This is still a lot of room for testing here. But for 1/16” stainless steel, I used these settings:

• 0” lead-in

• Cut on the center of the line

• Kerf: .003” or 0.08 mm

• Feed: 75 ipm or 32 mm/s

• Clear Z: 0.394” or 10 mm

• Pierze Z: 0.100” or 2.5 mm

• Cut Z: 0.079” or 2 mm

• Pierce Delay: 0.5s

• Off Delay: 0.25s

P.S.

While exploring 3D printed solutions to the problem of mounting the torch to the ArcDroid, I stumbled across the following things you can print for your ArcDroid:

1. ArcDroid Torch Holder

2. Sensor Covers for the ArcDroid

In today’s fabrication industry, LEAN principles can sometimes seem complex or overwhelming, especially for small shops with limited time and resources. But when you keep it simple and focus on the essentials, LEAN becomes a powerful tool — delivering real value without unnecessary complication. At Green Shoe Garage, we’ve assembled a practical guide to straightforward LEAN strategies that even the smallest fabrication shops can use to work smarter, reduce waste, improve quality, and boost productivity.

Workplace Organization & Visual Controls

• 5S — A foundational LEAN tool for workplace organization:

  • Sort (Seiri) — Remove unnecessary tools, parts, and materials. Keep only what’s needed for current production.

  • Set in Order (Seiton) — Arrange tools, equipment, and materials logically. Designate specific locations so everything is easy to find and return.

  • Shine (Seiso) — Keep the workspace clean. Regular cleaning helps prevent issues, exposes problems early, and improves morale.

  • Standardize (Seiketsu) — Create consistent procedures for maintaining organization and cleanliness. Use checklists, schedules, or visual standards.

  • Sustain (Shitsuke) — Build good habits. Make 5S part of your shop’s culture through discipline and regular audits.
    

• Shadow boards / tool control — Use outlined, labeled places for tools so missing items are immediately obvious.

• Floor markings and zone labels — Clearly mark areas for raw material, scrap, WIP (work-in-progress), and finished goods.

• Color coding / tags — Apply color schemes to tools, bins, and paperwork for fast identification.

• Andon lights / status indicators — Simple lights or signals to display machine status (running, setup, down).

• Job boards / work cell visual boards — Boards showing job priorities, schedules, and current progress.

• Parts location labels & barcodes — Make it easy to find and track parts and inventory.

People & Communication

• Daily standup meetings / huddles — Quick 5–15 minute meetings to review safety, goals, challenges, and daily plans.

• Cross-training operators — Train team members on multiple machines or processes for flexibility.

• Kaizen suggestion system — Provide an easy way for staff to suggest and act on improvement ideas.

• Gemba walks (management at the work site) — Leadership regularly visits the floor to observe, listen, and support problem-solving.

• Standard work instructions — Document best practices for setups, operations, and inspections — ideally with visual guides.

• Job rotation (where safe) — Rotate tasks to reduce fatigue and build skills.

Production Flow & Scheduling

• Single-piece flow / small batch production — Minimize work-in-progress, catch defects early, and keep the shop uncluttered.

• Kanban pull systems — Use cards or bins to trigger replenishment only as needed.

• Quick changeover / SMED — Reduce tooling/setup times so small batch production is practical.

• Takt time awareness — Align production pace with customer demand.

• Cellular manufacturing / work cells — Group machines to minimize part travel and boost efficiency.

• Level loading / Heijunka — Balance workload to avoid peaks and valleys in production.

• FIFO (First In, First Out) lanes — Ensure older jobs and materials are processed first.

Inventory & Material Management

• Point-of-use storage — Keep tools and materials at the point of use.

• Small lot purchasing / just-in-time delivery — Buy smaller quantities more frequently to reduce inventory costs.

• Scrap bins at source — Identify and track scrap at the point where it occurs.

• Standardized material handling equipment — Use carts and bins designed to fit your material sizes.

• Mistake-proof labeling — Clear, consistent labels to prevent mix-ups.

Quality & Error Prevention

• Poka-yoke (error-proofing) — Fixtures, guides, or checks that make mistakes impossible or immediately visible.

• Go/no-go gauges or templates — Quick dimension checks without full inspections.

• In-process quality checks — Find and fix issues during production, not just at the end.

• Root cause problem solving (5 Whys, fishbone diagrams) — Structured methods to address recurring problems.

• Standardized inspection points — Consistent checkpoints to catch defects early.

Equipment Reliability

• Total productive maintenance (TPM) — Operators help maintain and clean equipment daily.

• Preventive maintenance schedules — Planned maintenance to prevent breakdowns.

• Simple machine downtime tracking — Log when and why machines stop to uncover patterns.

Waste Reduction & Continuous Improvement

• Muda awareness training — Teach staff to spot the 7 wastes: overproduction, waiting, transport, overprocessing, inventory, motion, defects.

• Kaizen blitz / improvement events — Focused efforts to solve specific problems quickly.

• Value stream mapping (VSM) — Visualize and streamline processes by removing non-value steps.

• Standard scrap and rework tracking — Identify sources of waste and address them.

• Energy efficiency checks — Reduce wasteful use of energy, compressed air, and utilities.

• Space utilization reviews — Reevaluate layouts to maximize efficiency.

Other Powerful LEAN Elements

• Dedicated staging areas for incoming jobs

• Clear scheduling boards or digital dashboards

• Parts kitting (pre-package all parts needed for a job)

• Checklists for setup, teardown, and cleaning

• Dedicated rework/repair station

• Visual timers or counters on processes

• Invest time to build simple jigs and fixtures

• Whiteboards to track jobs, ideas, and metrics

• Digital tools (barcoding, QR codes) where practical
  

Final Thoughts

LEAN isn’t about expensive tools or complex systems — it’s about building a culture of continuous improvement through simple, disciplined practices. Small fabrication shops can achieve big gains by focusing on what matters most and involving the entire team in the journey.

Or if you prefer in text format….

1. Let Curiosity Lead: Ask questions. Experiment freely. The best work begins with 'What if?'

2. Respect the Process but Focus on the Goal: Slow down. Measure twice. Set up with care. The quality of your work reflects the quality of your attention. Keep the end product and the end user in mind at all times.

3. Safety Is a Sacred Habit: Wear your gear. Know your tools. Stay present. Nothing is worth more than your well-being.

4. Prototype Early, Iterate Often: Rough versions are stepping stones to brilliance. Every iteration brings insight.

5. Master the Tools — But Never Serve Them: Learn the software. Understand the hardware. Then make it all work for your vision, not the other way around.

6. Value Craftsmanship Over Clout: Build with pride, not for praise. A well-made object speaks louder than any trend.

7. Share What You Learn: Document your process. Show your failures. Teach others. Knowledge multiplies when it's shared.

8. Bridge Old and New: Combine tradition with technology. Honor the past while pushing the frontier. Never stop learning or evolving.

9. Stay Humble. Stay Dangerous: Remain a student. Stay sharp. True skill is quiet, focused, and always evolving.

10. Leave It Better Than You Found It: Clean the bench. Respect the tools. Uplift the people around you. Every touch leaves a trace — make yours count.

TL;DR: GitHub repo containing the example code is here.

Imagine you're tinkering with an Arduino in your workshop. You’ve hooked up a temperature sensor, maybe a light sensor too, and the readings are flowing in smoothly through the serial monitor. It's fun… but what if you could log that data in real-time to a Google Sheet, accessible from anywhere, sharable with your team, or viewable from your phone?

That’s the power of combining the Arduino Uno R4 WiFi with Zoho Flow — and it's easier than you think.

Traditionally, sending sensor data to the cloud meant building some kind of server or investing in expensive cloud platforms. That's overkill for many projects, and honestly, it’s a buzzkill when all you want is to see your sensor data neatly flowing into a spreadsheet.

Enter Zoho Flow, a low-code integration platform that acts like Zapier's savvy cousin. With just a webhook, you can have your Arduino send data to Zoho Flow, which then pipes it right into Google Sheets. No servers, no authentication headaches, no Firebase config files. The negative being if someone got your Zoho API Key and learned the message format, they could spike your spreadsheet with bogus data.

What You’ll Need

• Arduino Uno R4 WiFi

• An analog sensor (e.g., LDR, TMP36, etc.) connected to A0

• Wi-Fi access

• A free Zoho account and access to Zoho Flow

• A Google Sheet you want to log data into

Step-by-Step: Sensor to Spreadsheet

1. Set Up Your Google Sheet

Create a new Google Sheet with columns like:

Timestamp | Arduino | Sensor | Value

Use Google Sheets' built-in timestamping if you want, or add it in Zoho Flow. In this example, we get the timestamp from Zoho.

IMPORTANT: Add the column headers before creating the flow in Zoho, else you will not see the field names once you start linking to the spreadsheet.

Also, grab the spreadsheet ID number from the address bar in the browser. It’s all the random numbers and letters between the /d/ and/edit?. We will need that in Zoho Flow.

Figure 1. The spreadsheet with column headers and data starting to flow in.

2. Create a Zoho Flow

1. Go to Zoho Flow.

2. Create a new flow and choose "Webhook" as the trigger.

3. Copy the Webhook URL.

4. Add an action: Google Sheets → Create Row.

5. Map the webhook field (e.g., value) to your Sheet’s columns.

Figure 2. Configuring the Zoho Flow Webhook. Be sure to grab the zapikey. It’s all the numbers and letters after /?zapikey= AND before &isdebug=false

Figure 3. Configuring the Sheet action. Don’t forget you need the Google Sheets ID for the spreadsheet that will be logging the data.

Figure 4. Once configured, you can turn the Zoho Flow on and off as needed.

Figure 4. Zoho Flow provides analytics. Useful to see if your Flow is having any issues.

Figure 5. Zoho Flow also provides an history of the triggers and actions of your flow.

3. Code Your Arduino

Upload this code to your Arduino Uno R4 WiFi:

/*
  Arduino to Google Sheets via Zoho Webhook
 */


#include "WiFiS3.h"
#include "arduino_secrets.h" 

///////please enter your sensitive data in the Secret tab/arduino_secrets.h
char ssid[] = SECRET_SSID;        // your network SSID (name)
char pass[] = SECRET_PASS;    // your network password (use for WPA, or use as key for WEP)
char zapikey[] = ZOHO_KEY;
int keyIndex = 0;            // your network key index number (needed only for WEP)

int status = WL_IDLE_STATUS;

char server[] = "flow.zoho.com";  

// Initialize the Ethernet client library
// with the IP address and port of the server
// that you want to connect to (port 80 is default for HTTP):
WiFiSSLClient client;

/* ---------------------------------------------------------- */
void setup() {
/* ---------------------------------------------------------- */  
  //Initialize serial and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
  
  // check for the WiFi module:
  if (WiFi.status() == WL_NO_MODULE) {
    Serial.println("Communication with WiFi module failed!");
    // don't continue
    while (true);
  }
  
  String fv = WiFi.firmwareVersion();
  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
    Serial.println("Please upgrade the firmware");
  }
  
  // attempt to connect to WiFi network:
  while (status != WL_CONNECTED) {
    Serial.print("Attempting to connect to SSID: ");
    Serial.println(ssid);
    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
    status = WiFi.begin(ssid, pass);
     
    // wait 10 seconds for connection:
    delay(10000);
  }
  
  printWifiStatus();
}


void send_data() {
  int sensor_reading = analogRead(A0);
  Serial.print("Sensor Value: ");
  Serial.println(sensor_reading);
  Serial.print("Starting connection to server...");
  if (client.connect(server, 443)) {
    Serial.println("connected to server.");
    // Make a HTTP request:
    String postData = "GET /731846675/flow/webhook/incoming?zapikey=" + String(zapikey) + "&isdebug=false&arduino=unoR4&sensor=temperature&value=" + String(sensor_reading) + " HTTP/1.1";
    client.println(postData);
    Serial.println(postData);
    Serial.println();
    client.println("Host: flow.zoho.com");
    client.println("Connection: close");
    client.println();
  }

}


/* just wrap the received data up to 80 columns in the serial print*/
/* --------------------------------------------------------------- */
void read_response() {
/* --------------------------------------------------------------- */  
  uint32_t received_data_num = 0;
  while (client.available()) {
    /* actual data reception */
    char c = client.read();
    /* print data to serial port */
    Serial.print(c);
    /* wrap data to 80 columns*/
    received_data_num++;
    if(received_data_num % 80 == 0) { 
      Serial.println();
    }
  }  
}

/* -------------------------------------------------------------- */
void loop() {
/* -------------------------------------------------------------- */  
  send_data();
  read_response();

  // if the server's disconnected, stop the client:
  if (!client.connected()) {
    Serial.println();
    Serial.println("disconnecting from server.");
    client.stop();
  }

  delay(30000);
}

/* --------------------------------------------------------------- */
void printWifiStatus() {
/* --------------------------------------------------------------- */  
  // print the SSID of the network you're attached to:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

  // print your board's IP address:
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);

  // print the received signal strength:
  long rssi = WiFi.RSSI();
  Serial.print("signal strength (RSSI):");
  Serial.print(rssi);
  Serial.println(" dBm");
}

And for secrets.h the file will look like this:

#define SECRET_SSID "YOUR-NETWORK-SSID-HERE"
#define SECRET_PASS "YOUR-NETWORK-PASSWORD-HERE"
#define ZOHO_KEY    "YOUR-KEY-HERE"

Be sure to replace the words between the ““ with your actual SSID, password, and API key.

4. Watch the Magic Happen

Run your sketch, open your Google Sheet — and watch as your sensor values appear in real-time. Boom! You're now logging physical world data to the cloud with no backend and almost no code.

Why This Matters

This setup is more than a one-off trick. It’s a pattern — a modular way to build IoT systems without needing to be a full-stack developer. You can now:

• Log plant soil moisture from your garden

• Track light levels in a photo lab

• Monitor temperature in a server closet

• …or build a full dashboard using Zoho Analytics or Google Data Studio

It scales with your ambition.

Take It Further

• Add timestamping in Arduino or Zoho Flow

• Use multiple sensors and send multiple fields

• Display values on an OLED screen and log them simultaneously

• Schedule email alerts or SMS if values go out of range — all from Zoho Flow!

Final Thoughts

If you're an engineer, maker, or educator dreaming of low-friction IoT logging, this combo — Arduino Uno R4 WiFi + Zoho Flow + Google Sheets — is a dream team.

No backend. No cloud headaches. Just data from the real world, flowing into your spreadsheet like magic.

So what are you waiting for?

Grab a sensor, spin up a Zoho Flow, and build your first cloud-connected data logger this weekend. You’ll be amazed at what you can build with just a few wires and a good webhook.

UPDATE: Since the data is sitting in Google Sheets, you can also use Google Looker Studio to visualize the data and then embed it on your website. See below:

Figure 6. Visualize the data using Google’s Looker Studio.
https://lookerstudio.google.com/embed/reporting/c708bc23-c096-4bb1-bbf9-22a1f172d7fe/page/kZuKF

As embedded engineers, we’re used to working with oscilloscopes, terminal windows, and IDEs. But what if I told you that you could create a fully interactive serial interface—complete with data visualization and custom controls—right inside your browser, using JavaScript?

That’s exactly what I set out to explore using the p5.js creative coding library and its companion p5.WebSerial extension. The result is a lightweight, browser-based dashboard that can connect to your microcontroller over USB, read sensor values, and visualize them—all without installing any desktop software.

Let’s take a closer look at how it works.

Why WebSerial?

Traditionally, reading serial data from a microcontroller like an Arduino or ESP32 involves connecting to a COM port using a terminal program or writing a custom Python or Processing script. The Web Serial API changes the game by allowing websites (with permission) to communicate directly with serial devices.

This opens up exciting opportunities for rapid prototyping, testing, and even end-user applications—right in the browser.

The Tools

• p5.js: A JavaScript library for creative coding and rapid UI development.

• p5.WebSerial: An add-on that wraps the Web Serial API with an easy-to-use interface.

• Modern browser: Chrome or Edge (WebSerial is not yet supported in Firefox or Safari).

What the Code Does

Here’s a quick rundown of what this sample project enables:

• Draws a 400×300 canvas using p5.js.

• Provides a "Choose Serial Port" button for the user to select their connected microcontroller.

• Opens and manages the serial connection using Web Serial.

• Reads incoming data (e.g., sensor values) and displays them on-screen in real-time.

• Adds a "Disconnect" button to safely close the connection.

Core Functions:

• makePortButton(): Creates the UI for selecting a serial port.

• serialEvent(): Called automatically when new serial data arrives.

• makeDisconnectButton(): Lets the user close the connection gracefully.

• draw(): Continuously updates the canvas with the latest sensor reading.

This allows for seamless interaction with any device that outputs serial data—such as temperature sensors, light sensors, or custom-built instruments.

How the Data Flows

Once the serial port is selected, the browser opens a connection and begins listening for incoming lines of data. Here’s what the serialEvent handler looks like:

function serialEvent() {
  inData = serial.readLine();
  if (inData != null) {
    inData = trim(inData);
    vals = int(splitTokens(inData, ","));
    if (vals.length >= 1) {
      console.log(vals[0]); // Print first sensor value
    }
  }
}

The data is parsed, logged to the console, and shown on the canvas. You can expand this to plot data over time, control actuators, or trigger events based on thresholds.

Why It Matters

This approach simplifies how we prototype and share microcontroller projects. Imagine sending someone a link instead of source code, and letting them interact with your hardware through a sleek browser UI. Whether you're debugging sensors in the lab or demonstrating a project to a client, the immediacy and accessibility of WebSerial are transformative.

Limitations & Considerations

• Browser compatibility: Only Chrome and Edge currently support Web Serial.

• Security model: Web Serial requires user permission to access ports—good for safety, but not suited for fully autonomous applications.

• Performance: Suitable for low- to moderate-speed data (e.g., 9600–115200 baud). Not ideal for high-speed binary streams.

Get Started

You can clone or fork the project from my GitHub repository [insert repo link if applicable], and adapt it to your own microcontroller projects. For best results, ensure your device outputs clean, newline-terminated ASCII strings.

Final Thoughts

This is just the beginning. As browser-based hardware interfaces become more common, I believe we’ll see more tools that blur the line between engineering and creative coding. Whether you're building a sensor dashboard, a hardware demo, or a smart art installation, p5.js and WebSerial offer a new, elegant way to connect code and circuits.

Sometimes the best interface isn’t an app—it’s a webpage.

Here is the entire sketch.js, followed by the .ino file for the Arduino Uno Rev4 Wifi. Or grab it from GitHub.

// variable to hold an instance of the p5.webserial library:
const serial = new p5.WebSerial();

// HTML button objects:
let portButton;
let disconnectButton;

let inData;     // for incoming serial data
let outByte = 0;
let vals = [];

function setup() {
  createCanvas(400, 300);

  if (!navigator.serial) {
    alert("WebSerial is not supported in this browser. Try Chrome or MS Edge.");
  }

  navigator.serial.addEventListener("connect", portConnect);
  navigator.serial.addEventListener("disconnect", portDisconnect);

  makePortButton();

  // Setup event handlers
  serial.on("noport", makePortButton);
  serial.on("portavailable", openPort);
  serial.on("requesterror", portError);
  serial.on("data", serialEvent);
  serial.on("close", handleClose);
}

function draw() {
  background(0);
  fill(255);
  text("sensor value: " + inData, 30, 50);
}

// Create the "Choose Port" button
function makePortButton() {
  if (!portButton) {
    portButton = createButton("Choose Serial Port");
    portButton.position(10, 10);
    portButton.mousePressed(async () => {
      try {
        // Always inside the button click handler:
        await serial.requestPort();     // Opens browser port chooser
        await serial.open();            // Tries to open selected port
        console.log("Serial port opened");

        makeDisconnectButton();         // Show disconnect button
        portButton.hide();              // Hide choose button

      } catch (err) {
        console.error("Serial connection failed:", err);
        alert("Failed to open serial port. Is it already in use?");
      }
    });
  } else {
    portButton.show();
  }
}

// Create the "Disconnect" button
function makeDisconnectButton() {
  if (!disconnectButton) {
    disconnectButton = createButton("Disconnect");
    disconnectButton.position(160, 10);
    disconnectButton.mousePressed(async () => {
      try {
        // Try to close using p5.WebSerial method
        await serial.close();

        // Extra check: forcibly close the underlying Web Serial port if still connected
        if (serial._port && serial._port.readable) {
          await serial._port.close();
          console.log("Underlying Web Serial port forcibly closed.");
        }

        handleClose();
      } catch (err) {
        console.error("Error while disconnecting:", err);
      }
    });
  } else {
    disconnectButton.show();
  }
}

// Called when a port is selected and ready to open
function openPort() {
  serial.open().then(() => {
    console.log("Port opened successfully");
    if (portButton) portButton.hide();
    makeDisconnectButton(); // show disconnect button
  });
}

// Called when serial port is closed
function handleClose() {
  if (portButton) portButton.show();
  if (disconnectButton) disconnectButton.hide();
}

// Handle serial port errors:
function portError(err) {
  alert("Serial port error: " + err);
}

// Serial data received:
function serialEvent() {
  inData = serial.readLine();
  if (inData != null) {
    inData = trim(inData);
    vals = int(splitTokens(inData, ","));

    if (vals.length >= 1) {
      value1 = vals[0];
      console.log(value1);
    }
  }
}

function portConnect() {
  console.log("Port connected");
  serial.getPorts();
}

function portDisconnect() {
  console.log("Port disconnected");
  serial.close();
}


function handleClose() {
  console.log("Serial port closed.");
  if (portButton) portButton.show();
  if (disconnectButton) disconnectButton.hide();
  inData = "";  // Clear last data
}

And the Arduino sketch:

void setup() {
  Serial.begin(9600); // Start serial communication
}

void loop() {
  int sensorValue = analogRead(A5); // Read from analog pin A5
  Serial.println(sensorValue);      // Send to serial port
  delay(50); // Slow down output a bit (20 readings/second)
}

“Anyone can cook.” Chef Auguste Gusteau, Ratatouille

Philosophy & Mindset

1. Anyone Can Make.

Creativity and craftsmanship are not reserved for elites, professionals, or people with fancy degrees. Everyone has the right and the capacity to make things with their hands, hearts, and minds. Our job as designers and engineers is to remove barriers, demystify processes, and give people tools they can actually use. The garage is for everyone.

2. Prevent Professional Priesthoods.

No one should have to "kiss the ring" to learn how to solder, 3D print, or build something meaningful. Jargon, exclusivity, and credential-worship create silos. At GSG, we reject that. We build open-source cultures, teach without condescension, and make mastery accessible.

3. KISS – Keep It Simple, Stupid.

Simple designs are more robust, easier to understand, easier to repair, and more elegant. Complexity for complexity's sake is a form of ego. Clear beats clever. When in doubt, take something out.

4. Make It Obvious.

Design should be self-explanatory. Cables should be labeled. Mechanisms should reveal their function. Maintenance should be intuitive. A good system invites you in; a bad one makes you feel dumb.

5. Message Over Technique.

A beautiful weld doesn’t matter if the final thing doesn’t mean something. Don’t get distracted by tricks and precision for their own sake. Focus on what you're saying through what you're building. Meaning beats mastery.

6. Design is Storytelling.

People connect with stories. A great product tells a story about who made it, why it exists, and what it wants to be. Machines don’t live stories—humans do. Let that humanity show in your work.

7. Design Should Uplift.

Function matters. But so does joy. Humor, color, playfulness, and elegance should have a seat at the table. Design for the soul, not just the job.

Tools & Technology

8. AI and CNC Are Tools.

Digital tools are extensions of your brain and hands. Use them with intention. Don’t be seduced by automation or outsource your creativity. AI doesn't dream. It replicates. You are the origin.

9. Avoid Tool Jockey Syndrome.

Loving tools is fine. But using them just to tinker, instead of finishing the job, is a trap. Know when to play, and when to ship. Solve the problem. Don't just admire problems endlessly or tinker around getting 0.001% more from a tool.

10. Adopt the New When It Helps.

Use tools and tech that actually increase efficiency. If a new tool makes you quicker or more capable, use it. But don’t chase fads. New is not always better—better is better.

11. Good Tools Should Disappear.

Great tools become invisible. They fade into the workflow and help you focus on your idea. Avoid bloated systems that overwhelm with options you’ll never use. Flow matters more than features.

12. Focus on Reducing Workflow Friction.

Choose tools and methods that minimize steps between your idea and a working prototype. Shave the drag off your workflow. Always be refining your process. Every inefficiency is a tax on creativity.

13. Every Tool You Learn Reduces Fear.

Each skill unlocks confidence. That tool you’re scared of? Learn it. Once you do, you’ll fear less and build more. Constantly be upskilling.

Process & Practice

14. Reuse What You’ve Got. Let Your Junk Drawer Guide You.

Work with what you have. Scrap parts, leftovers, old furniture, last year’s prototype—your junk drawer is a treasure chest. Reuse is sustainable, resourceful, and creatively challenging. Constraints make better designers and the best ideas often come from finding new purpose in old things.

15. Prototype Relentlessly.

Don’t overplan. Don't wait for perfect conditions. Start building. The sooner you test your ideas, the sooner you find what works. Rough prototypes are worth more than perfect concepts on paper.

16. Perfect is the Enemy.

You can always make it better—but only if you finish it first. Perfection is procrastination in disguise. Get it good enough to ship. Then improve. Iteration is better than obsession.

17. Performance Isn’t Enough.

Designs must balance capability with cost, time, and context. Building the fastest, most powerful widget means nothing if it’s too expensive or too late. Practicality is not compromise—it’s wisdom.

18. Treat Failures as Stepping Stones.

Every misstep, burn mark, or broken part is a data point. Mistakes are how we learn. Embrace them, log them, laugh at them, and use them to do better next time.

19. Throw Out the First Design.

Assume version one is flawed. Don’t cling to it. Build it fast, break it fast, and move on. Real growth happens in version two and beyond.

20. Design for Future You.

Leave notes. Label your work. Comment your code. Organize your files. Future You is forgetful, tired, and probably working late. Be kind to them.

21. Design for the Next Pair of Hands.

You won't be the last person to use, repair, or expand your project. Make it understandable to others. Leave behind clarity, not mystery.

22. Constraint is a Feature.

Limitations aren’t obstacles—they’re fuel. A limited budget, tight deadline, or lack of parts forces focus. Welcome constraint. It sharpens your edge.

23. Make Learning Inescapable.

Design things so people can learn from them without even trying. Let your work teach through interaction. Good design is educational by accident.

24. Build Like You Might Need to Escape With It.

Lightweight, modular, durable. If you had to grab your work and run, would it survive the journey? If not, rethink it.

25. Optimize for Repair, Not Perfection.

Use fasteners, not glue. Make things that are meant to be fixed, improved, and opened again. Repairability is sustainability.

26. Design for the 2 A.M. Fix.

Would it make sense to someone under stress, in the dark, half-asleep? If it wouldn’t, make it simpler.

27. Start Crude, Polish Later.

Don’t waste polish on an idea that doesn’t work. Make the ugly prototype. Then refine. Build raw, then shape it into beauty. Timeless objects and systems that last, evolve; they are not invented in one fell swoop.

28. If It’s Worth Building, It’s Worth Sharing.

Put your projects online. Talk about your process. Teach what you learned. You’ll make the community stronger—and yourself.

29. Plan but Leave Room for Serendipity.

Sketch the roadmap, but don’t pave over the side trails. Some of the best breakthroughs happen when you’re not looking for them. Stay open to the unexpected, and let happy accidents shape the journey.

1. Know Your Audience

Before designing any chart, ask yourself: Who is this for? An executive may need a high-level summary with quick insights, while an analyst may require detailed data breakdowns. Understanding the needs, technical knowledge, and decision-making style of your audience ensures your visualization delivers the right message. Tailor the complexity, format, and depth accordingly. If your audience is non-technical, avoid using jargon and opt for clear visual metaphors instead. Effective data visualization involves translating data into meaningful information for the viewer.

2. Choose the Right Chart Type

Selecting the right chart type ensures your data is clearly and accurately communicated. Here's a breakdown of common chart types and when to use them:

• Bar/Column Chart: Best for comparing values across categories. Great for discrete, non-time series data.

• Line Chart: Ideal for showing trends over time. Use when your data has a continuous time element.

• Pie Chart: Useful for illustrating simple proportions. Avoid when you have more than 3-5 segments.

• Scatter Plot: Excellent for showing correlations and relationships between two numerical variables.

• Heatmap: Highlights intensity or density of values across two dimensions, great for identifying patterns.

• Area Chart: Similar to line charts, but emphasize volume. Good for cumulative trends.

• Histogram: Best for showing the distribution of a single continuous variable.

• Bullet Chart: Good for comparing a metric against a target and ranges (e.g., performance vs. goal).

Always choose your chart based on the question you're trying to answer- whether it's comparison, distribution, relationship, or composition.

3. Keep It Simple & Focused

The most effective visualizations are clean and focused. Remove unnecessary gridlines, background images, and decorative elements that don't add meaning. Stick to one main message per chart. Use white space wisely to avoid overcrowding. Simplify labels and choose clear, readable fonts. By minimizing clutter, you allow your viewer to focus on what matters most: the data story. A good rule of thumb is to ask: If I remove this element, will the viewer still be able to understand the chart? If yes, cut it.

4. Use Color with Purpose

Color should be used intentionally to highlight, differentiate, or alert. Avoid using too many colors, as they can overwhelm the viewer and dilute your message. Stick to a consistent color palette across dashboards, and reserve bold colors, such as red or green, for alerts or key performance indicators (KPIs). Consider accessibility: use color-blind-friendly schemes and avoid relying solely on color to convey key distinctions. Utilize contrast to draw attention to important data points, while keeping the rest of the chart in muted tones to provide context.

5. Label Clearly

Labels should leave no room for confusion. Always label your axes and include units of measurement. For example, 'Revenue (USD)' is better than 'Revenue'. Avoid relying solely on legends; directly labeling bars or lines can improve readability and reduce eye movement. Ensure text is legible on all screen sizes, and avoid rotating labels unless absolutely necessary. Clear labeling not only enhances comprehension but also fosters trust in the data you present.

6. Highlight Key Insights

Don't just show data, draw attention to what matters most. Use annotations, bold text, or contrasting colors to highlight spikes, drops, or anomalies. Call out important thresholds, goals, or breaking points with reference lines or icons. Think like a storyteller: what's the main takeaway, and how can you visually emphasize it? A single highlighted point can turn a good chart into a powerful communication tool that influences decisions.

7. Use Contextual Aids

Data without context can be misleading. Always provide benchmarks, historical trends, or averages to help your audience interpret the numbers. Include tooltips for definitions, or brief footnotes if complex assumptions were made. Reference lines (e.g., targets, industry averages) help viewers frame what they're seeing. Without context, a number may seem good or bad; arbitrary context grounds the viewer in reality.

8. Leverage Interactivity (if available)

Interactive features such as filtering, tooltips, and drill-downs empower users to explore data on their own terms. This is especially valuable in dashboards where different users may seek different levels of detail. Hover states can provide extra context without cluttering the view. Allowing users to switch views or toggle segments enables them to personalize their data experience. But avoid over-complicating: interactivity should enhance, not hinder, clarity.

9. Stay Consistent

Consistency builds user confidence. Use the same colors for the same categories across multiple visuals. Apply uniform font styles, number formatting, date formats, and axis scales where possible. This reduces cognitive load, creating a seamless experience. A viewer should never have to relearn how to read each chart. Branding and style guides are helpful for enforcing consistency across teams and reports.

10. Above All Else, Tell a Story!

Data alone isn't compelling- stories are. Wrap your visuals in the narrative by explaining the context, conflict, and resolution. Why does this data matter? What's at stake? Use supporting visuals to guide the viewer from question to conclusion. A well-crafted story transforms a static chart into a persuasive, memorable experience. The best dashboards tell a story at a glance.

Introduction

Ethical frameworks play a crucial role in shaping professional conduct, ensuring accountability, and protecting public welfare. The scientific, engineering, and medical fields have long-established, rigorous codes of ethics that govern research integrity, public safety, and patient care. In contrast, the rapidly evolving technology industry often operates under a more fluid and fragmented set of ethical guidelines. This paper explores the structured ethical codes in science, medicine, and engineering while contrasting them with the often reactionary and self-regulated nature of ethics in the technology sector.

Ethical Frameworks in Science, Engineering, and Medicine

Scientific Ethics: The Pursuit of Truth and Integrity

Scientists work in the pursuit of knowledge, making ethical conduct paramount to maintaining credibility and societal trust. Their ethical frameworks emphasize:

• Honesty and Integrity: Scientists must avoid data fabrication, falsification, and misrepresentation.

• Objectivity: Research should be unbiased and free from conflicts of interest.

• Transparency and Openness: Peer review, replication of results, and open data sharing are central.

• Respect for Human and Animal Subjects: Ethical guidelines such as the Belmont Report and Institutional Review Board (IRB) oversight ensure informed consent and humane treatment.

• Social Responsibility: Scientists must consider the long-term societal impacts of their research.

Key ethical frameworks include:

• The Singapore Statement on Research Integrity (2010)

• The European Code of Conduct for Research Integrity (2017)

• The American Association for the Advancement of Science (AAAS) Code of Ethics

Violations of these principles can lead to academic expulsion, research bans, and legal consequences, underscoring the rigidity of scientific ethics.

Engineering Ethics: Balancing Innovation and Public Safety

Engineers design systems and infrastructure that impact human lives and the environment. Their ethical principles include:

• Public Safety and Welfare: Engineers must ensure their designs do not pose risks to human life.

• Professional Competence: Engineers should work within their areas of expertise.

• Honesty and Integrity: Engineers must report accurate data and safety concerns.

• Sustainability: Ethical engineering considers environmental impacts.

Well-established engineering ethical codes include:

• The National Society of Professional Engineers (NSPE) Code of Ethics

• IEEE Code of Ethics (for electrical and computer engineers)

• ASME and ASCE Codes of Ethics (for mechanical and civil engineers)

Case studies like the Challenger Disaster (1986) highlight the severe consequences of ethical breaches in engineering, reinforcing the necessity of strict adherence to ethical codes.

Medical Ethics: Prioritizing Patient Welfare

Medicine is grounded in the duty to heal and prevent harm. The core principles guiding medical professionals are:

• Beneficence: Acting in the best interest of patients.

• Non-Maleficence: “Do no harm.”

• Autonomy: Patients must provide informed consent for treatments.

• Justice: Equitable distribution of healthcare resources.

• Confidentiality: Patient privacy must be protected.

Prominent medical ethical codes include:

• The Hippocratic Oath

• The Belmont Report (1979)

• The Nuremberg Code (1947) (established after WWII to prevent unethical medical experiments)

• The American Medical Association (AMA) Code of Ethics

Violations of medical ethics can result in revocation of medical licenses, criminal charges, and malpractice lawsuits. The rigorous oversight ensures strict adherence to ethical standards.

Ethical Challenges in the Technology Industry

Unlike science, engineering, and medicine, the technology sector lacks a singular, unified code of ethics. Instead, it relies on a patchwork of industry guidelines, corporate policies, and government regulations.

Absence of a Unified Ethical Code

Whereas scientists, engineers, and doctors must adhere to well-defined ethical standards, technology professionals often operate in gray areas. The ACM Code of Ethics and IEEE Code of Ethics provide ethical frameworks for computing professionals, but they are largely voluntary and rarely enforced with strict consequences.

Ethical Challenges in AI and Data Privacy

Technology companies frequently face ethical dilemmas in AI, data privacy, and cybersecurity. Concerns include:

• Algorithmic Bias: AI systems can reinforce societal biases if not carefully designed.

• Big Data Ethics: Companies collect vast amounts of user data, raising concerns about surveillance and unauthorized use.

• Cybersecurity and Ethical Hacking: Ethical hacking certifications like CEH (Certified Ethical Hacker) provide some structure, but cybersecurity ethics remain inconsistent.

Efforts such as:

• Google’s AI Principles

• Microsoft’s AI and Ethics in Engineering & Research (AETHER) Committee

• The European Union AI Act

attempt to introduce structure, but they lack the binding authority seen in medical, scientific, and engineering ethics.

Corporate vs. Public Interest: A Conflict of Ethics

Unlike scientists, engineers, and doctors, who serve public welfare first, many technology professionals answer to corporate interests. This has led to numerous ethical scandals:

• Facebook’s Cambridge Analytica Scandal (2018): Unethical data harvesting for political manipulation.

• Google’s Project Maven: Controversial AI collaboration with the U.S. military.

• Volkswagen Emissions Scandal (2015): Engineers manipulated emissions data to meet regulatory standards.

In many cases, ethical violations in technology result in fines and public relations damage but rarely lead to personal accountability for executives or developers.

Conclusion: The Need for Greater Ethical Oversight in Technology

The contrast between the rigorous ethical codes of science, engineering, and medicine and the often reactive, corporate-driven ethics of technology highlights a significant ethical gap. While scientists, engineers, and doctors face strict professional accountability, technology professionals often operate without the same level of oversight.

To bridge this divide, the technology industry must:

1. Establish a unified, enforceable ethical code similar to medical and engineering standards.

2. Strengthen regulatory oversight to ensure that ethical violations carry meaningful consequences.

3. Prioritize social responsibility over corporate profits, recognizing the long-term implications of unethical tech practices.

4. Develop standardized ethical training programs for technology professionals, similar to medical and engineering licensure requirements.

5. Encourage greater public accountability by increasing transparency in AI, data privacy, and cybersecurity policies.

As technology increasingly shapes society, the industry must transition from a cavalier, self-regulated approach to a rigorous ethical framework that aligns with the standards upheld by other professions.

When I was selected for induction into Tau Beta Pi, the engineering honor society, I was asked to visit an art museum and reflect on the role of the arts and humanities in technology. At first, I thought it was just an exercise in broadening our perspectives, but I quickly realized it was about something far deeper—ethics. Technology is inherently amoral; it does not have intent. But the people who create it do. As engineers, we have an obligation to consider not just how something works but why it should exist at all. Jeff Goldblum’s line from Jurassic Park comes to mind: “Your scientists were so preoccupied with whether or not they could, they didn’t stop to think if they should.” Engineering is not just about technical brilliance; it’s about responsibility. Every algorithm, circuit, or mechanical system we design has real-world consequences—affecting individuals, shaping industries, and sometimes even altering society itself. The arts and humanities remind us that technology is not neutral; it reflects the intentions, biases, and moral compass of its creators. If we, as engineers, don’t engage with the ethical dimensions of our work, we risk building systems that serve power rather than people, efficiency over humanity, and innovation without accountability. Tau Beta Pi’s lesson was clear: great engineering isn’t just about solving problems—it’s about making sure we’re solving the right ones.

With this background, we must also recognize the convergence of professional engineering and the hobbyist maker movement is reshaping the job market, economic landscape, and societal dynamics. Traditionally, engineering was a structured profession requiring formal education, certifications, and adherence to rigorous standards. Meanwhile, the maker movement, fueled by DIY culture and open-source technology, thrived on accessibility, experimentation, and grassroots innovation. As these two worlds merge, a new breed of professionals is emerging—hybrid engineers and makers who blend technical expertise with hands-on creativity. This blending is creating unique job opportunities, transforming industries, and reshaping how people engage with technology.

The boundaries between engineering and artistry are blurring. Traditional engineering fields, which were once strictly about precision, efficiency, and utility, are now embracing creativity, storytelling, and human expression. In a world increasingly dominated by automation and artificial intelligence, new hybrid roles have emerged that demand both technical mastery and artistic vision. Three new job titles—Electronsmith, Atomwright, and BitCrafter—capture this convergence, embodying the fusion of electronics, mechanical craftsmanship, and digital creativity.

These roles are more than just new names; they represent a shift in how we think about work, innovation, and the uniquely human qualities that machines can never replicate. While AI can analyze, optimize, and even generate designs, it lacks something crucial—a life story. Like NASA astronaut Gene Cernan famously said about the difference between a human and a robotic probe on the Moon: “There’s something about going to a place with a set of human eyes and human ears and a human mind that a probe can never replace.” Similarly, human-made objects, inventions, and designs carry a narrative, an intention, and an emotional connection that AI-driven automation cannot replicate.

Let’s explore the meaning behind Electronsmith, Atomwright, and BitCrafter, why they are necessary in the modern world, and how they exemplify the need for careers that merge traditional engineering with hands-on artistry.

Electronsmith: The Artisan of Electronics

An Electronsmith is more than just an electrical engineer or a technician. They are an artist working with circuits, electricity, and embedded systems, blending the principles of traditional blacksmithing with modern electronic craftsmanship. Electronsmiths build circuits that are not just functional but also elegantly designed, with an emphasis on aesthetic PCB layouts, handcrafted enclosures, and user experience.Why We Need Electronsmiths:

• Personalized Electronics: In a world where mass production dominates, handcrafted electronics offer uniqueness, storytelling, and bespoke solutions.

• Art-Integrated Tech: From interactive art installations to handcrafted synthesizers, electronics are no longer just about function but about evoking emotion.

• Hardware That Tells a Story: AI can generate schematics, but an Electronsmith breathes life into hardware, making it resonate with human experience.

Atomwright: The Sculptor of Matter

An Atomwright is a hybrid of a machinist, mechanical engineer, and hands-on artisan. The name derives from "atom," the fundamental building block of matter, and "wright," meaning a skilled builder. Atomwrights work at the intersection of CNC machining, traditional hand tools, and advanced material science, crafting mechanical components that are as much about precision as they are about beauty and human touch. Why We Need Atomwrights:

• Merging Tradition and Innovation: As CNC machining and automation rise, we still need human intuition and craftsmanship in mechanical design.

• Storytelling Through Materials: A handcrafted wooden gear, a machined titanium sculpture, or a 3D-printed bio-inspired structure carries the identity of its maker.

• Beyond Mass Production: Consumers are seeking meaningful, custom-built products rather than mass-produced ones. An Atomwright ensures that mechanical design retains a personal connection.

BitCrafter: The Digital Artisan

A BitCrafter is a digital sculptor, blending software development with artistic vision. The term combines "bit," the fundamental unit of digital information, with "crafter," emphasizing hands-on creation. Whether it’s generative art, game design, digital fabrication, or interactive storytelling, BitCrafters build immersive digital experiences infused with human creativity. Why We Need BitCrafters:

• Humanized Digital Creations: AI can generate designs, but it lacks intent, humor, or personality—qualities that make digital experiences engaging.

• Ethical & Thoughtful Software: Code written by a human, for humans, is often more considerate and intuitive than machine-generated code.

• Bridging the Virtual and Physical: BitCrafters ensure that digital art, interactive media, and software-driven installations carry a human touch and communicate deeper meaning.

Why These Roles Matter in the Age of AI

AI is revolutionizing how we design, engineer, and create, but it cannot replace the human story embedded in every handmade piece of work. Just as a robotic probe on the Moon can never replace the wonder of a human astronaut exploring its surface, an AI-generated design lacks the depth, thought, and soul that comes from human creativity.

AI is Impersonal—Humans are Not

• AI lacks intention and experience—it generates solutions without lived context.

• AI does not struggle, learn, or evolve—human craftsmanship reflects a lifetime of growth and mastery.

• AI does not tell stories—humans embed personal meaning into their work, making it resonate with others.

The Future is in Human-AI Collaboration

Rather than replacing artisans, engineers, and makers, AI should serve as a tool that enhances human creativity. Electronsmiths, Atomwrights, and BitCrafters represent the future of careers that leverage both technology and traditional craftsmanship, ensuring that the final product carries not just functionality but meaning.

Final Thoughts: The Need for Engineering That Speaks to the Soul

The world does not need just engineers, designers, or coders—it needs creators who integrate technology with human emotion and storytelling.

A circuit designed by an Electronsmith is more than just conductive traces; it’s a visual and functional experience. A part machined by an Atomwright is more than just metal and tolerances; it’s a piece of engineering art. A program written by a BitCrafter is more than just ones and zeros; it’s an interactive journey that immerses the user in something deeply human.

Machines will always be faster, but they will never be personal. If we want the world to be filled with meaningful technology, then we need humans who craft, shape, and embed their own life stories into their work.

Whether you’re an engineer, a designer, or a hobbyist, embracing these roles means becoming more than just a technician—you become a storyteller through your craft. The future belongs to those who blend logic with creativity, precision with passion, and technology with soul.

So, are you an Electronsmith, an Atomwright, or a BitCrafter? Or are you something new altogether? Whatever your path, make sure it carries your story.

1. Make it Yours: Build a workshop that feels like home. It should inspire you, motivate you, and make you want to get to work. Forget about trying to turn it into some pristine YouTube set—nobody cares about fake. Be real. A little mess is fine, but don’t let it slow you down. Clean up when it makes sense, but don’t obsess over it. Your shop should work for you, not the other way around. Surround yourself with things that inspire you. Hang up your favorite projects, sketches, or posters. Keep a whiteboard or corkboard for jotting down ideas, to-do lists, or rough sketches of your next project.

2. Storage Debate

   1. For Generalist Makers: Keep it simple. Group tools by type—all your hammers in one spot, screwdrivers together, and so on. Keep the tools you need to run a machine close by, and organize materials by type (wood, metal, electronics, etc.).

   2. For Repeat Makers: If you’re cranking out the same kinds of projects over and over, organize by the steps in your process. Keep everything you need for each step together so you can roll from raw materials to finished product without wasting time hunting for stuff.

3. Efficient Workflow: Set up your tools and materials so they make sense for how you work. Think about your process. Place things so you can move easily from step A to step B without wasting time or tripping over stuff.

4. Documenting and Sharing: If you’re into documenting and sharing your work, don’t go overboard trying to make your shop a film set. But do take the time to set up good lighting and get a solid, adjustable camera mount. Make sure it’s easy to move the setup around so you’re not stuck filming in just one spot.

5. Windows and Natural Light: If you can, get some windows in there. Natural light makes a huge difference, and ventilation is always a plus. Plus, a nice view can keep you grounded and help you keep track of time.

6. Segment Dirty and Clean Work: Keep the messy stuff (like sawing and sanding) separate from the clean stuff (like 3D printing or electronics). It’ll save you a ton of headaches and keep your projects looking their best and tools working optimally.

7. Dedicated Finishing Area: Create a separate space for painting, staining, or varnishing. Keep this area free of dust and debris to ensure a clean finish. Use drop cloths or tarps to protect floors and other surfaces.

8. Tiered Storage: Think about how often you use your tools and materials:

   1. Daily Use: Keep these within arm’s reach. You don’t want to waste time looking for them.

   2. Monthly Use: Put these in easy-to-reach cabinets or shelves

   3. Rarely Used (Yearly): Deep storage. If you barely use something, consider borrowing or renting it instead of letting it take up valuable space.

   4. Avoid stuffing everything into drawers or cabinets unless it’s something you don’t use often. Clutter kills efficiency. Check out Adam Savage’s thoughts on First Order Retrievability.

9. Power and Ventilation: You can never have too many outlets. Make sure you’ve got enough for both your stationary tools and anything mobile. Ventilation is just as important. Whether it’s dust, fumes, or heat, you need a way to deal with it. Get an exhaust fan or a good air filter—your lungs will thank you.

10. Maximize Horizontal Surfaces: Keep your workbench clear. A cluttered bench isn’t a workbench; it’s storage, and storage belongs somewhere else. Your horizontal surfaces should be for working, not for stacking junk.

11. Modular and Mobile: Stay flexible. Use mobile workbenches, rolling tool carts, and modular setups so you can adapt as your needs change. Design your shop to grow with you.

12. Tool Maintenance: Take care of your tools, and they’ll take care of you. Set up a station for maintenance supplies like oils, sharpening tools, and spare parts. Schedule regular maintenance for power tools and larger machines, and keep a log of when each tool was last serviced.

13. Material Management: Label and sort materials by type and size (e.g., plywood sheets, metal rods, electronics components). Use vertical racks for storing longer materials like wood planks or metal pipes. Keep scrap materials organized and accessible for smaller projects or prototypes. Keep a bucket of “greeblies”, stuff you find or extra parts, that can be used in a future project, typically for aesthetic but sometimes functional purposes. Don’t go crazy though!

14. Safety First: Safety isn’t optional. Keep a well-stocked first aid kit in a visible, accessible location. Install a fire extinguisher suitable for electrical and flammable material fires. Use proper safety gear—goggles, gloves, ear protection, and dust masks—and make them easy to grab when needed. Keep clear pathways to avoid trip hazards.

15. Lighting Options: Good lighting is critical. Add task lighting over workbenches and tool stations for detailed work. Use adjustable or directional lights to focus on specific areas. Combine overhead lighting with portable lights to ensure full coverage.

16. Noise Control: If your shop is in a shared or residential space, think about soundproofing. Acoustic panels or heavy rugs can help dampen noise. For noisy tools like compressors, consider placing them in an isolated area or sound-dampened enclosure.

17. Climate Control: A comfortable shop is a productive shop. If you deal with extreme temperatures, invest in heating or cooling solutions. Insulate the space to maintain a stable working environment and reduce energy costs.

18. Internet Connectivity: Get your shop connected. Wi-Fi and Ethernet are great for running CNC machines, laser cutters, or even just watching tutorials. My laser cutter works so much better with a hardwired Ethernet connection. So having both wired and wireless connectivity is important. Have a laptop handy for design work and videos. And if you’re into it, set up a smart assistant like Alexa for quick calculations or shopping list additions.

19. Add Music: A little music goes a long way. It sets the mood and keeps you going on those long projects. Get a decent sound system—you deserve it.

BONUS TIP:

• Workshop Uniform: Whether it’s a pair of overalls or an old chore coat, having something to wear in the workshop is helpful for various reasons. Most obviously, it keeps our good clothes clean. Workshop uniforms are meant to get dirty. Second, it lets us have things like a tape measure or utility knife always at the ready. Workshop uniforms should have plenty of pockets. The workshop uniform is only for the workshop, so at the end of the day, you keep all your stuff together so you don’t have to fish everything out of your pockets when you cuddle up with your significant other later. Lastly, it helps to get you get into a mindset. Sometimes, we aren’t in the mood to work, but having a ritual like putting on the workshop uniform can help our mind get in the zone when it’s time to crank out some work. And when we leave the workshop, the lack of uniform reminds us to enjoy quality time with family and friends cause life is more than just work.

Hardware development has traditionally relied on linear processes, where design, prototyping, testing, and manufacturing occur in sequential phases. While this approach works for well-defined projects, it struggles to adapt when:

• Requirements change mid-project.

• Issues (e.g., part obsolescence) arise late in development.

• Complex systems require frequent iteration and verification/validation.

Unlike software, hardware projects face challenges such as long lead times, physical constraints, costly iterations, and dependency on manufacturing. However, these challenges can be mitigated by implementing Agile principles tailored for hardware workflows. This post presents some hard-learned lessons on applying Agile to hardware development, emphasizing iterative design, modular architectures, and continuous feedback to enable faster, more flexible development cycles.

Challenges in Hardware Development

Before exploring Agile solutions, it is important to recognize the challenges specific to hardware:

Agile addresses these challenges by introducing flexible workflows, continuous testing, and frequent stakeholder input to identify issues early and adapt quickly. But it’s never just that easy. So, without further aideu, my lessons learned on bringing agile management methodology to hardware projects:

1. The Best of the Best Don’t (and Won’t) Live In Your Town. Embrace remote work to the greatest extent possible. Not everyone needs to touch everything all the time. Be smart about when you collaborate in the real world and when you can work remotely. Integration tests are a great time to unite people for a week or two. Geographically distributed teams can also work 24/7. When I am asleep in New York, a co-worker can incrementally improve my design in Tokyo. And when she goes to sleep, I can pick back up and keep moving the ball forward. AR/VR might also help in this regard. It’s not quite there yet, but it probably will one day. Also good for getting customer feedback; they care more about higher-level requirements like look-and-feel and system-level operations versus the minutia of detailed design work. AR/VR seems reasonable enough at this point for the purpose.

2. Function versus Form Factor: I once had the task of designing a power supply for a system. Conceptually, a power supply is a pretty common subsystem for many things, big and small. I built the power supply, and from an electrical perspective, it worked flawlessly. From a mechanical perspective, it weighed too much and was dimensionally too large for the space it had been given. But we didn’t know how much space it could be given until the design was much further along. So we redesigned the power supply, and it meant that we couldn’t power everything the client wanted to power, but we fit the box. But if we kept the original power supply, we could power everything, but they would have to give up the space equivalent to a few sensors and associated circuitry to make it fit. But then, the loss of that sensor equipment lowered the system's power requirements. We were in a real Catch-22! So, we had to return to the client and systems engineer to present the tradeoff. The point of all this is that in hardware,e there are tradeoffs that are much more serious than in software. Adding more bits generally doesn’t affect the weight or size. Be prepared for this back-and-forth when designing hardware.

3. You can Design Software Without Developing Hardware, but it’s Very Rare to Build Hardware without also Developing Software. People building a smartphone app accept they are building for a fixed set of hardware devices. They aren’t (likely) building hardware. However, when building hardware, you are likely also building software. And with it comes all the problems that come with software development. But that is a story for another day.

4. Don’t Let The Project Management Tool Wonks Win. I swear some teams spend more time worrying about managing their work than doing it. Management tools should aid in getting the job done, not be a chore in and of themselves. That said, because we are embracing geographically distributed teams, your tool needs to be digital and accessible from a laptop browser and an app on a smartphone and tablet.

5. 3 Three-week sprints. With two-week sprints you will spend more time just wrestling with the management of the agile framework beast than doing value-added work. Four weeks and too much could have changed since the sprint was planned. Three weeks is the sweet spot.

6. First Law of Orbital Mechanics: Slow Down to Speed Up. Maintain a sustainable pace. Trying for breakneck speeds will cause burnout, and that’s unsustainable. Accept that the team needs to spend 10-15% of their time on management tasks, mostly meetings such as Sprint Design Reviews and Sprint Planning Meetings. Teams should be kept to 8 folks or less,s including non-technical staff such as scrum master and/or product owner. Want to know more about orbital mechanics? Click here. ;)

7. Yes AI is Coming for Our Jobs, Embrace It. I do not doubt that AI will have an effect on our design work, for better and for worse. As is true with any technological advancement, the goal should be that the tools (and yes, AI is just a tool) should do the drudgery work and free the human for the more creative work. I would be lying if I said I didn’t use AI to generate ideas. Humans, especially in teams, work better from a scratchpad idea than a blank sheet of paper. Use AI to help brainstorm initially, but always give it back to humans to massage, improve, and add creativity and innovation to concepts.

8. Open Source and Modular Architecture: Why Arduino succeeded, it force a form factor. On the one hand, there is an argument that it stifles future innovation. Still, standards also allow it so the fire department from Annapolis can help fight a fire in Baltimore (read more here). Put another way, don’t reinvent the wheel. And be warned, engineers always think they can build a better wheel. Don’t let pride into the design equation.

9. Design-Build-Test-Learn Loop. This is the meat and potatoes. This is probably why you are here. Let’s dive into what a scrum cycle should look like for hardware. A reminder for those who have just skimmed to this part. 3-week sprints. The target is no more than 10-15% of the team’s time spent on scrum/agile administrivia, which means 95-90% should be on the value-added Design-Build-Test-Learn loop. The loop starts as such:

   1. Product Backlog Review: Review all backlog stories based on the past sprints and any changes that have arisen since the last product backlog review. Kill any that are moot. Put those that are not ready into the icebox. Bring those requirements that are ready for execution forward into the next sprint and logically move the project forward. Get a feeling for hours of effort from the team. Validate with the client. This is the time for the client to get their say. This should occur on the first day of a sprint.

   2. Sprint Planning Meeting: Assign stories chosen to team members and have them break down the work into tasks that can be validated at the end of the sprint. Ensure that the even distribution of work and all dependencies are met and that parts are on hand during the fabrication/assembly phases. On-hand inventory is not something you think about in software agile development. Don’t be afraid to push to backlog any work that is just not ready for whatever reason. This one is meant to be for the team only so they can voice concerns without the risk of alienating the client. This should occur on the first or second day of a new sprint, depending on the complexity of the project and how much time is needed for product backlog review with the client.

   3. Daily Standups: This is a double-edged sword for most teams. Especially with teams that have someone with a penchant for micromanagement. It’s needed so everyone has a chance to talk about what they are working towards and, more importantly, what troubles or roadblocks they are hitting. Keep these minutes to 15 minutes or less. Of course, in geographically distributed teams, you might need to account for ways for folks to achieve the goals of the daily standup but in an asynchronous manner. You might consider alternating weeks and sometimes schedule the meetings at the beginning and sometimes at the end of the workday so everyone has an equal chance of having to get up early or stay up late. Or use digital tools like a virtual sticky note board so team members in highly different time zones can provide feedback asynchronously. But seriously, 15 minutes at most!

   4. Design-Build-Test-Learn Loop: Think of this like a sub-loop that occurs almost every day after the standup. This is where the value-added work gets done. The engineers and designers should spend time designing and building (think rapid prototyping — breadboarding circuit, 3D printing models, updating the firmware). Then, test what they have worked on to see if it meets the requirements or specifications that the component, assembly, or subsystem is expected to meet. Lastly, learn from the failures. I think we need to call learn out specifically because in a world where the notion that “fail early, fail fast” is perhaps okay with pure software development, it’s a bit problematic with hardware, if for no other reason than cost. It’s OK to fail but we need to fail smartly. We must rigorously learn from our mistakes so that when we go back to the drawing board (e.g., start the Design-Build-Test-Learn loopover), we do so in an informed manner. This means documenting test results. Getting feedback. Making informed conjectures on what to modify in the design. Understanding the 2nd and 3rd order impacts of those potential changes. Then, picking the changes that have the best chance of producing success.

   5. Design Review: Now, in a proper scrum/agile framework, this is called the sprint review. However, I prefer design review because it puts the emphasis on the work, not the management process. We are doing a code or design review of the work to ensure compliance with requirements, specifications, standards, etc. This is for the clients to provide feedback as well to ensure we are on the right path. This is also a chance to let the team shine and show off their hard work. Your co-workers are the best line of defense against errors. That said, groupthink is accurate, and significant review milestones should have smart, external eyes to catch what the team may be blind to. Remember to reward in public. This also occurs on the last day of a sprint.

   6. Optional: Sprint Demonstration: Some teams might have concerns about doing what is perceived as an internal design review in front of a client. Some opt to hold a separate sprint demonstration to get feedback from the client. Think about the difference between verification and validation testing. See below. Just remember this is yet another meeting taking away time from the Design-Build-Test-Learn loop where most of the value-added work gets done. So proceed with caution. See bullet #20 below to convince you NOT to got this route. ;)

   7. Sprint Retrospective: I prefer to keep this one internal. It’s a chance for the team to air their dirty laundry and discuss what is working and what isn’t working, both technically and from a project management perspective. This also occurs on the last day of a sprint.

10. Test Driven Development. If from the very start, every requirement you write, every function you derive, every specification created, if it is written down from the perspective of how in the hell will I test this later, you tend to write better requirements, test plans, etc. Don’t forget the difference between verification and validation testing, too. Verification is “Did I build the system correctly (to specifications)?” versus validation, which is “Did I build the correct system (to meet customer requirements)?”

11. Also, Technician Driven Development. Remember after you have design and built the prototypes, eventually a factory worker is going to have to recreate your work in a distant location, a technician is going to have to service this equipment 20 years later. Remember all the people who will build, use, and maintain/repair the hardware you are building. Software is much more intimate. The idea creator also turns the idea into reality by producing source code. Once the code is written, it can be forever duplicated perfectly and for free. Not so with hardware. The idea creator eventually gives up the idea to a small army of people to bring the idea into tangible form. Even for something that is 3D printed, the STL or 3MF file might duplicate the design perfectly. Still, each printer it is printed on will have individual nuances that translate the idea into an imperfect physical representation. Keep that in mind,

12. Roman Space Shuttle Story. If you have never heard the story of how Roman Empire horses affected the design of the United States Space Shuttle. Go read this. The point is this. Software, more than hardware, gets to have a “tabula rasa” start; hardware rarely gets to start clean. If nothing else, things like UL and FCC certifications constrain hardware design.

13. Keep It Simple. Everything should be written so that an 8th grader can understand it. Requirements. Test Plans. Test reports. It’s like Einstein once said, to paraphrase, if you can’t explain it to a kid, you don’t understand it enough yet.

14. Build a Common Parts Library. To this day, I remember the laughter on Ralph’s face when I told my first boss I calculated I needed a 195.5-ohm resistor but didn’t see any in the supply room. Go on Mouser or Digi-Key or crack open a McMaster-Carr catalog. There is a metric shit ton of parts being made in this world. Don’t waste precious hours trying to find the best part. The best part is like the best camera; it’s the one you have on you when you see a gorgeous sunset. A common parts library cuts down on inventory, wait times, and engineers hemming and hawing over which screw is the perfect screw. However, a defined process should be in place to account for the fact that there will be times when a common part just won’t cut it, and there needs to be special procurements. Just make it the exception, not the norm.

15. Encourage Collaboration and Teaching: Something that really resonates with me regarding the Maker Movement is that it marries designing and building cool stuff with the need to teach and share with others what you have learned. That gets lost in traditional engineering teams. Set aside time each week for people to share or collaborate in a way that lets them let their hair down in a more risk-free environment than, say, a design review where everyone is perhaps a bit nervous. This mindset also encourages lifetime learning, which leads us to…

16. Cross-pollinate. Let the mechanical folks solder, and let the electrical folks turn a wrench. Let them both write some code. Engineers tend to solve problems from the perspective of their chosen disciplines. This may not always yield the best solution from a holistic perspective. Get the team outside their comfort zone so they can at least appreciate the challenges and general principles of other technical disciplines.

17. If possible, and I know it’s a luxury most can’t afford, have 2 or 3 teams develop prototypes at the same time as insurance. Once the customer down-selects a chosen preferred system, reallocate resources to do the work to go from prototype to production.

18. Embrace Desktop Manufacturing Tools That Get Out of the Way of The Engineer. Tools like 3D printers, laser cutters, and CNC mills need to do the job of getting the idea of the engineer or designer into his/her head into reality as quickly and as painlessly as possible. It’s like the desktop publishing revolution of the 1980s and 1990s when tools like PhotoShop and Apple II hit the market. They weren’t for developers. They were for artists. Desktop manufacturing is to engineers, just as desktop publishing was to artists. An engineer spending time fiddling to get his/her tools just to work properly is spending fewer hours on value-added work.

19. Don’t Forget About Safety. I am not saying that software development is risk-free. It’s just a lot less likely to result in injury than hardware development, especially when fabricating parts on machines or handling potentially noxious chemicals. Ensure a culture of safety is embraced. Especially with agile, where the perception is to go fast or go home.

20. Don’t Be Afraid to Let the Client See How the Sausage is Made: Here’s a fact. Design, engineering, fabrication, assembly, installation, maintenance, and repair are messy. It’s messy work to bring an idea into reality. Don’t be afraid of pulling back the curtain for the client. I am not saying that there needs to be 100% transparency; sometimes things like NDAs and IP can come into play, but for the most part, I’d rather have the client involved more, not less in the entire product development lifecycle.

21. Save Perhaps the Consumer Goods Market, Hardware Lasts A Long Time. People might update their smartphones yearly, but other markets and industries consider hardware purchase investments. They want their stuff to last. That said, component manufacturers can be fickle too, so your system needs to be designed and built to last but also to be reworked when the inevitable event of obsolescence of parts rears its ugly head.

22. Before We Sprint: In general, all software is going to be a thing that runs on a screen, maybe a touch interface, maybe a computer, and a mouse. Even if a piece of code runs silently on a server, there is at least a command line interface. So, in general, there are some safe assumptions with software. Hardware is not so. It can be anything. I could be building an electronic toothbrush or a military jet aircraft. And anything in between. That said, while agile is good at working in arenas with loose or evolving requirements, there needs to be some work done before sprints can start to define requirements in terms of cost, schedule, and performance expectations. Remember bullet #6 about slowing down to speed up.

23. Let The Team Self-Organize. In other words, throw out everything I just discussed if the team feels it won’t work and let their expertise guide you instead. People make the difference.

Let me say that again. In the end, it’s the people that matter. It’s the people that make a difference. Agile methodology, or any methodology, is only as good as the people implementing it. So what else did I miss? What are your thoughts on building hardware in an agile manner?

In an age defined by rapid technological advancement, complex global challenges, and evolving human needs, the lines between traditional disciplines of creation, production, and innovation are increasingly blurred. The fields of industrial arts, industrial engineering, industrial science, and industrial design intersect in a shared mission: creating functional, efficient, and aesthetically pleasing products and systems. Each discipline brings unique methodologies and perspectives, and their integration fosters innovation by blending craftsmanship, efficiency, research, and design thinking. At Green Shoe Garage, we pride ourselves on adopting the iDEAS Creative Philosophy — a cohesive, multidisciplinary approach to designing products, systems, and experiences. This philosophy seeks to harmonize creativity, functionality, efficiency, and sustainability, enabling solutions that address both human and planetary needs.

1. The Four Pillars of the iDEAS Creative Philosophy

Industrial Design: Human-Centered Aesthetics

Industrial Design prioritizes aesthetics, user experience, and human-centered solutions.

• Contribution: Shapes the interface between the product/system and its users.

• Core Principles:

  • Prioritizing ergonomics, aesthetics, and emotional resonance.

  • Bridging art and function to create products that delight and inspire.

• Role in Nexus Design: Ensures that every solution is not only effective but also engaging and intuitive for its intended audience.

Industrial Engineering: Optimizing Efficiency

Industrial engineering provides the systemic and process-driven perspective, ensuring efficiency, scalability, and system optimization:

• Contribution: Optimizes production and operational efficiency, ensuring scalability and cost-effectiveness.

• Core Principles:

  • Lean manufacturing, resource optimization, and systems thinking.

  • Focus on sustainability through waste reduction and energy-efficient processes.

• Role in Nexus Design: Ensures that solutions are viable and scalable while maintaining high efficiency and environmental responsibility standards.

Industrial Arts: Celebrating Craftsmanship

Industrial Arts celebrates the mastery of tools and materials, offering a hands-on, craft-centric perspective.

• Contribution: Hands-on expertise ensures designs are grounded in practicality and material reality.

• Core Principles:

  • Emphasis on skill, precision, and material understanding.

  • Preservation of traditional craftsmanship while embracing modern tools like CNC machines and 3D printers.

• Role in Nexus Design: Provides the human touch, enabling designs that are not only functional but also imbued with personality and authenticity.

Industrial Sciences: Driving Innovation

Industrial Sciences drive innovation through materials research, technology development, and empirical validation.

• Contribution: Develops new materials, processes, and technologies to push the boundaries of possibility.

• Core Principles:

  • Experimentation and empirical validation.

  • Integration of cutting-edge advancements such as IoT, AI, and biomaterials.

• Role in Nexus Design: Provides the innovative edge that keeps designs relevant and forward-thinking.

2. Key Intersections

Design and Prototyping

• Industrial Arts: Provides the hands-on skills and tools to physically create prototypes.

• Industrial Design: Guides the conceptualization and user-centric refinement of prototypes.

• Industrial Engineering: Ensures the prototype is manufacturable at scale, optimizing the production process.

• Industrial Science: Enhances prototypes by introducing advanced materials and validating performance.

Material Innovation

• Industrial Science: Researches new materials (e.g., composites, bio-materials) and their properties.

• Industrial Engineering: Develop efficient methods to incorporate these materials into production.

• Industrial Design: Explores the aesthetic and functional possibilities of innovative materials.

• Industrial Arts: Demonstrates the feasibility of manipulating these materials in real-world applications.

Smart and Sustainable Manufacturing

• Industrial Science: Investigates energy-efficient and eco-friendly processes, like additive manufacturing and renewable energy use.

• Industrial Engineering: Implements lean and sustainable practices to minimize waste and maximize efficiency.

• Industrial Design: Prioritizes sustainability in product lifecycle design, including recyclability and reduced environmental impact.

• Industrial Arts: Integrates traditional methods, such as upcycling, with modern sustainable technologies.

User-Centered Product Development

• Industrial Design: Places the user’s needs, ergonomics, and aesthetics at the forefront.

• Industrial Engineering: Ensures the product is practical, durable, and cost-effective for production.

• Industrial Arts: Adds a personalized, crafted touch to meet unique user demands.

• Industrial Science: Validates the product’s performance under various conditions, ensuring reliability and safety.

Integration of Technology

• Industrial Science: Develops cutting-edge technologies, such as IoT and robotics.

• Industrial Engineering: Optimizes workflows and systems to incorporate these technologies efficiently.

• Industrial Design: Envisions how technology enhances user experiences.

• Industrial Arts: Applies these technologies in tangible products, bridging creativity and functionality.

3. Core Tenets of the iDEAS Creative Philosophy

• Interdisciplinary Collaboration:

  • Foster collaboration between artisans, designers, engineers, and scientists to leverage diverse perspectives.

  • Encourage cross-disciplinary fluency to create seamless workflows.

• Holistic Problem-Solving:

  • Address technical, aesthetic, human, and environmental factors simultaneously.

  • View challenges as systems, identifying how individual components interact within larger contexts.

• Sustainability and Responsibility:

  • Commit to eco-friendly materials and processes, lifecycle thinking, and circular design.

  • Balance human-centric solutions with planetary stewardship.

• Iterative Creation:

  • Employ rapid prototyping and feedback loops, blending the artistry of industrial arts with the precision of engineering and the empirical rigor of science.

• Human and Planetary Needs:

  • Focus on creating solutions that improve quality of life while reducing environmental impact.

  • Integrate equity and accessibility into the design process.

• Digital Design and Hybrid Fabrication

  • Digitally design all aspects of a product, or at the very least, digitally capture all design work.

  • Select fabrication processes that best create tangible objects. Embrace both old-school craftsmanship (hand-made) and modern fabrication tools, such as 3D printing technologies (brain-made). Blend them together to make finished products. Always employ a hybrid fabrication mindset.

4. Benefits of Adopting the iDEAS Creative Philosophy

• Holistic Innovation: Combining industrial design's user-centered approach with engineering's technical precision and industrial arts' creative expertise fosters well-rounded solutions.

• Enhanced Collaboration: Cross-disciplinary teams benefit from diverse perspectives, blending artistic, technical, and scientific inputs.

• Optimized Systems: Industrial engineering ensures that products designed with artistic and scientific insights can be produced efficiently and sustainably.

• Informed Craftsmanship: Industrial arts practitioners can use the latest scientific materials and engineering techniques to elevate their craft.

• Sustainability: By integrating sustainable materials, energy-efficient processes, and lifecycle thinking, the collaboration addresses environmental concerns effectively.

5. Examples of Real-World Applications

Automotive Industry

• Industrial Arts: Crafting prototypes and aesthetic components.

• Industrial Engineering: Streamlining assembly lines and optimizing fuel efficiency.

• Industrial Science: Developing lightweight, durable materials like carbon fiber composites.

• Industrial Design: Shaping user-friendly, visually appealing vehicles.

Smart Home Devices

• Industrial Design: Creating sleek, intuitive interfaces and forms.

• Industrial Science: Incorporating IoT and sensor technology for connectivity.

• Industrial Engineering: Ensuring mass production is efficient and cost-effective.

• Industrial Arts: Adding artisanal touches like wood or metal finishes for premium appeal.

Wearable Technology

• Industrial Science: Innovating lightweight, flexible electronics and materials.

• Industrial Engineering: Optimizing manufacturability and durability.

• Industrial Design: Ensuring wearables are ergonomic and stylish.

• Industrial Arts: Personalizing designs with artistic flair.

6. Educational Implications

• Interdisciplinary Curricula: Programs combining the hands-on skills of industrial arts with engineering, science, and design principles. Create new programs that teach interdisciplinary thinking, blending hands-on craftsmanship with technical and scientific rigor.

• Project-Based Learning: Real-world challenges require students to collaborate across these fields.

• Makerspaces and Labs: Facilities equipped with tools for digital fabrication, prototyping, and testing to foster integrated learning.

7. Challenges and Opportunities

Challenges:

• Bridging the gap between creative/artistic disciplines and analytical/scientific ones.

• Ensuring accessibility to advanced tools and interdisciplinary education.

• Skill Gaps: Training individuals to work across disciplines requires significant investment in education and resources.

• Cost and Accessibility: Advanced tools and materials can be expensive, limiting widespread adoption.

• Integration Complexity: Aligning workflows from multiple disciplines can be logistically challenging.

Opportunities

• Developing hybrid roles such as "Creative Technologist" or "Design Engineer."

• Leveraging AI and machine learning to enhance collaboration across these fields.

• Promoting sustainability through combined expertise in materials, systems, and design.

• Global Impact: Address complex challenges like climate change through sustainable, system-wide solutions.

8. Future Directions

• Artificial Intelligence and Machine Learning:

  • Enhance design processes with AI-driven optimization and predictive analytics.

  • Support artisans in generating unique, data-informed creations.

• Biomaterials and Eco-Design:

  • Industrial sciences will continue to pioneer renewable and biodegradable materials.

  • Artisans and designers will explore the creative potential of these materials.

• Immersive Collaboration:

  • Utilize virtual and augmented reality to facilitate collaboration across disciplines and geographies.

• Circular Economy Models:

  • Focus on creating products that are not only recyclable but regenerative, aligning with nature’s principles.

Conclusion

The iDEAS Creative Philosophy is a forward-looking framework that merges the tactile artistry of industrial arts, the user-centric creativity of industrial design, the efficiency of industrial engineering, and the innovation of industrial sciences. The intersection represents a powerful convergence of creativity, functionality, efficiency, and innovation. By embracing the strengths of each discipline, this philosophy offers a pathway to creating functional, beautiful, sustainable, and future-proof solutions. It is a holistic approach to problem-solving and creation that addresses the many multifaceted challenges facing humanity and the planet today and tomorrow. By integrating these fields, we create products and systems that are efficiently made, affordable, practical, visually compelling, and sustainable.

For more about Green Shoe Garage and the services we provide, please visit our website.

Industrial Arts 2.0 represents a modernized version of traditional industrial arts, integrating advanced technologies, new materials, and contemporary design philosophies. It reflects the shift from a focus on manual craftsmanship to a blend of hands-on skills and high-tech innovation, catering to the demands of the 21st-century maker economy, smart manufacturing, and sustainable design.

Key Features of Industrial Arts 2.0

1. Advanced Tools and Technology Integration:

   • 3D Printing and Additive Manufacturing: Expanding the ability to create complex designs with ease.

   • CNC Machining: Precision subtractive manufacturing for prototypes and production parts.

   • Laser Cutting and Engraving: Allowing intricate designs in materials such as wood, metal, and acrylic.

   • Robotics and Automation: Training students and professionals in programming and operating robotic systems.

   • IoT and Smart Product Integration: Incorporating sensors, connectivity, and automation into products.

2. Emphasis on Digital Skills:

   • CAD and CAM: Advanced computer-aided design and manufacturing software, such as SolidWorks, Fusion 360, and Rhino, is central to Industrial Arts 2.0.

   • PCB Design: Using tools like KiCAD to design and integrate electronics into physical products.

   • Programming and Coding: Incorporating Python, C++, or JavaScript to enhance workflows or enable smart functionalities.

3. Blending Art, Design, and Engineering:

   • STEAM Education: Combining Science, Technology, Engineering, Art, and Math to foster creativity and innovation.

   • Generative and Parametric Design: Using algorithms to optimize shapes and structures for function and aesthetics.

4. Focus on Sustainability:

   • Teaching sustainable design practices, including material optimization, upcycling, and energy-efficient production techniques.

   • Emphasizing renewable materials and minimizing waste through technologies like additive manufacturing.

5. Expanded Scope of Materials:

   • From traditional wood and metal to modern composites, bio-materials, and carbon fiber.

6. Collaborative Learning and Open Innovation:

   • Makerspaces, Fab Labs, and coworking environments foster collaboration and innovation.

   • Embracing the Maker Movement, which emphasizes community-driven innovation and accessibility to high-tech tools.

Applications of Industrial Arts 2.0

1. Smart Product Design:

   • Designing IoT-enabled products with embedded electronics and connectivity.

2. Rapid Prototyping:

   • Quickly developing functional models for testing and iteration using tools like 3D printers.

3. Custom Manufacturing:

   • Producing one-off designs and small-batch products tailored to specific needs.

4. Sustainable Design:

   • Creating products with minimal waste using renewable or recyclable materials.

5. Artistic Exploration:

   • Blending technology and artistry to craft sculptures, installations, and high-tech furniture.

6. Industrial and Automotive Design:

   • Leveraging advanced fabrication techniques to create lightweight, optimized components.

Key Skills in Industrial Arts 2.0

1. Technical Proficiency:

   • CAD/CAM software, CNC programming, and additive manufacturing techniques.

2. Electronics Integration:

   • Designing PCBs, soldering components, and integrating sensors for smart systems.

3. Programming:

   • Writing scripts for automation, robotics, and IoT connectivity.

4. Material Science:

   • Understanding modern materials like composites, polymers, and bio-materials.

5. Creative Problem-Solving:

   • Applying design thinking to solve real-world challenges.

6. Technical Communication:

   • Writing clear documentation, including user guides, design specs, and technical reports.

7. Traditional Trades and Crafts:

   1. Traditional woodworking and metalworking skills, along with skills related to carpenters, electricians, plumbers, and other trades, are given renewed emphasis and are empowered with modern technology to aid the more traditional hands-on skills.

Examples of Industrial Arts 2.0 in Action

1. Makerspaces and Fab Labs:

   • Community-driven spaces equipped with 3D printers, CNC machines, and other tools for public use.

2. Startup Innovation:

   • Entrepreneurs prototyping and launching products using digital fabrication tools.

3. Education Integration:

   • STEAM programs teaching students how to combine creativity, design, and engineering with technology.

4. Sustainability Projects:

   • Designing products with renewable materials and circular manufacturing principles.

Careers in Industrial Arts 2.0

1. Digital Fabrication Specialist

2. Smart Product Designer

3. Parametric Design Engineer

4. Sustainable Manufacturing Consultant

5. Additive Manufacturing Technician

6. CNC Programmer and Operator

7. IoT Product Developer

8. Makerspace Manager or Instructor

Conclusion

Industrial Arts 2.0 represents the future of hands-on creativity, merging traditional craftsmanship with cutting-edge technologies like 3D printing, IoT, and robotics. It provides a pathway to innovate while emphasizing sustainability, collaboration, and modern skill sets, making it essential in today’s rapidly evolving maker economy.

I threw ChatGPT a little challenge and asked for a proof-of-concept attempt at creating a Python script that takes a 3D model in STL format (the buck) and automatically generates a negative space mold that can be 3D printed and used for hot wax copies of the original.

The code is here on GitHub.

It is run by the following command:

#python3 ./makeMold.py <inputFileName>.stl

The output will be two new STL files; they will be named <inputFileName>_mold_top.stl and <inputFileName>_mold_bottom.stl.

It defaults to a wall thickness of 10mm but can be edited in the code. In the future, I want to update the script to take certain parameters, such as wall thickness, from the user on the command line, such as:

#python3 ./makeMold.py <inputFileName>.stl —thickness 10.0

Also, I am not happy with the placement of the keys and recesses to ensure alignment, nor am I happy with where the pour spout is created. Those will be improved. But it works good enough for now.