12 March 2008

More Tininess From the Malay Archipelago

I've been blogging on nothing but code lately, so here's a "quick" paleo-post.

"Hobbits": Primitives or Pinheads?

The anthropological world was shocked several years ago by the discovery of a relatively recent pygmy species of stem-human, popularly dubbed "hobbits" and more technically dubbed Homo floresiensis (Brown et al. 2004). Known from subfossil remains of several individuals from the island of Flores (Morwood, Brown et al. 2004), including one nearly complete skeleton including the skull (the holotype specimen), these people stood barely over a meter in height, shorter than any modern pygmy humans. They survived at least until 13,000 years before present (Morwood, Soejono et al. 2004), and, judging from the one skull, they had extremely small brains for such late-surviving Homo (380 cc—we average around 1400 cc and even Australopithecus africanus averaged in the 400s). They had other primitive features as well, such as chinless jaws, a low twist in the forearm bones (Ibid.), robust leg bones (Ibid.), a chimp-like wrist (Tocheri et al. 2007), and some features of the teeth.

But not everyone agrees that the Floresian "hobbits" are a separate species. Various researchers have proposed that they are, in fact, pygmy Homo sapiens and that at least some individuals, including the holotype, have a pathological condition that includes microcephaly, a.k.a. "pinheadedness" (Martin et al. 2006, Jacob et al. 2006). After all, at least some of the supposedly diagnostic features, such as chinlessness, are present in some members of our own species (Jacob et al. 2006). But others insist that there are genuine primitive features in the Floresian specimens that cannot be explained by microcephaly or dwarfism (Falk et al. 2005, Falk et al. 2006, Argue et al. 2006).

A New Discovery

Until recently, the Floresians' size distinguished them from H. sapiens. But that was before this week's publication (Berger et al. 2008; open access) of some very recent (1400 to 2900 years B.P.) pygmy/dwarf fossils from Palau. More work needs to be done to free these fossils from the limestone they were found in, but they seem to be Homo sapiens proper, high-domed skulls and all. What's really interesting is that, like the Floresian "hobbits", the Palauans are smaller than any living population of H. sapiens. But unlike the "hobbit" holotype, their cranial capacity is not abnormally low.

Berger et al. note that the Palau specimens have some supposedly "primitive" features that may in fact be related to size, such as proportionally large teeth (megadontia) and chinless mandibles. The authors don't firmly ally themselves with either camp, but note that at least some of the supposed diagnostic features of H. floresiensis are probably phylogenetically uninformative, merely being results of dwarfism.

Thoughts

Personally, while I'm no expert in any the fields involved, I find the arguments that the Floresians are pathological, pygmy H. sapiens unconvincing. For one thing, people afflicted with the proposed diseases don't actually look like the "hobbits" except in having small brains. For another, asymmetry that was ascribed to pathology seems more likely to me to be a preservational artifact. Look at just about any fossil skull face-on—most of them are asymmetrical.

But more damning are the limb characters, which no known pathology can explain. (Did they have some kind of "ape-itis" in addition to microcephaly?) Fact is, I think that if H. floresiensis were 130,000 years old instead of 13,000, nobody would even contest the idea that they weren't H. sapiens. And morphology deserves more weight than chronology in matters of systematics.

