Last week the laptop I use for macOS development said that there is an XCode update available. I tried to install it but it said that there is not enough free space available to run the installer. So I deleted a bunch of files and tried again. Still the same complaint. Then I deleted some unused VM images. Those would free a few dozen gigabytes, so it should make things work. I even emptied the trash can to make sure nothing lingered around. But even this did not help, I still got the same complaint.

At this point it was time to get serious and launch the terminal. And, true enough, according to df the disk had only 8 gigabytes of free space even though I had just deleted over 40 gigabytes of files from it (using rm, not the GUI, so things really should have been gone). A lot of googling and poking later I discovered that all the deleted files had gone to "reserved space" on the file system. There was no way to access those files or delete them. According to documentation the operating system would delete those files "on demand as more space is needed". This was not very comforting because the system most definitely was not doing that and you'd think that Apple's own software would get this right.

After a ton more googling I managed to find a chat buried somewhere deep in Reddit which listed the magical indentation that purges reserved space. It consisted of running tmutil from the command line and giving it a bunch of command line arguments that did not seem to make sense or have any correlation to the thing that I wanted to do. But it did work and eventually I got XCode updated.

After my blood pressure dropped to healthier levels I got the strangest feeling of déjà vu. This felt exactly like using Linux in the early 2000s. Things break at random for reasons you can't understand and the only way to fix it is to find terminal commands from discussion forums, type them in and hope for the best. Then it hit me.

If you are an avid Linux user who hops distros every weekend, it can be confusing at times to pick a distro to install. Well, not anymore. There exists a website named DistroTest that lets you test Linux operating systems from your web browser without requiring any sort of installation so that you can get a better idea regarding what to expect from the operating system without even downloading it.

The website offers 807 versions of Linux distros across 244 operating systems and hence, it is more likely that the distro you’re planning to check out will have its version on DistroTest. Cool, right?

The best part is, it won’t ask any of your personal information and will not require you to create an account on the website. This way, you don’t have to worry about any privacy-related risk.

• GNU Binutils 2.33.1 Released With Support For Newer Arm Cortex CPUs, SVE2/TME/MVE

  The GNU Binutils 2.33(.1) release brings BFloat16 support (BF16), many ARMv8 architecture updates, eBPF support for the GNU toolchain to complement the GCC 10 compiler support for this alternative now to using LLVM, support for the new CTF (Compact Type Format) debug format, and other work accumulated in recent months.

