Michael A. Covington    Michael A. Covington, Ph.D.
Books by Michael Covington
Consulting Services
Previous months
About this notebook
Search site or Web
Ichthys

Daily Notebook

Popular topics on this page:
Solving the WPF update problem with async and await
Programming the iPhone in JavaScript?
How to run a command-line program in a WPF window
Network Watcher, freeware to test networks under Windows
iOS 7 bold type and battery life [Updated]
Astrophotos:
Tumbling Chinese rocket stage
Dark nebulae near Altair
Dark nebulae in Scutum
Dark nebula B138 in Aquila
Dark nebulae B169-B171 in Cepheus
Dark nebula B312 in Sagittarius
Atlas Centaur rocket stage
Scutum star cloud
NGC 6774
Copernicus and Aristarchus (lunar craters)
Many more...

For more topics, scroll down, press Ctrl-F to search the page, or check previous months.

For the latest edition of this page at any time, use this link: www.covingtoninnovations.com/michael/blog

Note: The ads that you see here are not controlled, sponsored or endorsed by Covington Innovations.
They are brought to you by Google and will vary depending on your personal browsing history.


2013
September
28-30

Ungoverned? Ungovernable?

As I write this (on October 1), the U.S. government is the laughingstock of the world because it is "shut down" due to a lack of proper financial management by Congress. We are in for a string of artificial financial crises for at least the next several months, due to more of the same theatrics and grandstanding.

I know the nation is deeply split over Obamacare. But all the controversy that we have today, we had six months ago. Congress has a job to do — pass appropriate financial measures at the appropriate times, regardless of how divided the country may be. They're not doing their job.


On a happier note, it looks as though I'm going to get to go to the Peach State Star Gaze this evening (Oct. 1) and do some astrophotography. This will be my first trip to Deerlick for any reason in two years; my first observing trip there in more than three years; and my first observing trip to any dark-sky site in two years. Real life has been interfering substantially with my hobby!

2013
September
27

Field of the Garnet Star

[Reprocessed 2013 October 12.]

This is a star field in Cepheus that I want to photograph again under better circumstances. The three brightest stars are Delta Cephei, the famous variable star, at the lower left; Alpha Cephei at the upper right; and Mu Cephei, Sir William Herschel's orangeish "garnet star," to the lower right of center.

There is also a dark nebula, Barnard 169-171, below the center of the picture, and a star cloud to the lower right of Mu.

Much like several recent pictures, this is a stack of five 30-second exposures with a 105-mm lens at f/2.8 using a Canon 60Da at ISO 1250 on an iOptron SkyTracker in my driveway.

2013
September
26

Cross-platform programming

In addition to my usual C#, I also program in Java. Here you see an experiment with Swing, the Java GUI. I took a simple word-frequency-table program and gave it a windowed user interface, not really to build a research tool, but just as a programming example. Above, you see it running under Windows and Linux. It will also run on the Macintosh. Download it free, with source code, by clicking here.

2013
September
25

A rich field in Sagittarius

[Reprocessed 2013 October 12.]

Here you see, among other things, the Swan Nebula on the right-hand side of the picture, the Eagle Nebula at the upper right corner, and the big star cluster M25 at the bottom. Above the center, in front of the star clouds, you see a roundish dark patch called B312, a dark nebula (dust cloud). Much like yesterday's picture, this is a stack of nine 30-second exposures with a 105-mm lens at f/2.8 using a Canon 60Da at ISO 1250 on an iOptron SkyTracker in my driveway.

2013
September
25

A streak runs through it
Dark nebula B138 in Aquila

[Reprocessed 2013 October 12.]

In the middle of this picture of the summer Milky Way, you can see a curved dark streak, a dust cloud far off in space. This is a stack of ten 30-second exposures with a 105-mm lens at f/2.8 using a Canon 60Da at ISO 1250 on an iOptron SkyTracker in my driveway. The brightest star is Delta Aquilae.



Emory Inn

Atlanta is the city whose motto seems to be, "OK, now what used to be here?" Because of its surging growth, buildings are torn down and replaced more often in Atlanta than anywhere else I've ever been.

On a trip yesterday, Melody and I noted with mixed feelings that the old part of the Emory Inn is being torn down. It was an obsolete building and needed replacing. But it is where we stayed the night before Sharon's graduation, and it is where Nathaniel asked my permission to marry Cathy.

2013
September
24

iOS 7 bold type and battery life

