Subtitle: Continuous Evolution Keeps 1960s Technology Alive

Short Abstract:

M is a conceptually simple language tightly coupled to a conceptually simple database. Originally developed in the mid to late 1960s, the technology has evolved to stay relevant in the 21st century. The talk reviews the history of the technology, the conceptual simplicity of both the M language and M database, and how the technology survives by evolving to adapt to the changing world of computing. Portability was a goal since its earliest days.

Longer Description:

M first ran on a PDP-7 and was a complete software stack: an operating system, a database, and a language. To run on such limited hardware, M seamlessly coupled a minimalistic database with a minimalistic language. It was based on a small number of concepts.

Fast forward more than a half century. While M is not mainstream software technology, it is the language and database of the largest real-time core-banking and electronic medical record systems. For example, a nation-scale medical record system in Jordan runs a complete FOSS stack developed in M. To robustly and securely serve such large-scale, mission-critical systems that require "five nines" availability, M has retained its core principles of a minimalistic language and efficient implementation, which allows it to scale down as well as up: the YottaDB implementation of M delivers thousands of database accesses per second even on a Raspberry Pi Zero with a consumer grade MicroSD card.

To remain relevant with changing economics and technology, M had to evolve. It moved from days when the cost of the hardware dominated, programmers were economical, and software was freely bundled with the hardware, to today. It has done so without compromising its foundational values. It ceased to be an operating system as it was ported to other computing platforms. A production grade implementation was released under a copyleft license in 2000/2001. While the M language retains its conceptual simplicity, the tight coupling of M, the language, with M, the database, now extends to other languages, C, Go, JavaScript, Lua, Perl, PHP, Python, and Rust. The talk will use examples from lua-yottadb, which tightly binds a highly capable minimalistic language and a highly capable minimalistic database.

Links:

• Project base: https://gitlab.com/YottaDB
• Source code for database with M anc C APIs: https://gitlab.com/YottaDB/DB/YDB
• Source code for Lua API: https://github.com/anet-be/lua-yottadb
• Source code for G, Python, Rust APIs: https://gitlab.com/YottaDB/Lang
• Source code for Perl API: https://gitlab.com/oesiman/yottadb-perl
• Source code for PHP API: https://github.com/chrisemunt/mg_php
• Source code for three JavaScript APIs: https://github.com/chrisemunt/mg-dbx-napi / https://github.com/dlwicksell/nodem / https://github.com/chrisemunt/mg-dbx
• User documentation (GNU FDL): https://yottadb.com/resources/documentation/
• Company home page: https://yottadb.com/