References
  • Argue, D., D. Donlon, C. Groves and R. Wright (2006 October 4). Homo floresiensis: microcephalic, pygmoid, Australopithecus, or Homo? Journal of Human Evolution 51(4):360–374. doi:10.1016/j.jhevol.2006.04.013
  • Berger, L. R., S. E. Churchill, B. De Klerk and R. L. Quinn (2008 March 12). Small-bodied humans from Palau, Micronesia. PLoS ONE 3(3):e1780. doi:10.1371/journal.pone.0001780
  • Brown, P., T. Sutkina, M. J. Morwood, R. P. Soejono, Jatmiko, E. Wayhu Saptomo and Rokus Awe Due. (2004 October 28). A new small-bodied hominin from the Late Pleistocene of Flores, Indonesia. Nature 431:1055–1061. doi:10.1038/nature02999
  • Falk, D., C. Hildebolt, K. Smith, M. J. Morwood, T. Sutkina, P. Brown, Jatmiko, E. Wayhu Saptomo, B. Brunsden and F. Prior (2005 April 8). The brain of LB1, Homo floresiensis. Science 308(5719):242–245. doi:10.1126/science.1109727
  • Falk, D., C. Hildebolt, K. Smith, M. J. Morwood, T. Sutkina, P. Brown, Jatmiko, E. Wayhu Saptomo, B. Brunsden and F. Prior (2006 May 19). Response to comment on "The brain of LB1, Homo floresiensis". Science 312(5776):999. doi:10.1126/science.1124972
  • Jacob, T. E., Indriati, R. P. Soejono, K. Hsü, D. W. Frayer, R. B. Eckhardt, A. J. Kuperavage, A. Thorne and M. Hennenberg (2006 September 5). Pygmoid Australomelanesian Homo sapiens skeletal remains from Liang Bua, Flores: population affinities and pathological abnormalities. Proceedings of the National Academy of Sciences of the United States of America 103(36):13421–13426. doi:10.1073/pnas.0605563103
  • Martin, R. D., A. M. MacLarnon, J. L. Philips, L. Dussubieux, P. R. Williams and W. B. Dobyns (2006 May 19). Comment on "The brain of LB1, Homo floresiensis". Science 312(5776):999. doi:10.1126/science.1121144
  • Morwood, M. J., P. Brown, Jatmiko, T. Sutkina, E. Wahyu Saptomo, K. E. Westaway, Rokus Awe Due, R. G. Roberts, T. Maeda, S. Wasisto and T. Djubiantono (2005 October 13). Further evidence for small-bodied hominins from the Late Plesitocene of Flores, Indonesia. Nature 437:1012–1017. doi:10.1038/nature04022
  • Morwood, M. J., R. P. Soejono, R. G. Roberts, T. Sutkina, C. S. M. Turney, K. E. Westaway, W. J. Rink, J.-x. Zhao, G. D. van den Bergh, Rokus Awe Due, D. R. Hobbs, M. W. Moore, M. I. Bird and L. K. Fifield (2004 October 28). Archaeology and age of a new hominin from Flores in eastern Indonesia. Nature 431:1087–1091. doi:10.1038/nature02956
  • Tocheri, M. W., C. M. Orr, S. G. Larson, T. Sutikna, Jatmiko, E. Wahyu Saptomo, Rokus Awe Due, T. Djubiantono, M. J. Morwood and W. L. Jungers (2007 September 21). The primitive wrist of Homo floresiensis and its implications for hominin evolution. Science 317(5845):1743–1745. doi:10.1126/science.1147143

03 March 2008

Names on NEXUS: Under the Hood

I nearly have the basic data model and data processing functions pinned down for Names on NEXUS. Once again, that's my project, hinted at in a paper of mine (Keesey 2007), to relate the data in NEXUS files (Maddison et al. 1997) to definitions of names as governed by the PhyloCode.

I've had to learn some new technologies and code packages to accomplish this. Here's a rundown of some key ones:

BioJava
This is the most recent addition. Originally I had built my own library in ActionScript 3.0 to parse NEXUS files. But it had some limitations. NEXUS is a rather old format (as bioinformatics formats go), and different applications produce somewhat different versions. So rather than use my own ad hoc library, I decided I should get an open source one.

There aren't any in ActionScript, of course, but there are some in Java. This meant I had to switch NEXUS parsing from the front end to the back end, but in some ways that's better. It means I can stored parsed data in the database instead of having client application parse NEXUS data every time. In fact, it means that the client never has to actually see raw NEXUS data—it can just fetch the pre-parsed data.

I first looked into using the NEXUS-parsing code in Mesquite, an open-source phylogenetic analysis program. But it's not set up for simply using the parsing engine on its own—the parser is tied into a whole file-browsing package. Then I found BioJava, which had exactly what I needed. Just looka this package!

Unfortunately there are still some problems with opening certain NEXUS files. I downloaded some samples from TreeBASE and they flagged errors in the TREES section. The reason, as I found after hours of searching and considering whether it might be better just to write my own parser after all, turns out to be an extra comma in the TRANSLATE section. Still not exactly sure how I'm going to solve that one. But it works when I remove the comma!