When I upgraded my iPhone 5 to iOS 7, I immediately noticed that the type on the screen was less legible. Today I found that I could get the older, bolder type style back by choosing Bold Type under Settings, Accessibility. Here you see what iOS 7 looks like when that setting is made.

Also, there are scattered complaints of iOS 7 ruining the battery life of an iPhone. My experience has been the opposite — my battery life is, if anything, better than before. I think the explanation is that iOS 7 apparently recalibrates the battery-charge meter and detects whether your battery has deteriorated with age. At least, that's my working hypothesis.

More about the battery-life issue: See this and this. iOS 7 is likely to turn on some options that you can turn off to save batteries, such as Background App Refresh. Also, in iOS 7 you are finally allowed to exit an app (rather than just abandon it to eventually shut down on its own); press Home twice, so you see your running apps in rectangles, and then flick the unwanted one toward the top of the screen. Any apps that are constantly communicating over the network will use battery power.

2013
September
23

Every crisis has its own time scale

This evening I skimmed part of a management book by a former CIA agent. Interesting reading. One take-away point (and I don't think these are the author's exact words): Every crisis has its own time scale. Responding too fast can be as bad as responding too slowly. You have to consider how quickly events are going to unfold and how your actions will affect them.

This certainly resonates with my own experience. One type of bad management considers every event an emergency requiring the fastest possible response. (One wonders if these managers are the people who, in college, always left everything to the last minute and then "pulled an all-nighter.") This is closely related to what management guru Peter F. Drucker calls "active inertia," responding to a new problem with a flurry of activity that does not actually address the problem.

It is also, as I understand it, a vital principle of emergency medicine. Signs and symptoms appear at a specific rate, and if you look too early, you don't see them; if you wait too late, you miss an opportunity; you have to think in terms of an ongoing process rather than an event.

2013
September
22

Some Java

