Skip to content

Dolby? In a TV context?

The big deal this season looks to be TV sets. The fifty to eighty inch diagonals are getting below $2k for OLED and below $1k for standard LCD with all the bells and whistles. One of the new features is HDR or high dynamic range that is showing up in 4k sets with a lot of brightness. PhysOrg carries a report that New TV tech promises better picture for mainstream consumers (November 25, 2016 by George Avalos, The Mercury News).

Televisions that promise a significantly improved picture will be available this holiday season at mainstream prices for the first time. Using a technology called HDR, or high-dynamic range, the sets can display more dynamic colors than older TVs and will allow you to see more details in both bright and dark areas of the screen.

HDR is only available on TVs that offer 4K – or ultra-high definition – resolutions. It promises to do what 4K generally doesn’t – offer a noticeable difference in picture quality.

While more programming and cheaper TVs are hitting the market, analysts are skeptical that a consumer rush on HDR sets is imminent. While the 4K HDR sets offer dazzling pictures, the increase in quality is not nearly as dramatic as the leap from older TVs to the first generation of flat-screen sets.

Another factor that could hold up sales is a nascent standard war between different flavors of HDR technology. Some sets and online video services support a standard pushed by Dolby called Dolby Vision.

This brings back memories of the 80’s and the quad channel sound, Dolby noise reduction, and the struggle to come up with something commonly available. So many choices and you can’t tell which is best (unless you’re super-human).

One item to look for: nits. The more nits, which refers to the brightness of a display, the better. Consumers should seek TVs with a spec of at least 1,000 nits, said Paul Gagnon, San Diego-based director of TV research with IHS.

Plus, there’s the old rule of thumb for buying a TV: Experts recommend shoppers seek out high-end models produced by well-known manufacturers.

“There are a lot of claims made by companies around specifications, but the consumer needs to make those judgments in person,” Gagnon said. “It really pays to go into a store and look at demonstrations. We all perceive images differently.

“You really need to be there in person to see if it’s worth the difference in price.”

It’s deja vu all over again!

Cultures for idea development

Ever wonder why English has such a rich written tradition? Why Tolstoy was Russian? The expression of ideas depends upon culture and software is no different. This is what Adam Michael Wood is arguing in choosing between Python and Django vs. Ruby and Rails.

tl;dr – Python

I have a particular app I’m trying to build, and it is just the sort of content-driven, database-backed, CRUD app that both Ruby on Rails and Django are perfectly suited for. (And that WordPress idiots evangelists would claim would be just perfect as a custom plugin, except that’s a terrible idea.)

So here is the definitive answer…

What matters in either case is the community of people who have gravitated to each language and (therefore) what kinds of tools are available for each. Also, the focus of the two disparate communities has impacted the design of Django and Rails in different ways.

So… bottom line: If you are learning to code because you want to be an entrepreneur, learn Ruby on Rails. If you are learning to code because you want to do unique and interesting things as a developer, learn Python.

Of course, YMMV (your mileage may vary) but the key is the “community of people” and that shows up everywhere things do or do not get done. A business is a community that chooses a certain culture. If it chooses wisely, it will grow and prosper. Governments – ditto. Notice, too, how the undergraduate culture of Dartmouth influenced BASIC in the documentary previously noted.

Wood provided a laundry list for his choice of Python. That helps to understand its popularity. The contrast and comparison he provides doesn’t help that much with the alternatives but that would tend towards all the technical comparisons that are divorced and distanced from the communities they reflect. It is also  worth noting that communities are tribal collections and they can be very protective and defensive. What this means is that trying to figure out the best software development environment isn’t a simple or straightforward analysis.

Consider the Arduino IDE versus Eclipse and how the Arduino handles C microcontroller software development at a BASIC level. Eclipse includes the kitchen sink so developers can use any one of many programming languages and do nearly anything they want. The Arduino simplifies developer choices and provides a basic toolkit. Then there’s micropython which can be compared and contrasted to the Picaxe BASIC or similar simplified microcontroller platforms.