Hibernate
Remember how I wrote a post a while ago about building classes that map from the Java back-end to the database? Turns out that was all unnecessary. Hibernate is a persistence layer that provides pretty seamless integration between Java and a database (in this case, a PostgreSQL database). Augmented by Hibernate Annotations and Hibernate Validator, it makes it fairly easy to set up and use a complex, well-organized database.

Well, okay, there's a bit of a learning curve first, but it's totally worth it. Incidentally, the book I used to learn it has what is possibly the best title ever.

Flex Data Management Services
Basically, Hibernate is to Java and databases as mx.data is to Flex and Java. It provides a persistence layer so that I don't have to keep track of whether or not I need to request certain data from the Java back-end. I just create DataService objects, tie them to Assembler classes on the back end, and it's all taken care of.

FlexUnit and JUnit
I've already extolled the virtues of unit testing. These wonderful (and, yes, comically-named) packages (huh huh) make it possible. I haven't built enough unit tests, really, but the few I have have been enormously useful in hunting down peculiar errors. And aside from that, since Eclipse can run JUnit tests natively, I can even use them to perform certain important tasks, such as setting up the database from annotated classes via Hibernate.

So What's Left For Me To Do?
Plenty. Although these premade packages help out enormously, I've still had to build an entire mathematics library, a MathML parser, and some tools for handling URIs. I've still got tons of work left to do on the user interface. (Event bubbling is helping a lot with that, by the way.) And, even when stuff is already built, just hooking up one pipe to another pipe can be more complicated than it seems.

