8 Sep 2021 GLF GLFPE -- Portable programming development environments for C/C++ and Arduino ----------------------------------------------------------------------------------------- What is GLFPE? -------------- GLFPE is the GLF Programming Environment, a working set of compilers, tools, and installed libraries which allow an interested user to reproduce and test executable versions of mostly C and C++ source code written and/or collected by GLF (Gary L. Flispart) over a span of almost 40 years of programming. An interested user might be someone who wants to try out computer programming in a known environment, with known working tools and sample source code, without needing to find out where to get all the components himself. The GLFPE project has gathered collections of such tools and code known to work in modern Windows and Linux settings. The Windows versions of GLFPE have been condensed to a mostly portable implementation, runnable on an installed Windows (XP up to 10) base, either by copying to hard drive or from a USB stick without installation. The Linux ports have been compiled and run on various installed OS variants, especially Ubuntu, Mint, and Debian in the past. Because the support libraries needed can be tricky to locate and assemble, more recently GLF has integrated the Linux ports into complete, user runnable, live boot OS images. These ISO images can boot and run the entire toolset from a DVD, USB stick, or VM (virtual machine) on almost any modern PC compatible computer, without installing anything to the computer itself. What can you do with GLFPE? --------------------------- If you use any of the versions of GLFPE, you can write, edit, compile, amd run C or C++ programs. On Windows, the GLFPE consists of just those utilities, compiler tools, and editor tools required to ensure that all sample C/C++ source code also provided can be successfully built and tested in that OS environment. The user is responsible for providing the Windows OS itself, along with any other unrelated applications required by the user. For Linux, an entire runnable OS environment is provided. Debian Linux, on which the GLFPE for Linux portable OS is based, is a free, openly distributable and user modifiable OS. It is possible to have a prebuilt, tested working suite of applications and utilities beyond merely the compilation support ready to run without requiring installation to a precommitted OS or hard drive. In addition, working bootable Raspbian OS (now Raspberry Pi OS) images copyable to SD cards are provided to port much of the same Linux programming and application environment to the Raspberry Pi (RPi) Microcontroller. In the GLFPE for Linux OS, as well as the Raspberry Pi, support is also provided for: Writing and compile programs written in C and C++, but in addition in Python and Java languages (using IcedTea IDE and OpenJDK). The Arduino IDE to program small microcontroller devices such as Arduino, PJRC Teensy, and Atmel ATtiny processors; For Arduino IDE (currently 1.8.5) the language used is Processing, which is a variant of C++; Immediately available use a variety of useful applications available as free software such as LibreOffice, VLC media player, Audacity sound editor, Chromium and Firefox web browsers, and a host of other applications which are available for download and installation. Where to find downloads for GLFPE files --------------------------------------- GLF does not yet run a full-fledged website, but has some introductory Youtube videos with links to the file tree on a personal Google Drive account -- here is a download link to the read-only shared file tree for GLFPE: https://drive.google.com/open?id=0Bx8ieuuNjGp5WlZQNGdQQlpLWTA Within that site, you can find a variety of "live-build" configurations, live boot ISO files, source code collections, and compressed packages of installed toolset installations (for Windows), as well as MD5 checksums for the files. All may be downloaded and burned to DVD-R or copied to USB to test. Of course, Google Drive is not intended to simulatneously download to hundreds of users at at time, so apologies in advance if things are slow (if only this distro could become popular enough for THAT to happen). The author can be reached at: customosmaker@gmail.com. Be aware the author is providing this stuff as a hobby, not a business, so please understand if he doesn't respond immediately. GLFPE is as open as the author can make it for several OS versions ------------------------------------------------------------------- PC compatible Windows GLF cannot pass along runnable copies of Windows for copyright reasons. However, Windows is almost universally available to PC users (at some cost). What GLF CAN share is a repackaged copy of working installations of open/free source applications and tools (IDEs, compilers, necessary object libraries) in a form known to work on Windows. GLF has assembled and tested them in as portable manner as possible, in the hopes that other users can replicate their function by copying and unpacking the files in a prescribed manner. PC compatible Linux Linux allows more flexibility. GLF can now actually give a potential user access to a fully working Linux OS system FOR FREE. GLF personally maintains live boot Linux distribution images to meet his own personal needs, and now posts the image files to the internet. Beyond just compiling programs, the other included applications are of broad interest, and useful in their own right to many potential users. GLF has been striving to get live boot configurations up to a state of universal maintainability, so that others may be able to replicate and extend the work. Since 2017, the configurations have become stable enough to try sharing them online. Debian Mate 11 (bullseye) is currently used as the base OS for a number of good reasons. Debian 11 stable is the current release, and it is now robust, stable, up to date, and maintained. MATE (a forked port of the Gnome 2 user interface) presents a stable and familiar desktop compatible with most applications, even older Linux X applications. Debian maintains perhaps the widest currently available software library. All applications and libraries in the Debian repositories are either open/free source, or their installable executable packages are freely available to all without restriction. Also, Debian does not further restrict the content in its officially released live boot images via copyright or trademark sanctions (Ubuntu and Mint DO RESTRICT such use). Therefore custom remix redistributions such as GLFPE based on Debian may be shared without infringement of Debian intellectual property. Most importantly, Debian openly provides the SAME tools used to package the official live boot ISO images for use by anyone running Debian (specifically the "live-build" package). Not only can GLF package and redistribute a fully working OS based on "live-build", he can share the configurations and tools with anyone else who wishes to do the same thing, and possibly extend or tailor their OWN custom version of the OS to suit personal needs. Not only does GLF make the system open, he passes it on for others to reliably do the same. Raspberry Pi There is even a tested port of GLFPE to the Raspberry Pi computer. Because the RPi uses a variant of Debian (Raspbian), the same freedoms apply to redistribution of working bootable images for the SD card in a Raspberry Pi. GLF works to update and clean up current Rpi versions of Raspbian (now Raspberry Pi OS) including GLFPE components and posts distributable ZIP-ed image files (with potential restricted personal content removed). GLFPE shares sample source code files ------------------------------------- The target user of the GLFPE, particularly the live boot versions, is someone who is more than a casual computer user, in particular a programmer or technology hobbyist who is interested in trying to code personal programs, perhaps to run on Internet-of-Things (IOT) devices such as Arduino or Raspberry Pi. The GLFPE runtime environment collections are distributed by GLF to share potentially useful tools and techniques (and showing off a little of his life work). That desire to share extends to several hundred sample C/C++ programs which GLF has developed (or copied from other free sources) over many years, all of which can be compiled and run under the GLFPE. These samples are offered as demonstrations or suggestions -- they do not represent the ONLY way to do things, only a way that has worked for the author. The functionality of GLF career and personal source code has been incrementally ported and expanded over many years from minicomputer Fortan (1970s), to MS-DOS (1980s), Windows (1990s), and Linux (2000s) OS environments. GLF has long taken an interest in open/free source applications and support libraries. A career working for a government agency in support of openly distributed scientific analysis offered ample opportunities to freely share and distribute suppporting code along with whatever application and data products supported the modeling and analysis. Some of the code is admittedly archaic, having begun in a DOS world (or earlier) and perhaps of limited interest to anyone other than the author. Other code is sample code written by others, or adapted by GLF, to display the vast capabilities of various open graphics, mathematical, and GUI support libraries. The very fact that the C and C++ code still compiles and runs after 30 years is of value in itself as a demonstration of the robustness and stability of the C language concepts embodied in the code. Even to the extent the old, untended code contains now-obvious mistakes or bad programming ideas, while embarassing to the author, can provide teachable bad examples. Use and abuse at your own risk. Specifics for alternate OS versions of GLFPE -------------------------------------------- There are versions of GLFPE which run on various operating systems including Microsoft Windows, Debian Linux on 32-bit and 64-bit x86 CPU, and Raspbian OS on Raspberry Pi. These are not all maintained with equal frequency and some are more up-to-date than others. All tools, libraries, OS, and source code are provided in good faith as APPEARING TO BE functional, having worked in test runs by GLF using his own equipment as of the archive date. Documentation of original internet source sites for all major tools and work provided by others is (hopefully, usually) provided elsewhere by the author. GLFPE for Windows If you use the Windows version of GLFPE, you will need a valid installed version of Windows. The current version works on Windows XP thru Windows 10. GLF has installed and tailored a set of compiler tools and IDE (Individual Development Environment) applications for Windows, currently tested on Windows 10. These tools are based on the Mingw32 port of GCC 6.3.0. GLF installed these tools on a Windows system, tweaked some settings, and repackaged all the necessary software into "Quick Install" zip files capable of copying the same software state to another computer. It is not necessary for an end user developer to rebuild the compiler toolset the same way GLF did, but a comprehensive step-bystep guide is provided to explain how if one desires to replicate the toolset, and perhaps customize it. If the "Quick Install" is unzipped to hard drive, the packages assume they reside on that drive, usually the C: drive. The portability launch scripts work for installations to any drive G: down to C: (searched in that order). The Windows software toolset has remained similar (as a dedicated C: drive installation) for GLF since at least 2007. It has been run and tested on Windows XP, 8, and 10 more or less in its current form. GLF uses the Orwell Dev-C++ IDE to compile programs on Windows, as well as a locally-compiled version of the V IDE, an obsolete but portable and lightweight IDE which GLF has found very useful to port from Windows to Linux or Rpi. GLFPE for Raspberry Pi The image files provided, when copied to SD card, will boot the Raspberry Pi directly, with everything already installed and working. These have worked on Rpi 1, 2, and 3 variants. A Raspberry Pi image is available based on Raspbian Buster. Each was enhanced with additional libraries and software capable of compiling almost all the programs in the GLF source collection. Many of the same utility applications which work under Debian (GLFPE Linux) also work on the Rpi, albeit slower. GLFPE for Linux live boot The images are hybrid ISO files which can be copied to DVD-R or USB to boot a PC compatible (either 32-bit 686 or 64-bit AMD/Intel CPU). Unfortunately for some modern computers, Debian does not yet support Secure Boot (under UEFI). UEFI booting WITHOUT Secure Boot IS SUPPORTED. It may be necessary to temporarily modify BIOS settings to be able to boot in Legacy Mode, or to turn off Secure Boot mode to boot GLFPE on some computers. Optionally, if you want to install an equivalent Linux system directly to a compatible computer, the Debian boot menu includes install options which have been shown to work. The live boot ISO files have also been found to install and run as VMs (Virtual Machines) under Oracle Virtualbox. This distribution was previously based on Debian 8 (jessie), or Debian 9 (stretch), but is now maintained using Debian 11 (bullseye). GLF uses the Debian-supported "live build" system to create these bootable DVD/USB images (ISO files). After creation of the ISO files, they may be burned to DVD or copied to USB (GLF now uses the application "multibootusb" built into GLFPE to make bootable USB drives). The C/C++ compiler under GLFPE is GCC (typical for Linux). GLFPE is now based on Debian 11 stable and includes GCC 10.2.1. GLF has also includes the V IDE, Code::Blocks, Geany, and as always, the raw command line to assist GCC programming. As of this writing, the current numerical release of Debian 11 based GLFPE is version 709 (Sep 5 2021). GLFPE for Raspberry Pi: Why Debian is used as a base for live boot GLFPE Linux ------------------------------------------------------- The Windows versions of the source code assume an installed compiler toolchain on a computer running Windows XP or newer. As such, the OS is not directly transferable to other users. GLF has developed a set of step-by-step instructions for installing such a build environment assuming an already installed Windows OS. GLF does not advocate one IDE over another to work in such an environment, but does provide the free and open tools actually used by GLF and known to work with the provided source code. GLF uses Orwell Dev-C++ and V IDE under Windows, and has experimented with Code::Blocks. The Linux ports allow a freer distribution of methodology, because in general, Linux is free and open software. It is easy to acquire working live boot ISO images of various Linux distributions over the internet, and use linux either with or without commitment to direct OS installation. However, the customization required to allow full compatibility with the GLFPE source code is both arcane and time consuming. Ideally, GLF would like to distribute a working live boot OS with all dependent libraries and recommended software tools preinstalled. GLF originally based Linux ports on Ubuntu, then Mint, but after having succeeded in producing customized redistributions for other users, GLF found out about the restrictions (by Ubuntu and Mint) which prohibited their widespread dissemination. Redistribution of actual customized working Linux distributions is legally a little sticky. Some of the most popular and supported distributions such as Ubuntu and Mint consider some of their content to be proprietary, and place restrictions on redistribution of working live boot images not specifically authored or authorized by them. After some research and experimentation, GLF found that Debian did NOT restrict redistribution in the same ways, and also included "Live Build", a set of tools and scripted processes which allowed rebuilding a custom Debian 8 (Jessie) installation from scratch IN THE SAME MANNER which all official Debian distribution ISO images are prepared. GLF therefore bases all current redistributions of GLFPE Linux on the Debian Live Build platform. It is both legal and practical. GLF chose the MATE flavor of Debian because the user interface (based on a fork of Gnome 2) is familiar, comfortable, and productive. Other software included ----------------------- The current GLFPE Linux (Debian 11) distributions continue to be supported, and include GCC version 10.2.1. Also included is a fully working installation of the Arduino IDE (currently version 1.8.13) with extensions for PJRC Teensy (Teensyduino) and the Mellis extensions for ATtiny 84 and 85, as well as ESP32 support. Provisions have been made in the GLFPE Linux to allow hosting and compiling source code on a USB flash drive. It is possible to fully develop working softtware for either a 32-bit or 64-bit Linux environment or for Arduino-compatible processors without ever performing a full OS installation or even requiring a working hard drive on the computer. No commitments, no risk to the host computer. The live boot OS environment invokes "Vegas Rules" -- whatever happens in "Vegas", stays in "Vegas". The GLFPE Linux redistributions are used everyday by GLF to develop software and to perform various everyday tasks such as web browsing, watching Netflix, etc. As such, the software included reflects the personal experience and tastes of GLF. Two distribution flavors for PC compatibles are provided -- AMD64 and 686. Both versions include a standard Debian installer which can install the working environment with all included libraries) to a compatible computer if desired. However, the live boot versions are fully usable without such installation. GLF has also included SD card images for Raspberry Pi (based on Raspbian) which include all successfully ported GLFPE libraries and source code. It is possible to develop many of the same programs for PC or Rpi with these images, and in addition, provisions are made for development of Rpi-specific hardware projects. GLF source code tree compatible with GLFPE ------------------------------------------- The GLF source code provided is compatible with the GLFPE. Many of the programs compile across multiple OS platforms. Many of the programs were originally developed in a MS-DOS or Windows environment, and were later ported to Linux. Requisite libraries are either internet standard open source libraries widely available in binary form or have been precompiled by GLF from available source code. Replication (or not) of GLFPE Linux distribution ------------------------------------------------- The Debian live build cores (.tar.gz files) include everything used by GLF to produce the numbered release version of GLFPE Linux. That includes all configuration specifications and certain customizations which may also include additional .deb files for software not available in the repositories. The core files are about 400 Mb in size. It is now possible to upgrade or extend a current runnable version of the GLFPE for Linux live boot image WITHOUT ACTUALLY INSTALLING IT. The process uses a working disk with about 30 Gb of space available, formatted as EXT4 (a Linux format -- this is important to the process). Using an actual USB 3 external hard drive dramatically speeds up the build process over using a USB 2 flash stick, but the latter also works (slowly) if it's big enough. On a (x86 or AMD64) computer compatible with a given CPU version of GLFPE, one may upgrade to another ISO file of the same CPU type. A step-by-step instruction for the process is provided elsewhere, but basically, you boot a GLFPE drive, insert the USB EXT4 work disk, perform a little "scripting magic", back up and edit a prior version of the configuration file set, then start the build process from a command line from within the top level of the configuration folder. Assumng good internet bandwidth, after as little as 1 hour (USB 3 hard drive -- about 4 hours if USB 2 flash), you should have a new ISO file with the latest versions of the Linux kernel, applications, and libraries. Replication (or not) of GLFPE Windows distribution --------------------------------------------------- The recent rebuilding of The GLFPE Windows suite alowed the author to verify procedures and edit and improve the documentation, so the author now also provides the build procedures, links, and source files on the above website. The author has chosen MinGW32 with GCC 8.3.0 as the version of compiler included. it is of course possible to build a similar toolset based on another compiler (MinGW-64 or even Clang), but the author has no experience to report with alternate compilers. In most cases, the libraries will still need to be compiled from source to go along with the chosen compiler. The chosen compiler retains compatibility (in a portable way) with any Windows from XP to Windows 10, and the author considers that an important value. The Windows version of GLFPE requires much manual intervention and inevitable R&D to handle compiler and library changes, so building the toolset from scratch is not a trivial exercise, and most users need not do it, since the Quick Install will provide a working environment in a few minutes. Good luck if you try. If you succeed you will understand the system in a DEEP way. NO WARRANTY -- free to try and possibly break ----------------------------------------------- This compilation is a work in progress. It is not guaranteed to be either feature-complete or fully (nor correctly) documented. The source code and resulting executables are not warranted to be suitable for any intended use. Use at your own risk. GLF will not pretend to provide technical support beyond whatever documentation may be published on his own web site, or which points to original sources for software and web-published manuals. This IS FREE, after all. You should be able to use the live boot versions without affecting any other installed OS on a computer or personal files. However, Linux CAN provide access to those files and OS partitions, which can be both useful and potentially dangerous. You should routinely be safe to use GLFPE Linux every day and never leave a trace on the underlying computer. On the other hand, if you try hard enough, you can break your Windows installation, or completely wipe your hard drive. Try not to do that. With great power comes great responsibility. There is pretty much nothing in computing you CAN'T do with GNU/Linux and a little technical knowledge (for good or ill). Life is a journey, get moving, and try to avoid beasts which might lurk in the woods. The live boot OS provided is based on current products (Derbian 9 Mate) released by the Debian project. As such, the author of GLFPE is not directly responsible for the way the OS works, since he didn't invent it. Rest assured if you have problems running any part of GLFPE or any other Linux, you are probably not alone. Gnu/Linux is mostly the result of volunteer effort by thousands of people. However, there is an excellent chance that if you have a problem, a smart Google search will turn up suggestions, and maybe solutions. May you find these interesting and useful. Getting to this point took MOST OF A GEEKY LIFE. :)