tl;dr = too long; don’t (or didn’t) read. Wood was referring to search results when he investigated his question. We live in an ocean trying to find Flotsam, jetsam, lagan, and derelict (wikipedia). It is wealth for all of us.

Birth of BASIC – early systems development for the sake of computing

On YouTube is the story of an early project in computing, the Birth of BASIC. The timeframe is 1960 +/- a few years. The story isn’t just the development of BASIC but also that of interactive computing on a time sharing operating system.

The 38 minute video also shows the struggles in funding and in acquiring hardware. Another point brought out is that the programmers were undergraduate students. The focus was not on using the computers for academic research but rather for education. That meant that students were ‘turned loose’ to program what interested them and that creating access to high schools was also in the pipeline.

It is hard to imagine what was then if your experience is what we have now. A bit of history and a reflection on just how much has advanced in so little time provides a perspective on just what an epoch we inhabit.

Modern software development – not your granddaddy’s computer no more

Paul Galvin talks about Overcoming Functional Programming’s Cognitive Dissonance Issues (for sticklers like me).

I don’t know how much you’re like me, but if you are, you can get bogged down in the specific meaning of words, concepts, definitions and how these apply to the real world. I can personally have a difficult time bridging the gap between notional definitions and real world practice

I don’t know how much you’re like me, but if you are, you can get bogged down in the specific meaning of words, concepts, definitions and how these apply to the real world. I can personally have a difficult time bridging the gap between notional definitions and real world practice

So if you’re like me — a bit of a stickler for literal definitions — and you’re interested in functional programming, try and let your guard down a bit. I have been chipping away at my preconceptions for a while now and I’ve been enjoying some success. You may too.

This is what has hit me in exploring Python. Up until now, with Fortran, Basic, C, Java, and other classics, programming has been atomic. an equal sign indicates an assignment of one thing to another thing. Classes, structures, methods, and functions were just straightforward representations of collections or algorithms that boiled down to individual values of a defined type. Program structure was still just assign, compare, and branch. No more.

Functional programming uses a word that had a specific meaning in the classic context and takes it to new galaxies. The term “functional” no longer means just a chunk of code stuck out in a pile because of convenience and resource conservation. It is now a style of problem solving with nuance and depth. Getting from what was to what is now isn’t a simple journey and that is why Galvin’s Cognitive Dissonance strikes a chord.

Micropython is especially revealing in this light. Set up a WiFi station and then scan for networks and you get a list of tuples back. In the really old days, that’d been a two dimensional array.  Not all that long ago, it’d be an array of structures or classes. Now, the tuple that describes the SSID and other properties of networks heard by the WiFi radio is an ordered collection of constants. A loop can iterate through the list of networks and a single assignment can break out the tuple into individual variables so you can parse the values for authorization mode and other properties to print out a pretty report of what was heard. 

Underneath this is one of the issues that caused the break between Python2 and Python3. That is Unicode (wikipedia). The idea of an English only character set that could be conveniently set up with only 256 or fewer items gave way to world wide computing that needed to accommodate many languages and alphabets and symbols. That really messed things up for programmers as the simple structures they used to manage character strings became much larger and more complex. With lots of memory and computing power, that wasn’t too big a deal but with the Micropython target size and complexity presented problems.

Another way of looking at this is that the mathematicians are creeping into programming. It used to be that being able to program was a matter of understanding algebra. That created a lot of ‘cognitive dissonance’ in schools as many educators had set ‘computer literacy’ up on a pedestal as an alien god and that led to a lot of bad schooling. For mathematicians, computer literacy was just a flavor of their usual studies and computers were really rather simple as they weren’t electronic engineers trying to design logic gates that actually worked. Mathematicians often start with something simple and build things. The things they build are means to communicate ideas and concepts in a very rigorous way. Newton and Leibniz ‘invented’ calculus as an example. Even algebra was invented to describe and help solve a class of problem.

