This Critic closed see Cycle 2

Critic of Build a CYGWIN environment in docker.

AddUser needs debugging, fails to work as expected

Build the base CYGWIN environment.

UI Automation

UI Automation is an automation tools for Windows UI. Can a powershell script build the base CYGWIN image?

• Can this be done in the docker windows image? likely no.
• Can cygwin install be automated? likely yes.

UIAutomation.dll how to get it?

Best Instructions

The UIAutomation.dll file is in a cryptic named file which need to be extracted. The best instructions for how are at https://community.spiceworks.com/how_to/160771-how-to-obtain-and-install-uiautomation-dll.

Construct a base cygwin docker environment

The basic method is to choose a windows base environment, next interactively install cygwin in a host directory, use https://www.cygwin.com/setup-x86_64.exe Install apt-cyg from https://github.com/ilatypov/apt-cyg/blob/master/apt-cyg in the docker image. Using docker create an image with the cygwin host directory copied to the guest docker image: use docker cp

Using this process an image was created

https://cloud.docker.com/u/tomrake/repository/docker/tomrake/cygwin

Next iteration

Need to add a normal user.

How to well meaning team got into a conflict

Git for Windows is based on it’s own code on the msys2/mingw-64 code base. The msys2/mingw-64 team uses a patched based contribution system to rebuild it’s system. The msys2/mingw-64 system is built as a series of packages, by a recipe which includes patching of the source code at build time.

Git for windows includes many of the same tool but builds them from a single git repository.

Report on source updating.

A gitlab rebuild is in response to a branch push.

Report on building prototype

An example prototype of a CLISP build system could be libsigsegv

• Prerequisite to CLISP
• Multi platform - release artifacts are
• Git hosted on savanah

How the build(s) are structured

• There is a build interface
• There are instances of Runner for each artifact target.
• Each runner has a tag - the tag is platform/artifact type.

Building CLISP dependencies.

Design a general build process.

• Specify requirements
• build a prototype
• report considerations
• is it suffiencent?
  • Yes - move to a release build
  • No - Report; modify requirement and iterate

Requirements

• artifacts in a docker volume

  • Where docker can find it.
  • Can gitlab find it too?

• source in a docker volume

  • source means current source
  • The source is updatable
  • The source is versionable
  • docker issues ??
  • gitlab issues ??

• build log is accessable

  [Read More]

Building CLISP on gitlab

Attempt to build CLISP on gitlab as a CI project.

Multiple platform support.

CLISP can be built on many platforms. Among them are

• Windows
  • MSC
  • mingw64 - a Unix
  • cygwin - a Unix
• MacOS - I don’t have this.
• Unix
  • Linux
  • FreeBDS

CLISP documentation

For Windows - install.WINDOWS

For UNIX - unix/INSTALL

For Porting general - unix/PLATFORMS

General Approach for docker build

• Create a base platform with all needed dependecies
• Do the configure and build
• Do the tests.
• Export the build artifacts

Each platform is defined by a key string

The build tools are a large case statement based on the key string, or perhaps there is a key.platform statement which tells the specific build conditions and methods.

Church, Turing and von Neuman

Alonzo Church solved the halting problem with the invention of lambda calculus. Alan Turing solved the equivanent problem by the invention of the Turning machine. John Von Neuman proposed an electronic computer based on the Universal Turing Machine to do physics calculation for nuclear fusion evaluation, his model is the basis for our modern computer systems.

FORTRAN and LISP

The first high level compiled language was FORTRAN. First proposed in 1953 the first compiler was delivered in 1957. In 1958 John McCarthy proposed a language LISP which concerned ideas of Church’s lambda calculus. The first compiler was implmented in 1959, during 1962 the first ocmpiler of LISP written completely in LISP was delivered. This was an incremental compiler which piece by piece compiled itself. This began the tradition of the interactive REPL that is part of today’s LISP system, as a consequence the concept of the IMAGE of a LISP system was also developed.

How we got Common LISP Standard

Calculations for atomic weapons and space based delivery systems for the same are the step father the computer industry. LISP is the second oldest high level programming language, FORTRAN was the first. Both conceieved in the 1950s. Artificial Intelligence, a term coined by LISP’s father John McCarthy, to pigeon hole the space he was interested in exploring.

LISP was developed in several dialects thought the ’80s, a stanard committee was created to create a common dialect which we call Common LISP.

beautiful-jekyll is a fork of Jekyll-Now

Jekyll-Now was good effort by Barry Clarke and https://deanattali.com/beautiful-jekyll/ is an improved fork of Jekyll Now that does not have the Double Scroll box problems. I would recommend starting any new github jekyll blog with Beautiful-Jekyll.