Category: F2024 – Mang

Her Code Got Humans on the Moon

The reading on Hamilton’s journey and the early days of computer programming highlights some important points about physical computing. The reading shows how important the software was in the Apollo mission and the project was  very complex and expensive. Therefore the designed software was to be very accurate  leaving no room for errors as they would be extremely expensive and could  even cause the entire mission to fail. As I look forward to the second half of this course, where we’ll work on physical programming, I plan to approach my projects with similar care, knowing there’s little room for errors. I hope to use strategies to avoid mistakes, like how the Apollo mission used simulations to test things before putting designs into the project.

Norman,“Emotion & Design: Attractive things work better”

The reading caught my attention with its focus on how emotions, aesthetics, and usability affect designs. The idea that “attractive products are not just nice to look at; they also work better because they make people feel good” really stood out to me. It reminded me that when I create my own designs, I should encourage people to explore them.  One approach could be adding elements that spark curiosity  and  raise questions like “How does it work?” while offering hints for exploration.

The idea that, when people feel good, they are often more flexible and creative, leading to better interactions with products,  made me think about how designing attractive designs can also boost user engagement and functionality. Based on this for my upcoming projects, I hope to create designs that mix good looks and usability to build a stronger connection with users, making the experience more enjoyable and improving overall satisfaction.

Concept

For this week’s assignment, I designed a simple switch to be positioned in front of a screen, like a laptop. This switch uses an HC-SR04 distance sensor and an Arduino board to control either a red or green LED. When the user is at a healthy distance from the screen—set to 50 cm or more—the green LED lights up. If the user gets too close, the red LED turns on as a warning to move back. This setup helps promote good screen-distance habits to protect eye health.

To implement the logic, I modified an example code for Sensors from the Arduino IDE. Below is a demonstration video for my switch.

Code

void setup() 
{
  // initialize serial communication:
  Serial.begin(9600);
  pinMode(trigPin,OUTPUT);
  pinMode(echoPin,INPUT);
  pinMode(GreenLED, OUTPUT);
  pinMode(RedLED, OUTPUT);
  
}
void loop() 
{
  long duration, inches, cm;
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  cm = microsecondsToCentimeters(duration);
  Serial.print(cm);
  Serial.print("cm");
  Serial.println();
  // Controlling LEDs from Distances
  if(cm<50 )
  {
     digitalWrite(GreenLED, LOW);
     digitalWrite(RedLED, HIGH);
  }else
  {
   digitalWrite(GreenLED, HIGH);
  digitalWrite(RedLED, LOW);
  }
  delay(100);
}

long microsecondsToInches(long microseconds) 
{
  return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds) 
{
  return microseconds / 29 / 2;
}

 

Reflection for future works

I have gained knowledge on how Simple switches are fundamental devices used to control the flow of current in a circuit.  It was also interesting to use the HC-SR04  sensor and see how it works. Going forward, I hope to use switches in combination with other logics to design complex and interesting projects.

Her Code Got People on the Moon

Hamilton has made imperative and remarkable contributions to the field of space. As the director of the Software Engineering Division at MIT’s Instrumentation Laboratory, Hamilton led the team that developed the on-board flight software for NASA’s Apollo missions, including the historic Apollo 11 moon landing. 

Margaret Hamilton’s contributions to the Apollo program and computer science have been widely recognized and celebrated. She coined the term “software engineering” to elevate the field and give it the respect it deserved alongside other engineering disciplines. Hamilton’s story not only highlights the crucial importance of software development in the success of the Apollo missions but also sheds light on the often-overlooked contributions of women in the early days of computer science and space exploration. Her pioneering work and leadership helped pave the way for future generations of software engineers and computer scientists.

 

Attractive things work better

The idea of the reading is simple – if you want to achieve great results in your product development, good design and usefulness should go hand in hand. However, most people forget about it and mess up one of the parts. I saw many ideas that were great but lacked design and attractiveness. As an example, I can take the startup competition. The team with a great idea but a bad slide deck design and pitch can easily lose to the team with a great slide deck and pitch, even though the latter might have an idea that is technically worse for implementation.

I would also like to mention that design can play a crucial role in marketing. As I have learned from one great professional, marketing is a systematic creation and capture of value. While value can be perceived straightforwardly as a utility and purpose, it can also mean something aesthetically pleasing or something that is very well differentiated from other ideas or products. It is important to remember that we are, after all, human beings, and our emotions and feelings can sometimes play a crucial role in deciding what is worth purchasing, using, wearing, etc. Thus, a great design can be a decisive factor for a customer to buy your product while encountering your advertisement.

Her Code Got Humans on the Moon