Now, with computer programming, mathematicians have a new world to play in. One outcome of that is new paradigms in thinking about the representation of algorithmic solutions for classes of problems.  That thinking shows up in the plethora of modern programming languages. Galvin’s advice to “let your guard down a bit” is classic for learning and something all teachers know at one level or another. 

It’s not a change that everyone sees but it is one that impacts them all. Never in human history has such a period existed with so much change so fast in how we think about the problems we face. We live in interesting times.

One thing leads to another: Time for the pi, GPS, ntp, ESP8266, microPython, Lua

The pi boots without any calendar time reference. If it comes up on the I’net, it uses ntp to set the clock but offline it has no reference. Things work pretty well by just ignoring the clock and I could just set it manually if need be. The other options would be to use a clock chip connected via I2C or, for just a bit more in cost, a GPS dongle. The GPS would need a view of the sky, though. Still. GPS is more accurate and provides other possibilities. And then there’s the GPS modules intended for drone use that have pressure sensors to measure altitude, temperature sensors to calibrate the pressure sensor, accelerometers, magnetometers, and gyroscopes for measuring attitude and motion. That gets even more delicious on options and possibilities.

There’s lot of stuff out there about using a GPS on a pi for a stratum 1 time server but the idea of getting a better sky view and using the sensors for environmental (e.g. weather station basis) sensing brings up the idea of a solar powered external doohicky on a wifi network to provide time and weather data using standard network protocols. That leads to the ESP8266 and its successor the ESP3212. Even though that wifi radio microcontroller has been out only a couple of years, it has a vigorous community, a lot of support, and even ntp, GPS, and weather station examples to serve as a starting point.

Since the successor isn’t readily available yet, initial development would be based on the ESP8266.  There are inexpensive boards for that with power regulators, USB access to the serial port, and other development conveniences. NodeMCU (documentation) seems to have provided a reference design that many others use. A version of Lua is provided with those boards to provide interactive script development needing only a terminal. Another option is to use the Arduino IDE with the ESP8266 add-ons and then tap into that massive ecosystem. Adafruit has a good rundown on how to do this with their HUZZAH version of the NodeMCU board. The Arduino process is, basically, compiled C. Another option is microPython which is a rather recent effort that provides a modern interpreted environment.

One factor that pops up in looking at these things is memory. The ESP8266 has about 50k for user data out of 96kB on chip data RAM and 64 kB instruction RAM (wikipedia). In comparison, the TRS80 Model 1 in 1980 (wikipedia) used up to 16k of instruction ROM and 48k for data RAM. The TRS80 used tape or, later, floppy for 100k of external storage. The ESP8266 usually has a 4 MB flash memory chip accessed by SPI and its clock speed is about 40 times that of the early personal computer but costs more than 100 times less. 

Bill Gates got a usable interpreter for those early PC’s into 4 KB and BASIC is still an option on the modern microcontrollers as Geoff’s Mighty Mite project illustrates. That modern firmware for a chip has a lot more memory to work with at much faster speeds so it’s more like a 1990’s BASIC than the 1980 TRS80 version. The Picaxe BASIC fits in here, too, as it is designed to run on older low end microcontrollers not that far from the TRS80 capabilities.

I’ll probably experiment with Lua some as it comes preloaded on the NodeMCU board I ordered. It appears to have some good features but the memory restrictions seem to cause some problems, it uses floating point numbers for everything unless you do a custom compile, and doesn’t have quite the breadth of community for support and portability that other options have. microPython also has some memory issues but it has the community, support, and portability benefits. The Arduino IDE with its C basis and compiled code takes care of the memory issues and also provides the support and community. So it looks like I’ll focus on microPython to see what the chip can do and how it works and the Arduino IDE for building final code. Both should have good transfer facility to the newer ESP3212.

Start with something simple – set the clock on a Raspberry Pi – and look where it leads! How does GPS work and how can it be used as a time standard? What is the ntp protocol and how is it implemented and what sorts of issues does it address? What about time resolution, calendars, epochs, accuracy, latency, and other such issues? What are the issues in using the pi for GPS based time service versus using a dedicated microcontroller with a standard wifi link using established protocols? What is the best development environment and firmware protocol for the microcontroller? — it’s not so simple anymore.

