In 2017 I worked on the Stylo project, uplifting Servo’s CSS engine (“style system”) into Firefox’s browser engine (“Gecko”). This involved a lot of gnarly FFI between Servo’s Rust codebase and Firefox’s C++ codebase. There were a lot of challenges in doing this, and I feel like it’s worth sharing things from our experiences.
I figured I should just post this somewhere so I can make future reference to how I feel about the matter, anytime someone asks me about such-and-such video, 3D, game or “dynamic” multimedia system. Don’t get me wrong, I like me some illustrations, photos, movies and music.
But text wins by a mile. Text is everything. My thoughts on this are quite absolute: text is the most powerful, useful, effective communication technology ever, period.
Before college the two main things I worked on, outside of school, were writing and programming. I didn’t write essays. I wrote what beginning writers were supposed to write then, and probably still are: short stories. My stories were awful. They had hardly any plot, just characters with strong feelings, which I imagined made them deep.
The first programs I tried writing were on the IBM 1401 that our school district used for what was then called “data processing.” This was in 9th grade, so I was 13 or 14. The school district’s 1401 happened to be in the basement of our junior high school, and my friend Rich Draves and I got permission to use it. It was like a mini Bond villain’s lair down there, with all these alien-looking machines — CPU, disk drives, printer, card reader — sitting up on a raised floor under bright fluorescent lights.
The language we used was an early version of Fortran. You had to type programs on punch cards, then stack them in the card reader and press a button to load the program into memory and run it. The result would ordinarily be to print something on the spectacularly loud printer.
There was a little cafe I used to go to that did the best bacon sandwiches. They came in a soft and pillowy white bap. The bacon, thick-cut from a local butcher, was midway between crispy and chewy. Ketchup and HP sauce were served in miniature jars with the sandwich, so you could dab on the exact amount you liked. That was all there was to it: just bread and bacon and sauce. Eating one of these sandwiches, as I did every few weeks, with a cup of strong coffee, felt like an uncomplicated pleasure.
And then, all of a sudden, the bacon sandwich stopped being quite so comforting. For a few weeks in October 2015, half the people I knew were talking about the news that eating bacon was now a proven cause of cancer. You couldn’t miss the story: it was splashed large in every newspaper and all over the web. As one journalist wrote in Wired, “Perhaps no two words together are more likely to set the internet aflame than BACON and CANCER.” The BBC website announced, matter-of-factly, that “Processed meats do cause cancer”, while the Sun went with “Banger out of Order” and “Killer in the Kitchen”.
In shared memory multiprocessor architectures, threads can be used to implement parallelism. Historically, hardware vendors have implemented their own proprietary versions of threads, making portability a concern for software developers. For UNIX systems, a standardized C language threads programming interface has been specified by the IEEE POSIX 1003.1c standard. Implementations that adhere to this standard are referred to as POSIX threads, or Pthreads.
The tutorial begins with an introduction to concepts, motivations, and design considerations for using Pthreads. Each of the three major classes of routines in the Pthreads API are then covered: Thread Management, Mutex Variables, and Condition Variables. Example codes are used throughout to demonstrate how to use most of the Pthreads routines needed by a new Pthreads programmer. The tutorial concludes with a discussion of LLNL specifics and how to mix MPI with pthreads. A lab exercise, with numerous example codes (C Language) is also included.
Limbs can be incredibly useful. Whether it’s the wing of a bat, the elongated leg of a hopping frog or our own grasping arms, limbs have been adapted to all sorts of ecosystems and functions through the course of evolutionary time.
The earliest limbs date back to over 375 million years ago. The fossil record has beautifully documented how the fleshy fins of ancient fish became more and more limb-like and allowed our amphibious ancestors to come ashore. These creatures, like us, are known as tetrapods—or “four limbs.” Now a study on a modern fish familiar to aquarium enthusiasts has provided new insight into the genetic underpinnings of this transcendent change. Boston Children’s Hospital biologist M. Brent Hawkins and colleagues published a study today in Cell that demonstrates mutations to either of two zebrafish genes can create a very limb-like fin in these fish. By using gene-editing techniques to replay the mutation in the lab, the researchers were able to pinpoint how some zebrafish grow fins that have more of a resemblance to our arms.
“We found that the effects of management strategies like controlled burns and bison reintroduction on animal communities were six times stronger on average than the effects of plant biodiversity,” Guiden said.
“The most important effects of restoration on animal biodiversity had little to do with plant community biodiversity,” he added. “So management practices focused on restoring plants might be insufficient to also restore animals.”
Like many who walk the hallways of elite institutions, Ram Dass’ life intersected with influential mid-century thinkers and doers. His most famous collaborator might have been Timothy Leary in the early 1960s. Their landmark studies of psychedelic drugs lead to his dismissal from Harvard in 1963…
Disoriented little fish caught the attention of staff members at the Coleman National Fish Hatchery in Red Bluff, California, in early January 2020. Looking down into the outdoor tanks, called raceways, the facility’s employees noticed that among the dark, olive-colored clouds of live fish, there were occasional slivers of silver from the undersides of tiny fry that were struggling to swim. The fish would roll onto their sides, sink to the bottom for a moment, spring back upright, swim a few strokes, and then roll over again.
Many were dying, too. While a few hundred mortalities daily in a facility containing millions of fish is normal, something was definitely amiss.
When it comes to figuring out how similar various pieces of data are from one another (and which is the closest matching one in a large group of candidates), simhashing is one of my favourite algorithms. It’s somewhat simple, brilliant in its approach, but still not obvious enough for most people (myself included) to come up with it on their own. Readers may be familiar with hashing algorithms such as MD5 or SHA, which aim to very quickly create a unique signature (hash) of the data. These functions are built so that identical files or blobs of data share the same hash, so you can rapidly see whether two blobs are identical or not, or if a blob still has the same signature after transmission to see if it was corrupted or not. Then different blobs, even if mostly the same, get an entirely different signature.
While simhashes still aim to have unique signatures for documents, they also attempt to make sure that documents that look the same get very similar hashes. That way, you can look for similar hashes to figure out if the documents are closely related, without needing to compare them bit by bit. It’s a statistical tool to help us find near-duplicates faster.
That’s a bit vague, but that’s alright. I’ll try to explain things in a way that gives a good understanding of things.