I was impressed by what I learned from reading this article. Margaret Hamilton basically saved the Apollo mission and also opened the door to the world of computer engineering. I am sure that many people still do not know about this fact, and this is true that the role of women in the STEM field was underrepresented throughout the 20th century and before, not to mention that educational opportunities became available for women much later than for men. Nowadays, this is being changed and many women have a chance to contribute to the development of science. Talking from my personal experience, I know a lot of women in science, particularly in space development and exploration fields in my country, Russia. Even in the 20th century, there were female astronauts, physicians, and mathematicians. Although their role and contribution might not be as significant as the one of Margaret Hamilton, they all also played a role in empowering women in STEM in my country.

 

 

PROJECT: UNUSUAL SWITCH

For this unusual switch project, I conceptualized a system where clicking or snapping my fingers would activate an LED light. This idea explores novel ways of interacting with electronic devices using natural gestures.

Components Used:

Arduino board: Used to control the circuit and process inputs

LED: The light source activated by the finger snap

Resistor (330 ohm): To limit current flow and protect the LED

Jumper wires: For making connections between components

Copper tape: Used as a sensor to detect the finger snap without a traditional button

REFLECTION: 

• Importance of resistors: I initially forgot to add a resistor, which resulted in the LED burning out. This made me understand the critical role of resistors in protecting sensitive components.

IMG_7912

The reading “Emotion & Design: Attractive Things Work Together” presents a compelling argument about the interplay between emotion, design, and usability, particularly emphasizing that attractive things work better. This resonates with my own experiences and observations in various contexts, such as product design and user interfaces. For instance, I have noticed that when using a software like a food delivery app with a visually appealing interface, I tend to feel more satisfied with the experience, even if the functionality is similar to less attractive alternatives.

On the other hand, the reading “Her Code Got Humans on the Moon” has shifted my perspective on the historical significance of software engineering. I had previously viewed software as a more modern development, but the article illustrates how foundational work was being done as early as the 1960s. Additionally, the reading raises several questions for me. How did Hamilton’s experiences as a working mother in a male-dominated field influence her approach to software development? Furthermore, how can we ensure that the contributions of women and other underrepresented groups in technology are recognized and celebrated in contemporary narratives? These questions highlight the need for a more inclusive history of technology that acknowledges diverse contributions.

Project Overview

This project is a hands-free, light-activated night light designed to automatically turn on an LED when it’s dark and turn it off when it’s light. Using a light-dependent resistor (LDR) as a sensor, the circuit detects ambient light levels and toggles the LED accordingly. This is ideal as a night light or as an indicator light in dark conditions.

Materials Used

• Arduino Uno: The microcontroller board used to control the circuit.
• Jumper Wires: For making connections between components.
• Resistors:
  • 330 Ohm resistor (for the LED, to limit current).
  • 10k Ohm resistor (as a pull-down resistor for the LDR to ensure stable readings).
• LED: Acts as the night light, illuminating when ambient light is low.
• Light-Dependent Resistor (LDR): Detects the light level in the environment and changes its resistance accordingly.
  

  Arduino Code

  The following code reads the light level from the LDR and turns the LED on when the light level drops below a specified threshold (indicating darkness) and off when the light level is above this threshold (indicating light):

int ldrPin = A0;           
int ledPin = 9;           
int threshold = 500;       

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

void loop() {
  int ldrValue = analogRead(ldrPin);  
  Serial.println(ldrValue);           
  
  // Check if the light level is below the threshold
  if (ldrValue < threshold) {
    digitalWrite(ledPin, HIGH);  
  } else {
    digitalWrite(ledPin, LOW);   
  }
  
  delay(100);  
}

Improvements

• • Automatic Brightness Adjustment: Incorporate PWM to adjust the LED brightness gradually based on light levels, creating a dimmer effect in low light.
  • Sensitivity Adjustment: Experiment with different threshold values based on the ambient light conditions in various environments. This ensures accurate and responsive behavior.

Video Demonstration

Small things overlooked

We often overlook small details and focus too much on assumed important features such as usability or practicality. In the reading “Her Code Got Humans on the Moon”, the suggestion to put a warning on a project was disregard because the assumption that the users are trained enough. This resulted in a disastrous problem, deleting all data when the astronauts actually press it. I think this example is similar to small lines of code or comments that we often consider insignificant. These parts may not make a project immensely better, but without them, issues could arise, as seen in the astronaut example.

Another takeaway from the reading is the importance of not making assumptions about users. Good design should account for worst-case scenarios or consider the perspective of someone with no prior knowledge of the product.

Similarly, Norman’s reading said that small details like warnings or the aesthetics of an interaction may not add specific usability to an object. However, it’s important to view design from multiple perspectives, not just functionality. While it’s logical to prioritize functionality, good aesthetics can sometimes offset weaknesses in other areas. In some cases, strong aesthetics prompt users to engage more based on emotional appeal rather than logical reasons. A good example of this is the vintage trend, such as using vinyl records or old flip phones. While these items don’t offer more functionality than recent models, they attract users by evoking nostalgia and a unique aesthetic.

intro