Here's a rough list of what's left:
  • Finalize the servlet for uploading and parsing NEXUS data. (I'm very close on this one.)
  • Finish the required behind-the-scenes "search" features. Some of these might be a bit involved, like the ones that suggest possible links between NEXUS taxa and species or specimens or between NEXUS character states and apomorphies.
  • Overhaul the way Names on NEXUS entities (particularly specifiers) are referenced in MathML.
  • Finish the user interface. So far I just have a few forms. I still have to do tree visualization, stylesheets, high-level navigation, transitions, etc.
  • Constrain access to certain functionality. Names on NEXUS is going to be a pretty open, collaborative tool, but I need to set a few boundaries. (E.g., I can't have any old person delete data.)
  • Make sure the server's all optimized, with a static, JNDI-named Hibernate factory, etc.

And here are some things that aren't, strictly speaking, essential, but would be awfully nice:
  • Create a servlet to provide permanent links for Names on NEXUS entities.
  • Create unit tests for all relevant classes.
  • Add JavaDoc and ASDoc comments to all code.

Part of me is also thinking about renaming the project. I mean, it's a good name for what it does right now, but what if I start to bring formats other than NEXUS into the fold? (Not that there are many, but....) Well, I'll probably cross that bridge when I come to it.

My goal is to get an alpha version online sometime this Spring and go open source with it by the Fall. We'll see....

20 February 2008

Posting Code in Blogs

Until the previous post, I'd been hand-converting code samples into HTML for blog entries. Incredibly tedious. Amazingly tedious.

Now I have a tool that does it all for me: Colorer-take5. It integrates with the Eclipse development environment and works like a charm. I just grab the HTML it generates, stick it in <div> and <pre> tags like so:

<div style="color:#AAAAAA; background-color:#0000AA; font-size: small; width: 400px; overflow: auto; padding: 1em"><pre>
<!-- generated HTML -->
</pre></div>


Bam, done. And it's free!

Now I just have to figure out how to make my own coloring scheme.....

Of Document Classes and Timeline Code

My coworker Ezra and I just got through figuring out a bizarre bug in an application created with Flash CS3 (using ActionScript 3.0). Since I didn't see anything else about it online, I thought I'd post it here.

The Set-Up: A loader SWF loads in section SWFs. The section SWFs have timeline code that trigger events based on timeline animations.

The Problem: On their own, the section SWFs worked fine. But once loaded into the loader SWF, only their class code would execute; none of the timeline code would execute, not even traces.

The Really Strange Wrinkle: I created a minimal proof-of-concept test, and it worked fine. It even worked when I used the section SWF from the actual project. So the problem seemed to be in the loader (but it really wasn't).

Here's the code from the minimal proof-of-concept test. Here's the loader class:

package timelinetest {
import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.display.Sprite;
import flash.errors.IOError;
import flash.events.ErrorEvent;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.SecurityErrorEvent;
import flash.net.URLRequest;
public class TestLoader extends Sprite {
public function TestLoader() {
super();
addEventListener(Event.ADDED_TO_STAGE, loadContent);
}
private function loadContent(event:Event):void {
var loader:Loader = new Loader();
var info:LoaderInfo = loader.contentLoaderInfo;
info.addEventListener(IOErrorEvent.IO_ERROR, onContentIOError);
info.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onContentSecurityError);
info.addEventListener(Event.INIT, onContentInit);
loader.load(new URLRequest("./loaded.swf"));
}
private function onContentInit(event:Event):void {
var info:LoaderInfo = event.target as LoaderInfo;
addChild(info.content);
}
private function onContentIOError(event:IOErrorEvent):void {
throw new IOError(event.text);
}
private function onContentSecurityError(event:SecurityErrorEvent):void {
throw new SecurityError(event.text);
}
}
}


... and here's the section class:

package timelinetest {
import flash.display.MovieClip;
import flash.events.Event;
public class TestLoaded extends MovieClip {
public function TestLoaded() {
super();
stop();
addEventListener(Event.ADDED_TO_STAGE, onAddedToStage);
}
private function onAddedToStage(event:Event):void {
play();
}
public function onSpecialFrameReached():void {
trace("special frame reached");
stop();
}
}
}


... and on frame 10 of the root timeline in loaded.swf I had this code:

trace("calling onSpecialFrameReached()");
onSpecialFrameReached();


So on frame 10, it called onSpecialFrameReached(), which stopped playback. This worked fine. But similar code did not work fine in the actual project.

So What Was the Discrepancy?: Making the following modifications (underlined) to TestLoader.as caused the timeline code failure:

package timelinetest {
import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.display.Sprite;
import flash.errors.IOError;
import flash.events.ErrorEvent;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.SecurityErrorEvent;
import flash.net.URLRequest;
public class TestLoader extends Sprite {
private var loaded:TestLoaded;
public function TestLoader() {
super();
addEventListener(Event.ADDED_TO_STAGE, loadContent);
}
private function loadContent(event:Event):void {
var loader:Loader = new Loader();
var info:LoaderInfo = loader.contentLoaderInfo;
info.addEventListener(IOErrorEvent.IO_ERROR, onContentIOError);
info.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onContentSecurityError);
info.addEventListener(Event.INIT, onContentInit);
loader.load(new URLRequest("./loaded.swf"));
}
private function onContentInit(event:Event):void {
var info:LoaderInfo = event.target as LoaderInfo;
loaded = info.content as TestLoaded;
addChild(loaded);
}
private function onContentIOError(event:IOErrorEvent):void {
throw new IOError(event.text);
}
private function onContentSecurityError(event:SecurityErrorEvent):void {
throw new SecurityError(event.text);
}
}
}


See the difference? Before, there was no reference to TestLoaded in loader.swf. With this change, there is. Before, when loaded.swf was loaded, it contained the only reference to TestLoaded. This was as the document class, which had extra code from the timeline, so it was sort of a unique version of the class. But after the change, loader.swf had a copy of the TestLoaded class as well, a copy which had precedence over the unique version loaded in from loaded.swf. So the version with timeline code was ignored—no execution of timeline code.

The Remedy: This is something that was going to be done anyway—none of the loaded section SWFs should use the base version of the section/loaded class. They should all use their own subclasses. That way, nothing in loader.swf can block them.

Another solution (which isn't appropriate for our project, but it might be for others) would be to reference sections in loader.swf using an interface. (But even with this you'd still have to have different implementations in different SWFs, or they might conflict with each other—I think—should test that sometime.)

Really, though, there should be an option when assigning document classes, as there is when linking to a class from the library. You should be allowed to specify whether you want to use the class itself or an ad hoc subclass. If the former, the presence of timeline code should flag a warning message. Remind me to report this to Adobe.

15 February 2008

Happy Belated Valentine's Day!

We at Exopolis launched a "reboot" of our charming, wacky, retro Valentine's Day Mix Tape yesterday:

XOXO, Exo.


It features 26 songs selected by 26 of us. For my song, click here.


I did not actually have a hand in developing this thing, but I did have some "fun" reviving it. The original project was done two years ago by people who are no longer here, and the source files seem to have vanished. I had to decompile the SWF using Sothink SWF Decompiler. It did a pretty good job overall, but there were a couple of bugs that took me hours to track down.

First of all, functions seem to always be formatted this way:
function myFunction(arg1, arg2) {
// function body
}
...rather than this way:
myFunction = function(arg1, arg2) {
// function body
}
Now, normally that doesn't make a difference, and the former version is indeed preferable. But that changes if the declaration is actually supposed to be used to set a class field. A class field like, oh, say onEnterFrame. In that case, the former syntax simply declares a function and then does nothing with it, instead of actually setting the class's native handler. Fun.

Second of all (and this is not the decompiler's fault), Windows font names and Macintosh font names often differ. I spent hours trying to figure out why the "Send to a Friend" form wasn't working until I finally figured out that the dynamically-created text fields were referencing a font called "GFYKersti". In Windows, the exact same font's name is "GFY Kersti". Don'cha just love errors that boil down to a single character difference?

Anyway, now it works and we have the source properly archived in CVSDude. Back to developing new stuff in AS3 rather than trying to revive old stuff in AS2....

13 February 2008

The Most Primitive Stem-Bat

Man, lots of news pertaining to the evolution of flight lately. I saw a presentation on this bit of news at SVP last year—nice to see that it's been published. (Or, uh, will be tomorrow—today it's online early.)

Bats are mysterious creatures—not just in the poetic sense, but in the phylogenetic sense. What are they related to? Where did they come from? For a long time they were considered primate relatives—in fact, Linnaeus included them (as Genus Vespertilio) in his original version of Ordo Primates. In particular, they were often thought to be related to colugos (Cynocephalus), also known as "flying lemurs". Colugos aren't really lemurs, which are true primates, but they are relatives of primates (as are tree shrews, Tupaiidae). Like bats (and several other groups of therian mammal), colugos are arboreal and have large skin membranes used for aerial locomotion. Several characters seemed to unite bats and colugos, or at least put them in the same neighborhood, and this was the status quo for a while.

Then the whole placental tree got shaken up by molecular studies. Soon it became clear that bats were not at all close to colugos or primates, but were instead part of a large radiation with the imaginative name of Pegasoferae (previously mentioned here). Pegasoferae also includes Perissodactyla (horses, rhinos, tapirs), Carnivora (dogs, bears, weasels, seals, cats, hyenas, mongooses, civets, etc.), and Manis (pangolins, a.k.a. "scaly anteaters"—very odd creatures which look like pine cones).

The upshot is that we lost our model (colugos) for what a flightless stem-bat might look like. Now we have nothing (unless some fossil out there has not been recognized as such), so it's hard to tell much about how flight evolved in bats.

Enter a new species from Wyoming. Onychonycteris finneyi is now the most primitive known stem-bat, edging out the previous titleholder, Icaronycteris index. It still has wings, but it also has more primitive characters than any other known stem-bat. As an example, look at bat claws. Modern bats may or may not have a claw on their first manual digit (thumb). I. index has this, as well as a claw on its second manual digit (hence the name—"index finger"). But O. finneyi has claws on all five of its manual digits (hence its name—"onychus" means "claw").

O. finneyi is not a bat ancestor, since it coexisted with more derived stem-bats like I. index. But it does provide some clues as to the ancestral state of flying bats ("apo-chiropterans"). Scans of its ear canals reveal that, unlike modern bats and other known stem-bats, it did not have sonar capabilities. So, in stem-bats, flight evolved before echolocation.

Analysis of its proportions suggests that, like some modern bats, it probably had a flight style where it did not flap continuously, but had a pattern of fluttering up and then gliding down, fluttering up and then gliding down, and so on. (Sort of like a big, leathery butterfly.)

Unlike most modern bats, but like I. index, O. finneyi has a long tail. This evolutionary pattern is also seen in pterosaurs and birds (avialans), where the ancestral trait is a long tail, but the most successful later lineages evolve shortened tails (with occasional reversals).

The work of integrating fossils into the new paradigm of placental evolution is still in its early stages. Hopefully the characters in O. finneyi can help elucidate this problem, just as they have helped to elucidate the origins of bat flight. This fossil is an important clue in The Mystery of the Bat.

References:
  • Nishihara, H., M. Hasegawa and N. Okada (2006 June 27). Pegasoferae, an unexpected mammalian clade revealed by tracking ancient retroposon insertions. Proceedings of the National Academy of Sciences 103: 9929–9934. doi:10.1073/pnas.0603797103
  • Simmons, N. B., K. L. Seymour, J. Habersetzer and G. F. Gunnell (2008 February 14). Primitive Early Eocene bat from Wyoming and the evolution of flight and echolocation. Nature 451:818–821. doi:10.1038/nature06549

Adorable Science

Scientists recently announced the discovery of one of the smallest pterosaurs of all. Pterosaurs were hairy, skin-winged, flying creatures commonly, and somewhat incorrectly, referred to as "pterodactyls". This adorable little guy has been named Nemicolopterus crypticus, meaning "hidden, forest-dwelling wing".

Painted restoration by Chuang Zhao. Taken from the New Scientist article, which has a larger version.

The wingspan is a mere 25 cm. Although the only known specimen is not a fully grown adult, it would not have gotten too much larger had it lived that long. Smaller pterosaur specimens are known, but they represent less mature individuals (i.e., hatchlings).

As I mentioned, pterosaurs are commonly known as "pterodactyls" outside of the paleontological community. "Ptero-dactyle" is an old term for Pterodactylus, a genus of pterosaur known from the Solnhofen deposits in Germany. That term and other terms like "ornithosaurs" have not been in use in paleontology for a very long time. There is, however, a large group of short-tailed pterosaurs called pterodactyloids; Nemicolopterus is not really a "pterodactyl", but it is a pterodactyloid.

Photo showing just how small this thing was. Taken from the ITN article, which erroneously calls it a "dinosaur".

A far more egregious mistake is being committed by many places reporting this creature, though: calling it a dinosaur. Pterosaurs are not dinosaurs, but are generally considered dinosaur cousins. Most scientists consider them non-dinosaurian stem-avians, although the possibility of a stem-archosaurian position has also been investigated. Unfortunately, primitive pterosauromorphs are not known (with the possible exception of Sharovipteryx mirabilis, a poorly-known Triassic animal seemingly having "leg-wings"), so it is difficult to pin down their exact relationships. But it is quite certain that they were not dinosaurs, that is, there is no way that they were descended from the final common ancestor of Iguanodon bernissartensis and Megalosaurus bucklandii.

pan-Archosauria
|?-Pterosauromorpha (possible position)
`--Archosauria
|--pan-Crocodylia
`--pan-Aves
|--Scleromochlus taylori
|--Pterosauromorpha (generally favored position)
| |?-Sharovipteryx (or in Prolacertiformes)
| `--Pterosauria
`--Dinosauromorpha
|--Lagerpetonidae
| |--Dromomeron romeri
| `--Lagerpeton chanarensis
`--Dinosauriformes
|--Marasuchus lilloensis
`--+--Pseudolagosuchus major
|--Dinosauria (including Aves)
`--+--Eucoelophysis baldwini
`--Silesaurus opolensis

All these nomenclatural goof-ups aside, it's a pretty cool animal, and not just for its size. The toes are curved more than in any other pterosaur, and the authors interpret this as an adaptation to arboreality. I can just picture it hanging like a bat from a Mesozoic tree limb.

Preliminary anatomical reconstruction by John Conway. Click here for the full version.

What's interesting here is that it has arboreal adaptations, but it's not a primitive pterosaur. This same evolutionary pattern is seen in birds (avialans): the earliest members lack arboreal specializations, but some later members developer them. But this pattern is not, so far as we know, seen in bat (chiropteran) evolution. The earliest known stem-bats have arboreal adaptations, while the earliest pterosaurs and avialans do not. Might this reflect a fundamental difference in body plan between pan-mammals (including apo-chiropterans) and sauropsids (including pterosaurs and avialans)?

Two N. crypticus in a tree, by John Conway. Click here for the full version.


Reference:
Wang, X., A. W. A. Kellner, Z. Zhou, and D. A. Campos. (2008 February 12). Discovery of a rare arboreal forest-dwelling flying reptile (Pterosauria, Pterodactyloidea) from China. Proceedings of the National Academy of Sciences 106(6):1983–1987. doi:10.1073/pnas.0707728105