Rallynet CONF soup: Setting up hostapd, dnsmasq, and nginx

The base honeypot LAN server requires only a few software packages and very little configuration. LAN means local area network and honeypot refers to it being set up to route all network inquiries to its own services with no outside connections. This post is about the basic set of services needed for an isolated network that will serve up a local website. The first thing to do is to install the packages.

apt install hostapd, dnsmasq, nginx

A network has an interface, the hardware that makes the connection. Configuring this is done in the /etc/network/interfaces file. Here, I use eth0, the plug in cable connection as the standard outside network connection. wlan0, the wifi device, is defined to stand by itself as a “static” device with a fixed address and defined network parameters. The “auto lo” thing is how the computer refers to itself when it wants to use network protocols for internal communications.

auto lo
iface lo inet loopback
iface eth0 inet dhcp

allow-hotplug wlan0
iface wlan0 inet static
address 10.0.0.1
netmask 255.255.255.0
broadcast 255.0.0.0

# pre-up iptables-restore < /etc/iptables.rules

# allow-hotplug wlan1
# iface wlan1 inet manual
#     wpa-conf /etc/wpasupplicant/wpasupplicant.conf

The wlan1 stuff is commented out here but left so I can later experiment with the possibility of using the wifi connection to connect to two distinct networks. As it is, if I am trying to use eth0 on one net, say to get upgrades, and wlan0 as another, say the honeypot LAN, there are issues. Somebody using a cell phone might have similar problems if they have the cell network up at the same time they are connected to the Rallynet.

The “pre-up iptables” item is for adding security later. iptables is used to control what kind of network information is allowed to go from where it came from to where it wants to go.

hostapd is the service that enables other computers to talk to the Rallynet computer. It provides the network ID and handles connection security. It is a good idea to make sure the startup script /etc/init.d/hostapd knows where the configuration file is. Look for the line that defines DAEMON_CONF and modify it or add it if missing so the file contains the line

set DAEMON_CONF=/etc/hostapd/hostapd.conf

For a simple hostapd configuration that has no security, you can use:
# file /etc/hostapd/hostapd.conf
interface=wlan0
driver=nl80211
ssid=SNU
channel=1

The driver clause is there because hostapd needs proper hardware support and a software interface to that hardware that supports access point (the ‘ap’) protocols. The ssid is the network name that shows on the list people will see to select when they want to connect to the Rallynet. Here it is “SNU”.

dnsmasq provides information to connecting computers so they have an address on the network and know how to find things.
#file /etc/dnsmasq.conf
address=/#/10.0.0.1
interface=wlan0
dhcp-range=10.0.0.50,10.0.0.150,12h
no-resolv
no-hosts
#log-queries
#log-dhcp
log-facility=/var/log/dnsmasq.log

The address= line specifies that anytime a computer looks for an address to go with a domain name it will get the honeypot address. This means that anyone looking for their favorite web site will get directed to the honeypot instead. I’ve had problems with this when other networks are connected or when browsers think you’ve entered a search term rather than a domain name (e.g. “rallynet” rather than “rallynet.com”). no-resolv and no-hosts are in there to make sure that the local rallynet computer routing instructions are not used by other computers on the Rallynet. If find it works best to issue a “sudo systemctl stop dnsmasq” when I am plugged in to the I’net in order to get updates or whatnot. This helps avoid confusion.

nginx is a modern alternative to the old standby APACHE. I use it because it is supposed to have a smaller footprint and, I’d hope, reflects some lessons learned in twenty years of web servers. It is full featured and able to serve many websites with all sorts of features so configuration can have a lot of complexities. My major problem was making sure the “;” end of statement markers didn’t get lost in cut and paste operations I used to consolidate a tree of configuration files into just one. This example still includes a lot of things that explicitly restate defaults that are aren’t really necessary for the Rallynet so some pruning is still possible.

