How to use the GLFPE public sample source code tree "glfpe_public_amd64" 20230713 GLF --------------------------------------------------------------------------------------------- Who and What ------------ The contents of this directory are intended to supplement and extend the usefulnesss of certain publicly distributed Live Boot Linux OS variants which support the GLF Programming Environment (GLFPE). There is a lot of source code in here, especially C code but also some examples of Arduino C++, FORTRAN, COBOL, Python, and Phix. Binary executables included were built on a 64-bit (AMD64) Debian 12 ("bookworm") Linux OS system and should immediately run on such a system, but the code can be readily recompiled on another system (even 32-bit) if it does not need specific 64-bit features. GLF maintains another such archive of similar tested 32-bit (686) compiled code, and also makes that available. IT IS ASSUMED THAT THE USER WILL USE A COMPATIBLE LINUX OS TO INTERACT WITH AND/OR REBUILD THESE PROJECTS (Similar Windows projects are kept elsewhere). Where ----- The author (GLF) distributes personal and public domain or other free and open source code samples to illustrate the utility of the programming resources made available using the author's remix Live Boot Linux distros (GLFPE and certain others). The author currently maintains a YouTube site with introductory videos about the GLFPE remix building system and its variations for other OS platforms such as Windows and Raspberry Pi. The "CustomOSMaker" YouTube site which hosts tutorial videos: https://www.youtube.com/@customosmaker476 The Google Drive hosting site for 100Gb+ of downloadable GLFPE related content: https://drive.google.com/drive/folders/0Bx8ieuuNjGp5WlZQNGdQQlpLWTA?resourcekey=0-VeEuNkLMCpF1QT5Cd0nm7g The "CustomOSMaker" site (searchable on YouTube) provides a series of (somewhat dated) tutorial videos which include in the Comments section a web link to a (hack) Google Drive "website" (cheap without the usual domain maintenance overhead). That link shows a "GLFPE" folder containing about 100 Gb of content, including ISO images of current versions of Live Boot Linux builds, associated sample source code, and voluminous instructions on how to use them. The site distributes live bootable ISO images ready to use like any other live bootable Linux distro such as Ubuntu, Mint, Centos, etc. The site aso includes proven configuration filesets and instructions to reproduce, upgrade, and optionally extend new copies of the same or the user's own remix of a similar custom OS. This also happens to represent the bulk of the author's personal accumulation of career and current programming work, warts and all. The author periodically works on projects which might be used by others. By backing up the personal project tree and making it available on an Internet accessible site together with a complete working OS environment with which to build, maintain, and extend it, the author provides any local (or remote) potential user the ultimate in offsite backup and documentation. Why --- You might wonder why Google Drive and not a regular website? Google Drive is simple, cheap, and holds all the necessary data. A "real" website would cost too much in time (security and maintenance), money (for domain, certs, etc.), and effort (web design, feedback) given the small expected demand and a very niche market. Why not GitHub? They won't host the numerous huge 1-7 Gb ISO files and configuration filesets necessary. Given the small demand, download times for a potential user should be similar to that for a more publicized or commercial OS source such as Debian, Ubuntu, Red Hat, etc. The author tries to update all the images at least ever couple of months, and the sample source depending on which projects show changes. It is possible to distribute this source code directly embedded within the OS images at build time, but for most potential users that makes the ISO images inconveniently large, taking more download and image "burn" time than desireable. In the past, GLF distributed images of the "GLFPE" OS variant with the complete public content as contained in this folder, but for the newly upgraded Debian 12 based remixes since June 2023, the author chose to try to minimize size of such public distributions. The high-volume source compendia will now be in a separate archive, with a simle documented method by which a user use an external work drive and treat the source tree as if it were installed into the filesystem. The distributin imnages will now contain a minimal test set of source to illustrate and verify the utilty of the installed toolsets. That way the user can "pay" (in time) more for working applications and up-to-date OS security features, and less for the sample code, which most users never need to update anyway. How --- The archive of this folder is packed into a *.tar.gz file. You will need a running copy of a GLFPE compatible live boot (or optionally installed) Linux OS with the necessary toolsets and libraries preinstalled to use the code in ths archive, The most likely boot medium you will use is a USB flash stick. If you don't already have such a live boot medium:. Several of the GLF distributed images have the necessary C/C++ and other compilers and libraries preinstalled, especially the flagship "GLFPE Linux OS". Go the the Google Drive GLFPE site (), navigate the tree and find the current Debian 12 live boot image ISO files. Select the current "GLFPE" image (Ex: debian-live-glfpe-807-amd64.hybrid.iso). Download it -- with decent bandwidth it should take an hour or so. If you only have a Windows machine you can download and install "Win32 Disk Imager". If you have Nero CD/DVD software, it can also do it. If you have a running Linux system, you can use the built-in "dd" command (for the brave -- be careful) or you can get one of a number of utilities to burn an ISO image to USB. The GLF Linux OS remixes all have the gnome-disk-utility (Applications, Accessorties, Disks). Burn the ISO file to USB as needed. Boot the computer from the live boot USB stick. Once you have the system running, you can connect to the internet to download any other files, such as this source tree archive. The file is large, so you will need something large enough to hold both the download and the unpacked file. You will need an external USB hard drive or SSD drive, or a VERY LARGE USB flash thumbdrive. If you use Linux, you should format at least one partition on that external drive for Linux EXT4 format, the ideal format to hold Linux programming work and NECESSARY if you will try to rebuild an upgrade of one the live build remixes later. Downoad this archive (glfpe_public_amd64.tar.gz) and unpack the contents to the external EXT4-format USB drive. Unpack it (extract using the Linux built-in archiver utility). You should now have a folder available with a large amount of content under "glfpe_public_amd64". YOU NEED A RUNNING COPY OF GLFPE LINUX OS TO DO THE FOLLOWING -------------------------------------------------------------- If you have just booted GLFPE, when you look into the user home folder you should see folders labeled "Arduino", "dosbox_cdrive", and "src". Those folders at startup only have very basic content, enough to barely satisfy the application which exppect those folders. Due to a quirk in the way the user folder is initially established on boot, GLF chose to not include large content into the home folder by default to preserve maximal RAM (and pseudo-disk or RAMDISK) space for real work. The way the "user" is created at boot time means that the usual default content in the user home folder is COPIED into the home folder at boot time. Since in a live boot by default THERE IS NO LOCAL HARD DRIVE, that is, the filesystem you see exists in RAM, not any hard drive (it actually uses the read-only content of the USB boot stick). If a large amount of data were copied at boot time, it could use up most or all the memory available and render the OS unuseable. To avoid this, GLF uses a trick. By storing the voluminous data in a "hidden" folder within an otherwise unnoticed part of the filesystem, it avoids getting copied into RAM at boot. However, the top level folder for the special storage has been specially prepared with "user" permissions so that if symlinks are created within the user home folder which point to that data, it is treated as if it is part of the home folder with the same user permissions. The symlinks transparently look like "real" folders to any program which goes into them. This happens without consuming any significant RAM, so the system usually has 2-3 Gb of RAM (and simulated hard disk) available at start. The workaround requires the user to execute a script to bring into view "hidden" content normally needed for programming tasks. Select "Applications", "Programming", "GLFPE minimal source" from the menu. A window will pop up and go away in a few seconds. When you look again at the user home folsder, the original folders will have been renamed (Arduino_0, dosbox_cdrive_0, src_0) and three symbolic links with the original names will have been insert. You should now find a larger amount of content under those new symlinked folders. You won't immediately see some additional content whaich has also been added to the Arduino IDE environment which adds some nondefault toolchains which atake up enough space to warrant the special treatment. GLF personally retains an undistributed personal variant of the GLFPE Linux OS (GPERS) which he uses for everyday work, and into this personal filessytem he piles so much "stuff" that the ISO image now exceeds 8 Gb. That OK for an image which is NOT downladed by others, because the image and the build configuration can be retained on locally available media. However, it is not very practical for casual users to need to download that much data every time an OS is uograded for security or bugfix reasons, especially when the bulk of that data is largely static for years at a time (some code samles are 35 years old). Because of the plan to reduce even further the size of the bootable ISO image, GLF decided to separate the full open source code tree to an external work drive for casual users. This archive holds a fairly complet collection of everything GLF wishes to share with any programmer who might be interested, or to local users if projects in which GLF played a development role. The ISO will still contain a minimal subset of sample source, contining the most useful tools, all locally built libraries of importance, and a small test suite to show how the toolset works. That would be enogh for a casual programmer to see how things go together. If a more interested user cares to see the whole sourcecode package, he can download this archive, unpack it to an EXT4 work drive, and then create some new symnlinks to the external drive, replacing the originals. Then all the same compilation tools would still work, but on more source files. If 20 people downloaded and used the GLFPE OS image, no more than 1 or 2 would probably care to download and use the entire public source tree. That would also allw the external source tree to conatain even more content, perhjaps additional documentation, since it won't load down the main ISO imnage every time. ASSUMING YOU HAVE THE OS RUNNING, AND YOU HAVE UNPACKED THIS ARCHIVE TO AN EXTERNAL DRIVE: ------------------------------------------------------------------------------------------- Insert the external drive with the "glfpe_public-amd64" folder on it into a USB slot and it should automount. Navigate into that drive, and into the "glfpe_public_amd64" folder. You should find immediately under that top folder a few subfolders: "source", "dbox", and "Arduino_1819". Make a symbolic link (symlink) to each of those folders (the right-click menu of the file manager shows "Make Link"). Rename or delete the prior symlinks which point to the minimal test suite. You should then be able to drag-and-drop the new links onto the user's "home" folder ($HOME or ~). Rename each of the symlinks to match their respective counterparts: "Arduino", "dosbox_cdrive", and "src". You will now have access to the full open and public distributable (nonrestricted) sample source trees. The content of "Arduino" should contain almost every project for Arduino IDE that GLF has worked on, including for other targets such as Arduino Namo, Uno, Mega, Teensy 2.0 and 3.5, Rpi Pico, various ESP32 boards, and Atmega ATTiny85. The "src" folder (link) should contain sample projects for FORTRAN, COBOL, Phix, Python, and C/C++ for both PC and Z80 platforms. The src/v64_122 subfolder contains almost every project ever programmed on PC under Linux by GLF (some 650+ projects). The "dosbox_cdrive" contains as much public releasable content runnable under DOSBOX-X which GLF can provide, including Turbo C 2.0 and Watcom C compilers and source code trees which largely follow the same projects and applications built using GCC on the PC platform.,