Her code got humans on the mood

Before reading this article, I didn’t know anything about Margaret Hamilton, even though she is the person who basically laid the foundation for software engineering. She literally wrote the code that made Apollo 11’s Moon landing possible, and yet people didn’t realize how groundbreaking that was at the time.

It wasn’t just because she was a woman in tech, but because no one had really seen software engineering as a real discipline yet. It made me think about how when something revolutionary happens for the first time, people often don’t give it much credit because they have no prior knowledge/understanding.

One moment from the article that i remember the most was when Hamilton insisted on including error-handling in the code, even though others thought it wasn’t necessary. During the actual Moon landing, those systems kicked in and saved the mission from being cancelled. It made me think about how forward-thinking she had to be planning for what could go wrong. It also reminded me how invisible certain kinds of work can be. Her code wasn’t  visible like the rocket itself, but without it, none of it would’ve worked.

Attractive things work better

In the entire design industry, one area I’ve always had the most interest in was human-centered design. The idea that “products designed for use under stress follow good human-centered design” as stress makes people less good at problem-solving stood out to me. It made me think of when I myself am doing something in a hurry, and if something isn’t designed for ease of access, it forces me to slow down and spend extra effort on something that could be simplified. Whereas products designed for relaxed occasions can enhance usability through aesthetic design. So, it means that if we were to compare those two, usability would prevail over attractiveness.

However, after reading Norman’s article, my perspective shifted. He argues that attractive things work better, not because they have superior functionality, but rather because their visual appeal creates positive emotions that improve cognitive performance, especially in problem-solving.

So, aesthetic appeal can directly support usability, especially under stress. For instance, when I use confusing interfaces (especially when I’m in a hurry), I feel frustrated and mentally over the place. In contrast, using a clean, beautifully designed app like Notion makes tasks feel manageable, even enjoyable, despite any pressure. This made me think about the psychological aspect of good design and that it’s not just about how things work, but how they make us feel.

Concept

When thinking about this project, I wanted to solve a problem that I constantly deal with. I often bring a different bag or wallet everyday, meaning I have to move all my cards and items to the other bag. However, whether it’s my credit card, metro card, or student ID, I always realize too late that I left something in my other bag and it’s frustrating to get to the subway and not have my metro card or to be at a café and realize my credit card is missing.

So,  to fix this, I created a simple switch that tells me if my card is in my wallet. The idea is straightforward, if the card is inside, the circuit is complete, and the LED lights up. If the card is missing, the circuit remains open, and the LED stays off, reminding me to grab it from the other bag before I leave.

Here is a quick demo: IMG_5445 

 

Implementation

To build the circuit, I mainly based it off of the switch circuit we went over in class, however instead of the button I used two wires, one connected to my wallet and the other to my metro card. I then placed a thin conductive strip of aluminum foil inside my wallet as well as  on the metro card to make sure that when I insert the card  it completes the circuit, turning on the LED. This way, I can quickly check if I have everything just by looking at the light, no need to rummage through my bag at the last second.

Below is the code I used:

int wireTouch = A2;

void setup() {  
  pinMode(11, OUTPUT); 
  pinMode(wireTouch, INPUT);   // Button input
   Serial.begin(9600);

}

void loop() {
 int touchState = digitalRead(wireTouch);
 Serial.println(touchState);
  delay(1); 

  if (touchState == HIGH) {
    digitalWrite(11, HIGH);  // Turn LED ON if wires touch
  } else {
    digitalWrite(11, LOW);   // Turn LED OFF if wires don't touch
  }
}

Reflection

I think building this project was a fun and practical way to apply the switch circuit we learned in class to a real-life problem. I am pretty happy with the result as the circuit worked as expected, when the card was inside the wallet, the LED turned on, and when it was missing, the light stayed off. However, one challenge I faced was ensuring the conductive strips inside the wallet aligned properly with the card. At first, the connection wasn’t always reliable, and the LED flickered. I had to adjust the placement and use stronger adhesive to keep the strips in place.

In terms of improvements and additional elements, I could maybe add an LCD, so  instead of just the LED turning on or off, an LCD display could show a message like “Card Present” or “Card Missing,” which would provide a clearer and more informative response. A sound alert could also be useful, I could add a small buzzer so that it gives a short beep when the card is missing or inserted, providing a more immediate and noticeable notification.

Concept

I have a little jewelry plate that I try my best to put all my jewelry on at the end of the day so that it is easier to find them next time. However, sometimes I forget to put my jewelry on it, especially my ring, and then I would have to look around to figure out where I put it last time.

This became my inspiration for creating my unusual switch – to remind myself to put my ring where it is supposed to be. When the ring is put on the plate, it closes the switch circuit and turns on the LED bulb!

My hands are involved in operating this switch, but not in the traditional sense, as it is the ring that is acting as the switch and is the main object, so I decided to continue with the idea.

Video demonstration

Implementation

I mainly referred to the switch circuit we saw in class to build my circuit. There are 2 exposed wires on the plate that are not touching. One of the wires is connected to the digital pin 2 and pin 2 is connected to GND with a 10k resistor in between. The other wire is connected to 5V. When the copper ring is put on the 2 wires, it acts as a conductor and closes the circuit.

digitalRead is used on pin 2 to detect when the switch circuit is open or closed. When the circuit is closed (ring is on the plate covering both wires), the LED lights up, and vice versa.

const int switchPin = 2;
const int ledPin = 13; 