#file /etc/nginx/nginx.conf
user www-data;
workerprocesses 4;
pid /run/nginx.pid;
events {
  workerconnections 768;
}
http {
  sendfile on;
  tcpnopush on;
  tcpnodelay on;
  keepalivetimeout 65;
  typeshashmaxsize 2048;
  include /etc/nginx/mime.types;
  defaulttype application/octet-stream;
  sslprotocols TLSv1 TLSv1.1 TLSv1.2; # Dropping SSLv3, ref: POODLE;
  sslpreferserverciphers on;
  accesslog /var/log/nginx/access.log;
  errorlog /var/log/nginx/error.log;
  gzip on;
  gzip
disable “msie6”;

  #include /etc/nginx/conf.d/.conf;
  #include /etc/nginx/sites-enabled/
;

  server {
    listen 80 defaultserver;
    listen [::]:80 default
server;

    root /home/www-data;
    index index.html index.htm index.nginx-debian.html;
    server_name _;

    location / {
      tryfiles $uri $uri/ =404;
    }
    error
page 404 /index.html;

  }
}

The server section is where the customizing is really needed. I put the website in the /home directory rather than in /var as was the install default. The “location” and “error_page” statements work with the dnsmasq honeypot routing so that unknown pages on out of LAN domains will all route to the Rallynet home page. 

Note the log statements in the configuration files. I uncomment them when I first start out so I can find errors. Note also that these services often have utilities that will check their configuration files to make sure they are valid. When I get everything working, I’ll comment out the log statements to avoid filling up the file system.

This CONF soup is just about as bare bones as I could get it. Now I can start adding security or other features a step at a time and keep the debugging simple.

Be sure to save the default configuration files! These are a good resource for the options available. The servers also have man pages you can reference to find out about the configuration options. Web searches are also good ways to find examples and explanations.

Rallynet: Proof of Concept guidance

The first question was what to do with this thing (the Raspberry Pi or just pi). The NOOBS (new out of box software) install process worked well and provided a multi-boot pi with Raspbian, LibreELEC, and OSMC. Nice. Worked. Made a nice media center for the RV. Now what? How about a web services host so RV rally participants could upload their pictures to share? That led to Rallynet as a honeypot LAN installed on the Raspbian system. It worked, too. Now what?

That was a successful Proof of Concept so now the question became one of how to simplify and enhance. That meant being able to run both the media center and the Rallynet at the same time. It meant being able to dispense with the need for external USB storage. It meant looking into easier methods of file sharing.

First on the list was the host operating system. This came down to the recently announced Ubuntu Mate for the pi or Raspbian. There are a lot of other options and all are available to test and try out at the Raspberry Pi Download site. I decided to stick with Raspbian as it boots fast, has an established and vigorous community supporting it, puts a focus on development and maker needs, and is more directly customized for the hardware. The proprietary graphics in the pi are better accommodated with Raspbian although effective optimization to be able to show HD video requires re-building VLC or using an independent repository to get a special build of Kodi.

The latest release of Raspbian with all the latest bells and whistles was a nice clean install and it left near 30 GB of free space on its 32 GB micro SD card. Some of my favorite utilities installed with no hassle. To get the Rallynet services and GPS dongle tools, I installed from a terminal command prompt:

sudo apt install gpsd gpsd-clients python-gps hostapd dnsmasq nginx droopy photofloat gkrellm gkrellm-leds gkrellm-cpufreq gkrelltop lm-sensors gkrelltopd vim vim-gnome

This idea is to use GPS to set date and time on the pi. That project is quite a can of worms. It turns out that GPSd is an Eric Raymond (a long time well known FOSS advocate and activist) headed project with deep roots. It’s purpose is to take the device connection and message format issues and present them as a consistent and known API to facilitate GPS based utility development. GPSd can use shared memory to communicate with NTPd for a very accurate time service. Modern GPS devices intended for items such as drones provide barometric sensors and 9 axis motion sensing as is common in cell phones. That brings up the idea of using the device as the basis of a weather reporting service.

