[1] https://ad.easa.europa.eu/blob/NM-18-33.pdf
[2] https://www.mouser.com/datasheet/2/187/honeywell_hwscs06627_...
[1] https://ad.easa.europa.eu/blob/NM-18-33.pdf
[2] https://www.mouser.com/datasheet/2/187/honeywell_hwscs06627_...
For my 3D audio project I need an affordable way to make plastic cases. I felt like injection molding services are way overpriced, so I decided to make the molds in-house. Turns out, CNC milling is overpriced, too. As are 5 axis CNC mills. So in the end, we built our own CNC machine.
And like these things always go, I found an EMI issue with my power supply and a USB compliance bug in the off-the-shelf stepper control board. But it all turned out OK in the end so we now have the first mold tool that was designed and machined fully in-house. And I learned so much about tool paths and drill bits. Plus it feels like now that everyone has experienced hands-on how stuff is milled, my team got a lot better at designing things for cheap manufacturing.
Why do you need to make so many molds?
I remember copying code to make wrappers for those in C from books but can't remember if that was the only option or...
I know with VGA you had to use the BIOS to set modes but you could just write to the memory which was mapped at a certain address
There was no memory protection in Real Mode, so you could always poke the hardware yourself, but something written on a Tandy wasn't going to work on a Zenith unless you supported both, or ran everything through the BIOS.
Over time, the OS took over the HAL role, with the BIOS only being used until the OS could load native drivers. Now it's UEFI... same idea with a higher greater level of abstraction and modularity.
For a simple example, let's say you are simply driving in a circle. The car wants to lean toward the outside. The linear motors can provide a countering force, lifting the outside, lowering the inside, so the car stays level. Variable damping can only control the rate that it rolls. It will still roll in sub-second timescales, unless it completely locks down the suspension, which is terrible for both handling and comfort.
For another simple example: going over a speed bump. Linear motors can lift the front wheels over the bump, and then the rear wheels, so the body stays level the whole time. An active damper can go full-soft the moment the wheel hits the bump, but the compressed spring will still start lifting the front of the car. An active damper can do a better job managing the rebound on the far side so it doesn't oscillate, but it can't entirely prevent the bump from pitching the body up and down in the first place.
That's not to say it's worthless. Very fast active dampers can improve both handling and comfort. It's just nowhere near the level which is possible with linear motors.
For my Ruby example, each of those method calls will allocate an Array on the heap, where it will persist until all references are removed and the GC runs again. The extra overhead of the named reference is somewhere between Tiny and Zero, depending on your interpreter. No extra copies are made; it's just a reference.
In most compiled languages: the overhead is exactly zero. At runtime, nothing even knows it's called "data" unless you have debug symbols.
If these are going to be large arrays and you actually care about memory usage, you wouldn't write the code the way I did. You might use lazy enumerators, or just flatten it out into a simple procedure; either of those would process one line at a time, discarding all the intermediate results as it goes.
Also, "File.readlines(i).count" is an atrocity of wasted memory. If you care about efficiency at all, that's the first part to go. :)
Compare with a simple pipeline in bash:
grep needle < haystack.txt | sed 's/foo/bar/g' | xargs wc -l
Each of those components executes in parallel, with the intermediate results streaming between them. You get a similar effect with coroutines.Compare Ruby:
data = File.readlines("haystack.txt")
.map(&:strip)
.grep(/needle/)
.map { |i| i.gsub('foo', 'bar') }
.map { |i| File.readlines(i).count }
In that case, each line is processed sequentially, with a complete array being created between each step. Nothing actually gets pipelined.Despite being clean and readable, I don't tend to do it any more, because it's harder to debug. More often these days, I write things like this:
data = File.readlines("haystack.txt")
data = data.map(&:strip)
data = data.grep(/needle/)
data = data.map { |i| i.gsub('foo', 'bar') }
data = data.map { |i| File.readlines(i).count }
It's ugly, but you know what? I can set a breakpoint anywhere and inspect the intermediate states without having to edit the script in prod. Sometimes ugly and boring is better.It's not completely crazy. Software was developed by much smaller teams and got out the door quickly in that era.
I can see why local UI development fell out of favor, but it is still better (faster, established tooling, computers already have it so you don't have to download it). I can't help but feel like a lighter weight VM (versus electron) is what we actually want. Or at least what _I_ want, something like UXN but just a little more fully featured.
I'm writing some personal stuff for DOS now with the idea that every platform has an established DOS emulator and the development environment is decent. Don't get me wrong this is probably totally crazy and a dead end but it's fun for now. But a universally available emulator of a bare bones simple machine could solve many computing problems at once so the idea is tempting. To use DOS as that emulator is maybe crazy but it's widely available and self-hosting. But to make networked applications advancing the state of emulators like DOSBox would be critical.
Actually local first, maybe the way forward is first to take a step back. What were we trying to accomplish again? What are computers for?
That's basically the JVM, isn't it?
It's interesting to think how some of the reasons it sucked for desktop apps (performance, native UI) are also true of Electron. Maybe our expectations are just lower now.
MCAS affects the stabilizer, the thumb switches affect the stabilizer, the cutoff switch affects the stabilizer.
The elevators are controlled by the control column and the autopilot.
> The trim switches override MCAS, but when released, MCAS can resume trimming down again.
That is correct. That is why the procedure is to return the trim to normal with the thumb switches, then turn off the trim system. That's it. That's all there is to it.
> but they can make the controls so heavy that it's impossible to pull up.
Almost right - the trim has more authority than the elevators. The trim's ability to travel far is to provide great ability to get out of trouble. I don't really know what factors the aerodynamics guys used to calculate the max travel required. I do know there is a travel limiter on it (as I worked on that, too!) which reduces the max travel at higher speeds, because otherwise it can rip the tail section off, which is a big no-no.
There are sooo many constraints on the design of an airplane I sometimes wonder how anyone manages to make one that works at all. The Wright Bros calculated that their machine would fly, and it did, barely. Their contemporaries did seat of the pants design, which is why they failed.
Thank you, I'll update my brain and future explanations. :)