void setup() {
  pinMode(switchPin, INPUT);
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  // read switch state
  int switchState = digitalRead(switchPin);
  if (switchState == HIGH) {
    // turn the LED on when switch is closed
    digitalWrite(LED_BUILTIN, HIGH);
    Serial.println("Ring detected! Circuit closed.");
  } else {
    // turn the LED off when switch is open
    digitalWrite(LED_BUILTIN, LOW);
    Serial.println("No ring detected. Circuit open.");
  }
  delay(100);
}

Challenges and Future Improvements

This week’s project helped me to get a lot more comfortable with building circuits and working with Arduino. I still had to refer back to the schemes we saw in class but I am sure I will get confident to build circuits on my own as we progress.

One of the mistakes I did this week was getting straight into building my circuit before reading again the project description. I glossed over the fact that we had to use digitalRead to get the state of the switch and do something with it. I initially built a circuit with a 330 resistor and an LED that simply closes when the ring is placed and causes the LED to light up, so initially there was no switch at all . After reading through the requirement, I modified the circuit such that there are 2 segments to the circuit: 1) LED circuit that is closed, and 2) switch circuit connected to 5V and a digital pin with a 10k resistor in between that is open and gets closed with the ring. Whether the LED lights up or not depends on the open/closed state of the switch circuit.

As I now write this documentation, I wonder if it would have been more intuitive if the LED turns off when the switch is on (when the ring is placed on the plate), so as to have the lit-up LED as a reminder to put my ring on the plate. Though this change does not alter the concept of the project, I think it makes it more meaningful in terms of usability and intentions. I hope to be more intentional with my future projects; to make things that are well thought out and build things that do actions for a reason, not just for the sake of it.

Her Code Got Humans on the Moon

The story of Margaret Hamilton and her contributions to the Apollo mission’s success highlights perhaps the most important aspect in coding: error-proofing. When I was first introduced to coding through the Intro to CS course, I remember thinking it was silly to write extra lines of code to simple programs for error handling, i.e. if conditions to prevent from wrong input type being passed, when it seemed so obvious that such cases wouldn’t happen.

I have now come to realize, from taking more CS courses and practical experiences, that there will always be bad actors and mistakes are bound to happen. A key responsibility of software developers is to minimize potential failure points and handle them gracefully to make the system robust and prone-to-failure. Murphy’s law reflects the importance of anticipating all possible error scenarios and designing software that can withstand them.

The monumental Apollo mission could have ended in failure due to the absence of error-checking code, had it not been for Hamilton who identified the issue, and her team who found a fix just in time. It is always better to be safe than sorry, and not adding that few extra lines of code could potentially cost way more than we realize.

Attractive Things Work Better

This reading was very very interesting. Even before I read the piece, I silently agreed with the title, that attractive things work better. I have been learning to appreciate and be consciously aware of design of everyday objects around the house, mostly through seeing well designed pieces on my social media and watching videos that break down designs and their intentions behind them. I realize that a good design can truly elevate the user experience, especially now having read the points made by Norman about how positive affect created by good design can actually streamline the efficiency and usability of an object.

Norman’s argument that creative design is not always preferable, and that it depends on the seriousness and urgency of the situation was very insightful and made me reflect on how I personally interact with things. When I am in an extreme hurry (like extreme extreme) or madly stressed, I can not function at all — I find it hard to do some of the things that I can normally do without even thinking, whether that is writing text messages or opening a bottle of drink or tying my shoes. It is not dependent on the design of things; rather it is due my own state of mind. As Norman explains, in these high-stress situations, design should not interfere and instead be highly-tailored and easy to follow. This was an interesting statement that reminded me that intricate design is not always needed and wanted, and sometimes the simple things are indeed the better.

My Concept

For a while, I couldn’t come up with a creative idea. As I sat at my desk, I looked over at my surroundings and saw some books piled up from hours of studying, realizing I could use them as a switch.

A “Break Reminder Switch” activates when I close my books, triggering LED light to remind me to take a well-deserved break. And if you’re too tired, you can also use your head to activate the switch by resting it on top of the books.

Watch the video here

When thinking about the idea of my switch, it reminded me of a Pomodoro Studying Technique. I could improve this project by adding a timer that lets users take breaks for a set amount of time, like 5 minutes, before an alarm reminds them to get back to studying. This way, they can study for as long as they like and use the switch to manage their own breaks without losing track of time.

Set-up

I attached jumper wires to the covers of two books — one connected to GND, the other to a digital pin on the Arduino. When the books close, the wires touch and make the LED light up.

Initially, the wires didn’t always make good contact, so I adjusted the wire positions by twisting and aligning them at the center and opposite to each other to ensure they touch properly and trigger the switch.

Coding

int switchPin = 10;    
int ledPin = 6;        

void setup() {
  pinMode(switchPin, INPUT_PULLUP);  
  pinMode(ledPin, OUTPUT);
}

void loop() {
  if (digitalRead(switchPin) == LOW) { 
    digitalWrite(ledPin, HIGH);      
  } else {
    digitalWrite(ledPin, LOW);          
  }
}

Reflections

At first, I struggled for hours trying to get the external LED to light up. The issue was that I didn’t plug the short leg of the LED into the negative rail on the breadboard — this made only the internal LED light up. Then, it was the way I set up my project that kept causing problems.

I also learned that wire contact must be firm, so I tried different taping angles and even thought about using multiple wires for a better chance of contact.

Through all the trial and error, I realized how small details can cause big issues and that paying attention to them can save hours of frustration. Most importantly, I learned that good ideas often come from your surroundings, even something as simple as a stack of books.