hostapd, dnsmasq, and nginx provide the base for Rallynet as a honeypot LAN and a post on the Rallynet CONF soup will be up shortly to show how these were set up.

droopy is a Python script providing html based service on port 8000 to upload files. That means rally participants who take pictures with their cell phones can use their phone browser to upload their pictures to the Rallynet. If it works, I won’t need to install Windows file sharing services.

photofloat is a photo gallery that uses the standard file system for its data store. It includes a Python script will scan the photo folders to create thumbnails and JSON format descriptions in a cache for a simple web page photo gallery service. Eric Raymond has a good rundown on JSON in his story about the development of GPSd. The format came out of the programming language that started as a simple scripting  capabilities in web browsers and is now a massive part of website presentation and web apps.

One project is to either use a Python system monitoring script that detects file system changes or a modification of droopy to call the pictures scan after an upload has occurred. That will keep the photo galleries up to date with submissions.

So now it’s on to phase II. 

Grokking Python

One of the challenges – and major benefits – to an old school programmer learning Python is to get a handle on new ways to approach and talk about old problems. Java is ‘object oriented’ but much of how it does things is not that much different from the classic procedural languages. Python is another story.

In Python, everything is an object. That means there are no primitives.All variables are pointers to objects that have a number of properties like value and type. Pointers have a long history in C and they can be a source of confusion in some circumstances of you are not careful. Those properties that are available in Python are necessary to help keep things straight.

Constants are called immutable and an immutable list (list is the name used for an array) is called a tuple. Whereas a list with values that can be changed is enclosed in brackets, a tuple is optionally enclosed in parentheses. 

There are other collections like dictionaries and sets and there is functionality that allows common actions on these collections as well as handling set of collections. This is much more interesting than just having multi-dimensional arrays and hash indexing.

The Python iterator concept takes the old idea of a counter to step through a loop to a new level. Instead of just a counter variable that steps from here to there by how-much, an iterator is an object that will return successive values and, as an object, it can be controlled by mapping or filtering to produce interesting results.

Inline functions are established by using the key word “lambda” rather than the “def” that defines the standard function. There are some implications beyond this simple distinction that need exploration.

The use of white space seems to cause a lot of dissonance. That means arguments much like C programmers get into about line indentation. I don’t know why it bugs people as white space even goes back to Fortran on punch cards. Python just expands it a bit. Enforcing white space means that a lot of punctuation to define code blocks and statements isn’t necessary in Python and that can reduce errors and improve readability.

MicroPython is an effort to get the core ideas of Python development in a microcontroller. That means a modern interpreted coding environment to compete with BASIC, Forth, and similar classic options. For Python, it means trimming down the standard library and limiting the core language somewhat. 

Python has a lot of capabilities that could be useful in GPS applications. GPS data often comes in as records that are string of bytes that can be ASCII using standard NMEA clauses or binary using proprietary structures. Python provides a Struct function that will unpack these records by mapping to a format that indicates the binary data type and the manner the binary data is mapped to various data types. 

That is some of the base that everything else is built upon. What Python advocates refer to as “batteries included” is another level. If you want to anything in software, the odds are pretty good that someone has done it before. Standard language libraries are a result. Python has a very rich set of libraries that is included with its interpreter and is available anywhere Python is. Java also has an extensive library. C, in contrast, has a small default library but that is appropriate for its focus.

It’s all about paradigms for thinking about problems and expressing ideas. It used to be learning a new language was just about English or French or Russian. Programming languages are nowhere near as complex but can still provide a lot of insight into different ways to see things.

In the news: FCC vs innovation,

There is sometimes a need to provide a governor on things to keep them from going out of control. Protecting trade secrets has a long history that the patent idea was embedded in law to open this up a bit in a controlled way. Regulation is almost always a limiting control and it is another way to keep things from going out of control. There are two examples in the news this morning related to the struggles on this topic.

Amateur Radio exists, in part, to advance the state of the art. With SDR technologies and digital modes, the costs of radio communications experimentation have been reduced so that a larger bunch of hams can get involved. But Amateur Radio is regulated and keeping regulations up to date with the implications of technology is a nontrivial exercise. Current Rules Holding Hams Back from Adopting State-of-the-Art Technology, ARRL Says.

