The problem: Really crappy cell modem signal strength at a site in rural Virginia.
The solution (for now): About 1m2 of aluminum foil, made into a rough parabolic shape.
It ain’t pretty, until you look at the signal strength meter. -115dBm to -100dBm, which means the difference between being online or not. I’ll take it.
(Click for larger)
A recent article notes that apparently the crash of Spanair flight 5022 had as a major contributing factor a compromised warning system computer, which resulted in no audible alarm when the pilots attempted to take off with the flaps and slats retracted. (This is a Bad Thing.)
Here’s the scary part: The computer had apparently been compromised due to malware that had somehow been installed (suggesting to me that it was likely running Windows or another popular consumer operating system.)
I’m all for the use of modern technology in aircraft; engine management computers and other systems can make aircraft safer, more reliable, and much more efficient. Of course, as with all aviation systems, they ought to be thoroughly checked out before being allowed to control critical aircraft functions. One corollary to this is that large, complex, unverified operating systems should *not* be used to run systems in charge of essential functions. I sincerely hope that there has been a misunderstanding in this case. We don’t yet know all there is to know about aviation safety, of course — but not using consumer-grade software in critical systems should be as big a no-brainer as making sure that the wings are bolted on securely.
We need more programming languages like BASIC. Not the thoroughly modernized, object-oriented, jazzed-up descendants of the language — I mean the original BASIC. Specifically, a language which can be readily understood by anyone reading it who has a background in algebra — and one which can be easily learned in a few minutes’ time.
I recently came across (okay, went looking for and found) the original paper describing 1964 Dartmouth BASIC. It’s amazing how clear the example code is — and how well-thought-out the stated goals of the language are.
Compare the following “Hello, World!” programs in BASIC and JAVA…
BASIC:
10 print "Hello, World!"
20 end
Java (Android code):
package com.paad.HelloWorld;
import android.app.Activity;
import android.os.Bundle;
public class HelloWorld extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}//onCreate
}
Java (required XML for Android):
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Hello, World!"
/>
<LinearLayout>
That’s a LOT of crap, just to put “Hello, World” on the screen! Not only that, but how would a beginning Java programmer know all of the names of the required functions, and which parameters they take? Java is supposed to, among other things, shield programmers from the “complexity” of languages like C. I think I’ll stick with the “complexity,” thanks.
Not only that, but an additional point of failure has been introduced: the code now depends on a schema that resides on a webserver at schemas.android.com. Should this webserver go offline (for instance, the Android platform goes out of fashion, the organization running the site goes bankrupt or just doesn’t have a good backup policy in place, or whatever), the code is now broken — dependent on an external reference that is no longer there.