This month I'm refreshing my knowledge of some programming languages other than my usual C# and Prolog. At the moment I'm dabbling in Java using the handy Eclipse IDE. The price is right (it's all free!), Eclipse is easy to use, and of course Java gives you portability (Windows, Linux, MacOS, and to some extent several others).

I kept typing java xxxx.class when I meant java xxxx to run a compiled program.

One minor annoyance is that the world is in an awkward transition between Java 1.6 (Java 6) and Java 1.7 (Java 7). Java 7 was pushed out to Windows users with great urgency as a matter of security. Linux Mint has picked up Java 7, but Ubuntu 12.04 LTS, when fully "updated," is still Java 6.

Here is how to bring Ubuntu up to date:

(1) Type: sudo apt-get install openjdk-7-jdk

(2) Go into the software manager and remove various bits of OpenJDK 6 and, if present, "default" JDK 6. (You will have to search for them and "display technical items.") They will not uninstall until after Java 7 is in place. Until then, if you uninstall them, OpenJDK 6 Runtime will immediately reappear.

(3) Try these commands and make sure you get 1.7 version numbers:

java -version
javac -version

(4) Whenever you give anyone a compiled Java program, tell them it requires Java 7.

The trouble with standards, as Bob Stearns astutely observed, is that we have so many of them to choose between.

[Addendum:] More here. You can have more than one Java version installed in Ubuntu and choose which one is the default. But I'm annoyed that, right now, the whole world isn't in sync — thus sacrificing the portability that is Java's selling point!

2013
September
21

How to run a command-line program in a WPF window
  Network Watcher is here — network testing tool

Network Watcher, which I announced a while back, is finally ready. It's freeware. Download the zipped executable here or the zipped C# source code here.

When you launch it, it tells you the available Wi-Fi networks that your computer can see, with the signal strength and other information. You can select other commands to check your Internet connectivity and Windows LAN.

Although it's handy for testing networks, I actually wrote it to try out some fancy footwork with tasking in WPF. Whatever command-line program it's running executes in its own process, of course, with output redirected to an event handler. That process, in turn, is launched by an asynchronous task so that the WPF GUI will remain responsive.

The output from the command is grabbed line by line, asynchronously, but you could also grab it character-by-character, synchronously. You can also redirect standard input, but you can only do it synchronously (for obvious reasons; the process can't receive data before it's there).

Some additional notes:

(1) Network Watcher requires .NET Framework 4.5, which comes in via Windows Update.

(2) I am distributing this mainly as a C# programming example. All it does is execute some network-testing commands that you could have typed at the command line.

(3) The icon for Network Watcher is the electronic circuit diagram symbol for an antenna. It is not an upside-down peace sign, person waving arms in the air, or anything like that.

2013
September
19-20

Programming the iPhone in JavaScript?

For a brief but bright and shining moment this afternoon, I was able to create my own iPhone apps in JavaScript without going through the App Store or any licensing requirements. I wrote an .html file with JavaScript in it and transferred it to the iPhone via Dropbox. It launched in Safari and ran. It even accessed the Camera API.

Then I upgraded to iOS 7, and now it opens in a text viewer.

I haven't checked what happens in Files Pro, which is a file management and transfer app that I just acquired. Update: in Files Pro it works.

But I'm told that in fact you can cache any web page in Safari itself and keep it on your iPhone to run without a network connection. I'm going to explore this.

See also this book, which looks a bit dated — does the technique still work? It look as if it ports almost effortlessly to Android and even Windows mobile devices.

2013
September
18

Forty years

Forty years ago today was my first day of college. The previous day, I had flown in from Rome, Italy, with nine students headed for other colleges (three of whom I'm still in touch with), returning from the International Science School for High School Students in Sydney, Australia.

I described my first day of college five years ago. Today let me just note that I'm a bit too busy to do what I originally planned, which was to revisit the buildings in which I attended my first classes, and anyhow, one of the buildings no longer exists — Stegeman Hall, where I had P.E. But I'll definitely revisit one of them, the Boyd Graduate Studies Research Center, where I've spent much of my working time since 1984, and where I still go to use the library.

2013
September
16-17

Copernicus and his precursor Aristarchus

When Copernicus, in his famous 1543 book, proposed that the sun and not the earth was the center of the solar system, he cited an ancient Greek astronomer, Aristarchus, who had made the same proposal. Nobody had listened to Aristarchus. Copernicus did lots of mathematics and got people to listen.

The two prominent lunar craters in this picture are Copernicus and Aristarchus (upper left and lower right respectively). Stack of the best 3,000 out of 3,391 video frames, DMK video camera with infrared (IR-pass) filter, Celestron 5 telescope, under mediocre conditions.

2013
September
15

The Scutum star cloud

[Reprocessed 2013 October 12.]

This is the Scutum star cloud (again), a stack of thirteen 30-second exposures with a 105-mm lens at f/2.8 using a Canon 60Da at ISO 1250 on an iOptron SkyTracker in my driveway. This is an experiment in seeing what can be done under mediocre conditions. You can see thick clouds of stars near the center of our galaxy and dark nebulosity in front of them.



Star cluster NGC 6774

This picture was taken somewhat by accident; I didn't have my camera aimed quite as intended. It is the star cluster NGC 6774, the central portion of the image from a stack of seven 30-second exposures with the same equipment as in the picture of Scutum above.

This cluster has not been very noteworthy — in fact I had not even heard of it — but astrophysicists have recently taken an interest in it because it is about the same age as the sun.

2013
September
14

(Extra)

Why it's hard to give directions in Watkinsville

Our suburb to the south, Watkinsville, has been reshaped by road construction so many times in its recent history that it's hard to give anyone directions anywhere (as I discovered today while trying to help someone interpret directions she had been given). Here are a couple of my favorite intersections...

"Go straight on Mars Hill Road..." Not.

Verbum sapienti: None of these Hog Mountain Roads leads to a place named Hog Mountain as far as I can determine. They may be fragments of a road that once did; there is a town by that name, something like 30 miles away.

2013
September
14

A 50-year-old piece of space junk

I haven't stopped blogging — just had a busy few days. Now I'm back...

Just two days after photographing the Chinese rocket stage described in the previous entry, I accidentally photographed another discarded rocket booster passing through the same star field! This one is American and is almost as old as I am.

Here you see Scutum (again), a single 30-second exposure with a 105-mm lens. The rocket stage was already in the picture when the exposure started. It moved toward the lower left and faded from visibility as it went into the earth's shadow (which is quite large at that altitude). It turned out to be Atlas Centaur 2, launched November 27, 1963, just five days after President Kennedy was assassinated.

What you're looking at is a dead, burned-out booster stage that remained in orbit. It has been up there nearly 50 years and will probably last for centuries.

2013
September
6

Tumbling Chinese rocket stage

A discarded Chinese rocket stage tumbled through one of my astrophotos on the evening of the 4th. This is a single 30-second exposure of the constellation Scutum through a 105-mm lens at f/4, using a Canon 60Da on an iOptron SkyTracker, in my driveway.

Of course, the rocket stage looked like a star, moving and varying in brightness as it tumbled. It is identified as CZ-3 (Chángzhēng 3, 长征三号火箭) R/B, launched October 28, 2006.



Dark nebulae near Altair

[Reprocessed 2013 October 12.]

This is a field near the star Altair (the brightest star in the picture), showing several dark nebulae (dust clouds) — Barnard's "E" left of center, and then several others in front of the star clouds of the Milky Way.

This is a stack of 7 exposures with a Sigma 105-mm f/2.8 lens wide open on a Canon 60Da. Each exposure was 30 seconds at ISO 1250. The picture was corrected against dark frames, flat fields, and flat darks (bias frames). Processing was done with DeepSkyStacker and Photoshop.



Dark nebulae in Scutum

[Reprocessed 2013 October 12.]

Same technique as the preceding picture, but the subject is the constellation Scutum and this is a stack of nine 30-second exposures. The bright object in the middle is the star cluster M11.

2013
September
5

If you have a "stress ball," keep it in an ammo box

A "stress ball" is a tennis-ball-shaped thick balloon filled with a mushy substance; you're supposed to squeeze it to relieve stress or to exercise your hand muscles.

If you have one, I strongly recommend keeping it in an ammo box or at least a Mason jar. It is a time bomb waiting to go off.

Our excitement last night was that a stress ball, innocently stored in a closet several years ago, decided to leak out all its contents, thereby doing serious damage to clothing, carpet, and woodwork.

It delivered about half a cup of transparent, sticky gel, which was (thank goodness) soluble in water, especially hot water. I'm going to keep some in case an analytical chemist somewhere wants to figure out what it's made of. This particular stress ball was made in China by "Grand Star Industrial" and shows no indication of having passed any safety certification anywhere.

We've taken five garments to the dry cleaners. Two more were so gooey the dry cleaner wouldn't touch them, and we're attempting to clean them at home. Using a warm washcloth I was able to remove a small amount of goo from a shoe. With the garden hose, I de-gooed a plastic storage bin.

There remain the woodwork and the carpet. It should be possible to scrape a large pile of goo off the closet shelf and then put shelf paper down. As for the carpet, who knows? The goo is sitting on top; it didn't sink down into the pile. I'll lift off what I can with a putty knife and then run the carpet cleaner over it, with hot water, repeatedly.

I posted this sad tale on Facebook and immediately heard from others who had had the same experience. The goo gradually eats through the rubbery plastic and gets out. When it does, it gradually drips on everything beneath it and adheres to everything in its path. There is some reason to think all "stress balls" do this if given enough time.

2013
September
3-4

Solving the WPF screen update problem 
with async and await

DOWNLOADABLE EXAMPLES:
Simplest example without cancel button
With cancellation using flag
With cancellation by throwing exception

As many of us have found out the hard way, the Windows WPF user interface does not update the screen every time you change something on the screen. If you do a long computation, writing results in a TextBox as you go, you won't see anything in the TextBox until the computation finishes.

When I was not as old and wise as I am now, I spent a lot of time trying to make WPF update its screen the way WinForms does. Actually, my solutions are far from useless; you may need them if you are hastily porting a WinForms program to WPF and don't have time to do things right. See examples here.

The right way to keep a WPF application responsive, traditionally, has been to put the computation into a BackgroundWorker object, run it in the background, and have it communicate with the screen using ReportProgress.

But now we have several newer tools for the same job. Setting up background tasks is easier than it used to be, and the keywords async and await give us a non-blocking way to wait for a task to finish, without having to tell the task to trigger an event when it finishes.

In what follows, I'll show you how to put all of these together to run a background computation in a separate thread, let it write to the screen periodically, and keep the UI responsive. First, though, I'll take you through a few handy features of modern C#.


Lambda notation. Adapted from lambda calculus in formal logic and the LAMBDA special form in Lisp, lambda notation is a way to describe a method by just writing it, without giving it a name. That is, it's a way to write one or more C# statements in a place where the language is expecting a delegate (a reference to a method).

Here's what lambda notation looks like:

(parameters) => { statement; statement;statement; }

There is a simpler case, where there are no parameters and just one statement, which is actually an expression, such as a method call. Then you can write:

() => expression

such as, for example, () => MyMethod(myArg) (no semicolon is needed after it).


Task factory. You remember BackgroundWorker, the traditional class for creating background tasks. Nowadays there's a simpler way. You can create a task and start it running by just doing this:

var task = Task.Factory.StartNew( () => MyMethod(myArg1) );

or even

var task = Task.Factory.StartNew(MyMethod);

if MyMethod does not take arguments. The task starts running in the background, and task is a reference to it.


The async and await keywords. These give you a new, non-blocking way to wait for a background task to finish.

If you were using BackgroundWorker, you'd be wanting to set up an event handler to detect completion of the task. You can still do that, but with async and await it isn't necessary.

Here's how they work: async is used in the declaration of a method, to enable it to be called with await. But it can still be called the old way too, and it isn't obligated to do anything special.

Methods that are declared async should return tasks, not values. The proper declarations are:

async Task<T>, where T is some type, if the method returns type T;
async Task if the method returns void;
async void if the method is an event handler (only), because event handlers can't return anything.

You will soon see an example of the last one, or I wouldn't even have mentioned it.

Now for await. The await statement takes as its argument an async task, and it asynchronously waits for the task to finish. That is, it doesn't block the CPU while waiting. Instead, it shoves the entire rest of its own method into a continuation — a postponed action — and queues it to be triggered by competion of the awaited task. Meanwhile, it lets the original thread get on with whatever else it wants to do. A miracle! Or at least a lot of work saved.

Putting these two together, suppose CountUp is the name of a parameterless method that performs a time-consuming computation. We can launch it and run it in the background with these two statements:

var task = Task.Factory.StartNew(CountUp);
// You can do other work here and even launch other tasks
await task;

Or even this one statement:

await Task.Factory.StartNew(CountUp);

So here's how we start the action. This is a button click event handler, and it has to be declared async so it can use await, and async void (rather than the usual async Task) because it's an event handler. When the user clicks on the start button, the computation starts, proceeds, and finishes. Housekeeping is done to take care of the cursor and to disable the button while the activity is taking place, so the user can't double-launch it.

private async void buttonStart_Click(object sender, RoutedEventArgs e)
{
   buttonStart.IsEnabled = false;
   this.Cursor = textBox1.Cursor = Cursors.Wait;

   var task = Task.Factory.StartNew(CountUp);

   await task;

   this.Cursor = textBox1.Cursor = Cursors.Arrow;
   buttonStart.IsEnabled = true;
}


Invoke and InvokeAsync. We need one more tool in our kit. Recall that we want the background process to be able to write on the screen, or more precisely, to make changes to components that belong to the UI thread rather than its own thread.

That means it needs to perform cross-thread calls. Instead of calling a method directly, it needs to place that method in the queue of actions for the UI thread. That can be done with BeginInvoke, just as in WinForms, but I find it handier to use the two new methods Dispatcher.Invoke and Dispatcher.InvokeAsync, which take delegates, and hence lambda expressions, as their only argument, and run the delegate on the application's main thread (the UI thread). (More precisely, the argument is an Action, converted automatically from a delegate.)

The difference between the two is that Dispatcher.Invoke calls another thread's method and waits for it to finish, but Dispatcher.InvokeAsync doesn't wait. Using the latter will keep from slowing down the computation thread, but you're taking the risk that the UI thread might not be able to keep up.

So here is the complete CountUp() method. It writes numbers into a TextBox, pausing between them to do about a second of number-crunching:

private void CountUp()
{
   for (int i = 0; i < 10; i++)
   {
      // Cross-thread call to update things on the screen
      Dispatcher.InvokeAsync( () => ReportResults(i.ToString()) );

      // Simulate a slow computation
      for (int j = 0; j < 120000000; j++) { }
   }
}

ReportResults, in turn, appends its argument to a TextBox on the screen and scrolls it to the end.


Making it cancellable. What if we want to allow the user to cancel the computation in progress? That involves a CancellationToken object. Unlike a simple global boolean variable, a CancellationToken is guaranteed to be thread safe. We have to declare a CancellationTokenSource that is in scope everywhere it is used:

// Object that will keep track of cancellation requests.
CancellationTokenSource canceler;

When the user hits the Cancel button on the screen, we have to set the token to request cancellation:

// Event handler for cancel button
private void buttonCancel_Click(object sender, RoutedEventArgs e)
{
   if (canceler != null)
   {
      canceler.Cancel();
   }
}

And we have to make the "start" button create the canceler and enable the cancel button, so it has a little more housekeeping to do:

private async void buttonStart_Click(object sender, RoutedEventArgs e) {
   buttonStart.IsEnabled = false;
   this.Cursor = textBox1.Cursor = Cursors.Wait;

   canceler = new CancellationTokenSource(); // create the canceler
   buttonCancel.IsEnabled = true;

   var task = Task.Factory.StartNew(() => CountUp(canceler.Token));

   await task;

   buttonCancel.IsEnabled = false;

   this.Cursor = textBox1.Cursor = Cursors.Arrow;
   buttonStart.IsEnabled = true;
}

Notice the underlined code — we have to create the task in a slightly fancier way in order to pass the cancellation token to it as an argument. Of course, the computation task has to look at the token periodically and bail out if cancellation is requested. This doesn't happen automatically (nor would you want it to). So here is what CountUp now looks like:

private void CountUp(CancellationToken token)
{
   for (int i = 0; i < 10; i++)
   {
      // Check the flag
      if (token.IsCancellationRequested)
      {
         Dispatcher.InvokeAsync( () => ReportResults("Cancelled") );
         return;
      }

      // Cross-thread call to update things on screen
      Dispatcher.InvokeAsync( () => ReportResults(i.ToString()) );

      // Simulate a slow computation
      for (int j = 0; j < 120000000; j++) { }
   }
}

That's all. Not quite as complicated as BackgroundWorker, and considerably more elegant and versatile.

2013
September
2

Too hot for school?

[Revised.]

This year, some schools have started declaring heat days (analogous to snow days) and dismissing school on excessively hot late-summer days.

Are we turning into softies? I don't think so. I think several things have happened.

School year creep. School used to start after Labor Day. In my elementary-school days it had moved up to about August 28. Now it's often August 1. That makes a big difference because the hottest days of the year are usually around August 15, followed by a rapid fall-off (even in Georgia, but much more so up north). This is probably the single biggest reason "heat days" are now thought to be necessary.

Cheap architecture. Nobody talks about this, but after 1950, school buildings stopped having high ceilings and cross-ventilation with transoms. Architecture from coastal California (with its extremely mild climate) was adopted everywhere. It was common to build buildings that were designed for air conditioning, but leave out the air conditioning. (I endured a Yale dorm with that problem.) The result: excessive indoor temperatures.

Recognition that heat is harmful. Back in the 1960s, adults told children of my generation that air conditioning was a luxury and we shouldn't expect to have it at school — that we shouldn't need it — that doing without it was good for us.

But now we know that air conditioning does make people healthier and more productive. Yes, the human body can endure heat, but that comes at a cost. Students learn a lot better if they are physically comfortable, not pushing the limits of their endurance.

As for luxury, the fact that air conditioning is new doesn't mean it's decadent. There was a time when cooking your food was a novelty, too. Now everyone does it, and the time when it was new is lost in the mists of prehistory.

Climate change. Late summer really is hotter now than it was in 1930. We are that much farther away from the Little Ice Age of the 1600s. Global warming is real; the controversy is whether it's man-made.

Mistaken traditions. Much of North America has always been a much hotter, more humid place than most of Europe, where our traditions and expectations come from. Many of us don't realize how extreme our summers are, by the standards of other parts of the world, or how badly our traditional clothing fits our climate.

2013
September
1

Not that kind of doctor...

Frequently the medical profession tries to claim me as one of its own.

The other day I was at the doctor for a checkup. A nurse had left a stethoscope in the room, and she came back for it. The other nurse, having heard me introduced as "Dr. Covington," motioned toward me and said, "Oh, I thought it was his."



AN-gi-na or an-GI-na?

I hasten to add that I do not suffer from it, but I've heard doctors pronounce the word angina two ways. AN-gina seems to be gaining ground. I used to hear an-GI-na. What's going on?

It turns out there's a complicated story attached to this. Angina is a Latin word for "sore throat" (or, even earlier, "strangling") which was applied to a particular kind of heart-related pain by William Heberden in 1772. Before that, it was a rather rare word in Latin, though not entirely unheard-of. Lewis and Short's Latin Dictionary of 1879 notes that "the quantity of the penultimate" is disputed, meaning people weren't sure whether the I was long or short. To clear it up, they cite painstakingly-gathered examples of the word being used in poetry whose meter requires a particular vowel length. The I is short, and hence the middle syllable is not accented.

It took some time for word of this to reach the medical community. The vowel length is wrong in White's English-Latin Dictionary (1877) and probably many other dictionaries of that date and even later.



A Canadian etymological mystery

Why is the largest city in Québec called Montréal and not Mont-Royal, which is the name of the hill beside it?

Both mean "royal mountain." Réal is medieval French, but it had changed to royal before French-speakers reached Québec. So what happened? Did they import a Spanish word?

It turns out this is a mystery. The best guess Wikipedia can offer is that an Italian-language map was misinterpreted as archaic French.


If what you are looking for is not here, please look at previous months.