ARRL told the FCC in its comments that the current HF symbol rate “speed limit” reflects 1980s technology and has no place in an experimental radio service in which modern protocols could be efficiently deployed in crowded RTTY/data subbands.

“The symbol rate limit was created in order to maximize the efficient use and reuse of that crowded, shared spectrum, but the assumptions made at the time are no longer valid,” ARRL said, “and the rules now prohibit radio amateurs from utilizing state-of-the-art technology, thus precluding or substantially inhibiting any meaningful contribution to the advancement of the radio art in this area.” ARRL said earlier assumptions are no longer valid mainly because there is no correlation between the data rate and the occupied bandwidth in the rules now.

Another inhibitor is described by Michael Larabel reporting that Raspberry Pi VC4 Graphics Driver Working To Support QPU Shaders.

The latest Raspberry Pi graphics driver hacking by Eric Anholt of Broadcom has been working to support QPU shaders by this open-source driver stack. QPUs are the shader core of the graphics hardware found in the Raspberry Pi SoC, but come up short of supporting OpenCL or OpenGL compute shaders

Eric is looking at supporting QPU shaders now though with this open-source driver stack since it can be used for accelerated video decode.

On this last, that is why I had to re-build VLC and suffer it’s taking over the screen the way it does in order to use it to display videos. The Tutorial: Compile VLC with HW acceleration – Jessie, RPi 2/3 worked well and produced good results. It also provided an insight into the size, scope, and complexity of modern FOSS projects that really puts my 1980’s experience in systems software development in perspective. 

The default media play in Raspbian is OMXplayer and it works but it also takes over the screen and you have to launch it from a terminal window to use keyboard commands to control it. The VLC option appears to respond to keyboard input to the display window. Additional experimentation is needed.

Tofu and the NoTo font project

Perhaps you’ve seen it? Some document on the web or PDF or a word processing document with characters that look like little boxes of tofu? That’s what happens when a called for font or the substitute for it does not have a proper glyph for the character code. All text is to a computer is string of character codes that indexes display instructions. Those display instructions can be a bitmap or a mathematical description that must be processed to create something to put on the display device or printer in the space allocated and within the specifications of the device.

Google didn’t realize how big a problem this was until Android and ChromeOS became popular in wold wide markets.

The Noto font project (it’s a mashup of ‘NO more TOfu’) has been something of a labor of love, taking five years to reach its conclusion. But the result is an open source Noto font family which Google says includes “every symbol in the Unicode standard, covering more than 800 languages and 110,000 characters”.

When we began, we did not realize the enormity of the challenge. It required design and technical testing in hundreds of languages, and expertise from specialists in specific scripts. In Arabic, for example, each character has four glyphs (i.e., shapes a character can take) that change depending on the text that comes after it. In Indic languages, glyphs may be reordered or even split into two depending on the surrounding text”.

Mark Wilson: Google releases open source font Noto to eliminate the tofu problem.

Fonts on computers have always been a challenge. Consider Donald Knuth’s Tex [wikipedia] released in 1978. Adobe got into the act in 1984 when it released its page description language [wikipedia] and Apple, due in part to licensing costs, came up with TrueType in 1991. But when you get into fonts, you get into typefaces and glyphs and rendering methods and pixelated display issues. That’s the software facet. Another facet gets into presentation, readability, and human factors. What Google got into was another facet that is the mapping of glyphs to alphabets to language constructions. Unicode was developed to help code these things but artwork was needed to fill in a representation of the indexed glyph.

That’s a long way from the character generator chip on my TRS-80 model 1 where I had to piggyback another bit of memory in order to get lower case in a 5×8 pixel array mapping. I can image what would happen if I tried to use that computer to map a modern font glyph onto its screen. I’m not sure it even had enough memory to store the code needed for the glyph description in its memory much less the code to translate that description to a screen image. And how long would the processing take?