How tough can designing a switch be? Presumably not much—but it’s the contrary. While the circuit to utilize a switch may be one of the simplest ones in the electronics world, to what extent can that switch ‘make sense’ as well as be creative and ergonomically intuitive? From the distance-triggered switch I rushed in class to a coin-classifier that utilizes the different diameters of different coins, both of these prototypes I made in the course seem too ‘basic’ in terms of being so realistic (aka. boring). At the end of the day, setting off from the concept of ‘using body parts,’ I came up with the idea of a ‘Sleepiness Detector’ that would act as an automatic alarm (visually with LEDs and sonically with a buzzar) when the user (if there is one) closes their eyes.

process

Although the first two prototypes are discarded, I would still give credit to them here as a chronicle:

Still, the second prototype did give me some inspiration about using the conductive fabric to form the later artificial eyelids. While the code below is relatively simple, I would say the most difficult part of this product is to ‘install’ artificial eyelids to my eyes—maybe this is where collaboration was a necessity.

/*
+---------+               +--------+
| Switch  |  eyes         | LED R  |
|         |               |        |
| Terminal|--- Pin 2 ---  | Anode  |--- Pin 9 (Arduino)
|         |               |        |
| Terminal|--- GND        | Cathode|--- GND (through 220Ω resistor)
+---------+               +--------+
                         
                         +--------+
                         | LED G  |
                         |        |
                         | Anode  |--- Pin 10 (Arduino)
                         |        |
                         | Cathode|--- GND (through 220Ω resistor)
                         +--------+
                         
                         +---------+
                         | Buzzer  |
                         |         |
                         | Positive|--- Pin 11 (Arduino)
                         |         |
                         | Negative|--- GND
                         +---------+
*/

#define SWITCH_PIN 2   // Pin connected to the switch
#define RED_LED_PIN 9  // Pin connected to the red LED
#define GREEN_LED_PIN 10 // Pin connected to the green LED
#define BUZZER_PIN 11   // Pin connected to the buzzer

void setup() {
    pinMode(SWITCH_PIN, INPUT_PULLUP); // Set switch pin as input with pull-up resistor
    pinMode(RED_LED_PIN, OUTPUT);       // Set red LED pin as output
    pinMode(GREEN_LED_PIN, OUTPUT);     // Set green LED pin as output
    pinMode(BUZZER_PIN, OUTPUT);        // Set buzzer pin as output
}

void loop() {
    // Read the state of the switch
    int switchState = digitalRead(SWITCH_PIN);

    if (switchState == LOW) { // Switch is ON (active low)
        digitalWrite(RED_LED_PIN, LOW);      // Turn off the red LED
        digitalWrite(GREEN_LED_PIN, HIGH);   // Turn on the green LED
        tone(BUZZER_PIN, 1000);              // Play sound at 1000 Hz
    } else { // Switch is OFF
        digitalWrite(RED_LED_PIN, HIGH);     // Turn on the red LED
        digitalWrite(GREEN_LED_PIN, LOW);    // Turn off the green LED
        noTone(BUZZER_PIN);                   // Turn off the buzzer
    }
}

schematics & illustration

Both of the graphs are generated with TinkerCAD

Product Demo

Hindsight

Obviously, the method I used to install eyelids was not wise enough to replicate easily. If this is actually to be a thing, then there must be some more mature way to detect if eyes are closed.

It’s all about the balance – right?

Aesthetics vs. function, durability vs. lightness, artistic vs. technical—it’s so easy to fall into a binary mindset. To some extent, my intuitive argument would be: ‘Yes, that indeed makes life easier—but in terms of?’ While we humans like clear frameworks and roadmaps to navigate through the complexities, it seems that at the end of the day, despite the urge to simply pick a side (or polarize, in a fancy way), things—in many cases—turned out the most favorable when we took a step down and found the middle ground.

In fact, it seems quite contradictory to me, especially considering Norman’s arguments as a whole: yes, we tend to be hard-headed and pick sides intuitively, and the ‘fact’ seems to praise the balanced, but to perceive that balanced beauty/harmony/coherence or whatever induced, it comes back to our first-hand perception system (or effects in Norman’s words).

Okay, I’ll try to step down from delving into the philosophical rabbit hole. However, maybe more practically, how can these inquiries benefit our—or my—practice? From poetry to music to tennis, I constantly struggle between the fine lines. And now, not surprisingly, but ‘coding’ turned out to be the same. If I am to name a takeaway from this, then although I may not be able to point out a solution to any of the fields at the point or even forever, it must be, again, transforming the mindset:

When we use the term balance, what’s its connotation? If something, two or more, needs to ‘be balanced,’ at least it sounds to me that we are assuming that those things are intrinsically conflicting to some extent. But what if they do not conflict with each other in the first place? I’m not saying that this is the new version of ‘fact’ but suggesting maybe we should try to get rid of that guggling mindset and try as hard as possible to really, really look at what we are dealing with as a whole.