00:00:24.720
Good morning, everyone. My name is Bradley Grzesiak, and I am the CEO of Bendyworks. Today, I'm going to share a few ways to simplify your challenging software problems using rocket science, of all things. You can find me on the internet as "bradgrzesiak" pretty much everywhere. I'm going to start off by sharing a quote from my friend Ash, who said, 'Whenever Brad is drinking, you want to make sure you're sitting next to him, because instead of being obnoxious, he teaches you orbital mechanics.' The thing Ash doesn't know is that you don't actually have to feed me beer to learn that.
00:00:37.920
So after my talk, at any time during the conference, if you want to learn all about rocket science, feel free to ask me. Just a quick note for anyone who has visual issues: there will be one animated GIF; it's pretty mild, so hopefully, it won't cause any issues. Today's agenda consists of three parts. First, I'm going to teach you how we in the aerospace industry reduce cognitive load. Second, we'll see how to visualize simulations with graphics, and lastly, we will discuss how to control and respond to real-world processes.
00:01:07.840
I worked for an aerospace company for a bit over five years, and during that time, nothing I worked on ever went to space. Then, five years after I left that company, something I worked on finally did go to space, so I do have some basis here. Let's begin by discussing how to reduce cognitive load. The main thing to understand is that we, as rocket scientists, are not actual superheroes. We just followed a structured path in school that taught us bit by bit what we needed to learn. Just like you in your programming careers have done the same, we learned tricks and techniques to tackle really difficult problems.
00:01:44.000
One of the main ways we do that is by using higher levels of abstraction. If that sounds familiar at all to you, in programming, we typically use higher-level abstractions for dealing with things that are engineering-like or graphics-like. For instance, in programming, we'll often use simple primitives such as x, y, z for position. If we need to find the magnitude of a vector, we might use square root and Pythagoras' theorem. When we need to add two positions together, we might use zip plus map.
00:02:09.760
When it comes to rocket science, we've solved these issues mathematically, so instead we use matrices and vectors. You can simply find the magnitude, which is built into the Ruby standard library, if you require the right library. On the third line, you can see vector one plus vector two. If you use regular Ruby arrays, that will just concatenate them, resulting in a six-element array instead of an array of three, which is completely useless if you're trying to add vectors. Similarly, multiplying a matrix by a vector is really hard with just standard Ruby. But if you use the right libraries, you can just perform the multiplication.
00:02:59.200
The interesting thing about the multiplication of matrices and vectors is that the term 'times' is actually one of the most complicated terms in this context because it is overloaded in mathematics. A vector is essentially an array, and a matrix is an array of arrays. Now, let's discuss why we would ever want to use matrices and vectors in computer science problems. They are primarily used for linear transformations, which we see frequently but are simplified for our use to be more easily accessible as programmers.
00:03:55.920
For example, in CSS3, you have the transform key and can apply scale, rotate, and skew. Under the covers, these transformations are actually using a matrix times a vector. In rocket science, we often utilize this concept in kinematics and kinetics. I'm going to show you how a matrix interacts with a vector. To make it easier to understand, I'll simplify it to two-element vectors and matrices instead of three, which we would typically use.
00:04:28.000
The way I remember manually multiplying a matrix by a vector is to take the vector, rotate it up, and pass through the multiplication and vector addition as you proceed through the matrix. It's actually very simple. Fortunately, we use higher levels of abstraction, so we never have to implement this manually. If you were trying to do this from scratch in Ruby, you might implement it on the left; however, the standard library has a library called 'matrix.' You can just pull that in, which includes both matrices and vectors.
00:04:55.920
The nice thing is you don't even need a matrix times vector method because you can literally just multiply them together. This functionality takes care of dimensions for you. If your dimensions don't match up and you try to multiply them, your solution on the left might accidentally multiply them together without raising an error, while on the right it will notify you of a mismatch. One example of a linear transformation is the rotation matrix. Although it includes some trigonometry, you do not actually have to implement it manually; it's integrated into the libraries.
00:05:51.600
If you take the rotation matrix and set theta for a 30-degree rotation times a vector of (1,0), it converts the coordinates to approximately (0.866, 0.5). You can see the results if you have a 90-degree rotation. In summary, if you want to rotate something by 30 degrees, you can think of it as treating an image as a long vector. This is how we reduce cognitive load by utilizing tools provided by mathematics and maintaining higher-level abstractions.
00:06:06.240
Whenever you transform something in the domain of the real world and want to simulate it on a screen, you can utilize linear transformations, matrices, and vectors. Moving on, we're going to talk about visualizing simulations with graphics. Why would we want to do this? The main reasons I can think of, which I used back in my days as an aerospace engineer, include dealing with complex systems where there is high sensitivity to inputs. If you change one parameter slightly, it can lead to catastrophic failures.
00:06:56.000
For example, consider a screw hole close to the edge of a plate: if you shift it just a bit too far, the whole assembly could fail. Another reason is that there is often a need for pattern recognition, which computers are terrible at, while humans are good at it. Additionally, we typically look for solutions that are 'good enough.' It doesn't have to be perfect, but we want to avoid critical failures. In software engineering, you can equate this to testing: we operate with complex systems that have high sensitivity, and one mistake in your code can lead to test failures.
00:07:28.960
In aerospace engineering, we used graphical simulations to implement all these concepts. When launching an object into space, it faces numerous frequencies at various magnitudes, with the engines producing significant noise that affects the entire structure. As speed increases within the atmosphere, the craft experiences 'max q,' which refers to the point of highest aerodynamic load that can lead to significant shaking of the vehicle due to vibrations.
00:08:00.880
Rocket designers have established spectral analyses. If you place an object on a rocket, you can predict what to expect in terms of stress and vibration. This highlights the importance of simulations in understanding how things will behave under real-world conditions, such as zero-gravity conditions, where simple actions like kicking can produce significant effects.
00:08:32.239
NASA faced thermal equilibrium challenges early on with satellites. Typically, one side faces the sun while the opposite side cools down, leading to heat management issues, which NASA notably addressed using innovative heat pipe technology. The goal is always to account for safety factors, ensuring that structures can endure stress beyond normal limits. Lastly, the 'n-body' orbital mechanics, studying how bodies interact via gravitational forces, is academically fascinating. The n-body problem is driven by Newton's three laws, with most practical solutions deriving from a binary basis.
00:09:30.480
Closed-form solutions exist only for two-body systems. As you introduce more bodies, the complexity increases, and very few predictable motions arise unless specific conditions apply. Thus, the n-body problem poses challenging questions that even experienced mathematicians find hard to resolve. The fundamental components needed to evaluate the n-body problem include understanding the force of gravity and how various laws of motion intertwine to define acceleration, velocity, and position. Each concept must consider vector representation, as highlighted earlier.
00:10:27.920
To simplify these systems for better comprehension, we focus on the basics surrounding derivatives and calculus. In essence, derivatives help assess changes in position and velocity over defined time intervals. We can assume small time increments yield insightful approximations regarding velocity and position adjustments over time. This approach makes complex understanding more manageable, with division at the forefront of most calculations.
00:11:08.000
Let's illustrate this with Ruby, a programming language where clear-cut representations make handling these mathematical components far easier. The key takeaway is focusing on the 'gravity' aspect of these algorithms. Although the physics might seem daunting due to the complexities of instantaneous force build-up, ultimately, implementing these lines in a program can appear quite straightforward to those familiar with the language.
00:12:14.000
I'm going to demonstrate this with a simulation that features celestial bodies interacting in real-time. Using graphical representations as physical analogies offers tangible representations of our theoretical computations. Beyond merely computational, these examples yield a visual understanding of how celestial mechanics function so elegantly, even while adhering to relatively simple mathematical equations governing their interactions.
00:13:13.600
As I demonstrate the simulation, you’ll see the sun, Jupiter, and a comet traveling through space. You will observe interactions play out in real-time, visualizing how gravitational forces affect the trajectories as the comet approaches Jupiter. This demonstration highlights how math manifests itself through computer simulations into visual displays of gravitational behavior.
00:14:00.000
Next, we’ll shift our focus to controlling and responding to real-world processes. The reality of the world presents complexity that often challenges control systems. Within physics courses, idealized conditions allow us to neglect factors like air resistance. However, in real-world scenarios, all these perturbations must be considered for effective control mechanisms. This is where reacting to the environment rather than attempting to solve problems ahead of time becomes critical. It’s akin to feedback systems: if you want a desired output, you’d set a controller that interprets sensory data and adjusts actions accordingly.
00:15:45.760
For example, if you're curing meat, you'd write code to keep track of humidity levels—should you turn the dehumidifier on or off based on current metrics—or if you're managing rocket thrust control, assessing thrust requirements dynamically builds a layer of complexity. Using PID (Proportional, Integral, and Derivative) controllers helps manage this by continually adjusting outputs in response to input variations.
00:16:15.760
This feedback loop minimizes error margins, ensuring the essential outputs are maintained in stable ranges. Despite its complexity, these controls can be effectively codified in straightforward programming structures. Through iterative testing, developers can simply refine settings and algorithms until the necessary performance is achieved.
00:17:06.080
Let’s end with a brief demonstration incorporating controller functionality, similar to the well-known Kerbal Space Program, which employs similar feedback principles. By connecting Ruby scripts to manage altitudes and throttle settings, the program showcases automated ascent based on feedback systems. Through live simulation, we can see how a rocket manages its throttle to achieve a stable altitude, showcasing not just computational precision but also the beauty of real-time physics in play.
00:18:20.560
The culmination of these principles offers impactful insight into bridging aerospace concepts with everyday software challenges. Similar to the way we monitor rocket fuel consumption and adjust thrust in flight simulations, these lessons mirror our need to adapt effectively in software environments, ensuring optimal performance while gracefully handling the complexities surrounding various engineering challenges.
00:19:06.560
Thank you for your attention. The code related to this presentation will be available on GitHub and shared via Twitter. I hope you find valuable insights throughout, especially how aerospace engineering and rocket science principles can be utilized to tackle challenging software problems. Remember, behind every problem you encounter, there's often a simplified solution waiting to be discovered.