• GNU Binutils 2.33.1 has been released.

  Hello Everyone,
  
    We are pleased to announce that version 2.33.1 of the GNU Binutils project
    sources have been released and are now available for download at:
  
      https://ftp.gnu.org/gnu/binutils
      https://sourceware.org/pub/binutils/releases/
  
    The md5sum values are:
      
      56a3be5f8f8ee874417a4f19ef3f10c8  binutils-2.33.1.tar.bz2
      1a6b16bcc926e312633fcc3fae14ba0a  binutils-2.33.1.tar.gz
      f4e7e023664f087b3017fc42955ebb46  binutils-2.33.1.tar.lz
      9406231b7d9dd93731c2d06cefe8aaf1  binutils-2.33.1.tar.xz
  
  
    This release contains numerous bug fixes, and also the following new
    features:
  
      Assembler:
      
      * Adds support for the Arm Scalable Vector Extension version 2
        (SVE2) instructions, the Arm Transactional Memory Extension (TME)
        instructions and the Armv8.1-M Mainline and M-profile Vector
        Extension (MVE) instructions.
  
      * Adds support for the Arm Cortex-A76AE, Cortex-A77 and Cortex-M35P
        processors and the AArch64 Cortex-A34, Cortex-A65, Cortex-A65AE,
        Cortex-A76AE, and Cortex-A77 processors.
  
      * Adds a .float16 directive for both Arm and AArch64 to allow
        encoding of 16-bit floating point literals.
  
      * For MIPS, Add -m[no-]fix-loongson3-llsc option to fix (or not)
        Loongson3 LLSC Errata.  Add a --enable-mips-fix-loongson3-llsc=[yes|no]
        configure time option to set the default behavior. Set the default
        if the configure option is not used to "no".
  
      Linker:
  
      * The Cortex-A53 Erratum 843419 workaround now supports a choice of
        which workaround to use.  The option --fix-cortex-a53-843419 now
        takes an optional argument --fix-cortex-a53-843419[=full|adr|adrp]
        which can be used to force a particular workaround to be used.
        See --help for AArch64 for more details.
  
      * Add support for GNU_PROPERTY_AARCH64_FEATURE_1_BTI and
        GNU_PROPERTY_AARCH64_FEATURE_1_PAC  in ELF GNU program properties
        in the AArch64 ELF linker. 
  
      * Add -z force-bti for AArch64 to enable GNU_PROPERTY_AARCH64_FEATURE_1_BTI
        on output while warning about missing GNU_PROPERTY_AARCH64_FEATURE_1_BTI 
        on inputs and use PLTs protected with BTI.
  
      * Add -z pac-plt for AArch64 to pick PAC enabled PLTs.
  
      Utilities:
  
      * Add --source-comment[=] option to objdump which if present,
        provides a prefix to source code lines displayed in a disassembly.
  
      * Add --set-section-alignment =
        option to objcopy to allow the changing of section alignments.
  
      * Add --verilog-data-width option to objcopy for verilog targets to
        control width of data elements in verilog hex format.
  
      * The separate debug info file options of readelf (--debug-dump=links
        and --debug-dump=follow) and objdump (--dwarf=links and
        --dwarf=follow-links) will now display and/or follow multiple
        links if more than one are present in a file.  (This usually
        happens when gcc's -gsplit-dwarf option is used).
  
        In addition objdump's --dwarf=follow-links now also affects its
        other display options, so that for example, when combined with
        --syms it will cause the symbol tables in any linked debug info
        files to also be displayed.  In addition when combined with
        --disassemble the --dwarf= follow-links option will ensure that
        any symbol tables in the linked files are read and used when
        disassembling code in the main file.
  
      * Add support for dumping types encoded in the Compact Type Format
        to objdump and readelf.    
  
    Our thanks go out to all of the binutils contributors, past and
    present, for helping to make this release possible.
  
    Note in case you are wondering about what happened to the 2.33
    release, it is stuck pending the resolution of an issue with the keys
    used to sign the release.  Once this is resolved the 2.33 tarballs
    will be uploaded, even though they will now be slightly out of date.
  
  Cheers
    Nick Clifton
    Binutils Chief Maintainer.
  

• 1er GNUFEST 2019

  On October 26 I was present at the event 1 GNUFEST 2019 in the city of San Cristóbal, in this event I was representing Fedora giving the talk “What do people live in Free Software?“, Is the second time I give this talk the which was created at FudConf Panamá 2011, I like to give this talk since I usually give technical talks, in this I explain how someone can live from Free Software and that there is an entire economic ecosystem behind free software that allows it to be self-sustaining.

Docker is basically a virtualized open-source environment that allows users to distribute and install multiple apps on the server but without interfering each other’s installation and process. Docker benefits most from cluster environments and data centres. It provides an isolated environment for the container. Now, what are Docker containers?

You can compare the Docker Container with multiple containers available on a single shipyard with different articles. In the same way, Docker has implemented a technology called containers, which you can say a term used alternatively instead of virtual machines. However, containers take less space as compared to regular VMs.

The operating system images created by different developers to be used on containers are a package of a single application and all dependencies such as libraries, utilities, and static data into one image file, but without a complete operating system. That’s why containers can be compared to lightweight virtualization. All containers installed on any Docker can run simultaneously using the host OS kernel but with isolated processes. This gives them better performance while using low resource. The images running on it are only of few MBs. However, unlike VirtualBox or Hyper-V, natively the containers and Docker is available to manage using a command-line interface whether you want to download some OS image or managing of different apps, you need to type commands. It could be cumbersome for noobs or professionals those have to manage multiple containers on personal desktop or data centres or server clusters.

Thus, to mitigate all such incommodious the Docker provides an API that can be used to manage it using GUI (graphical user interface) based desktop applications and web-based management tools.