K-user mailing list

[Martin Vahi <martin.vahi AT softf1.com>]

As of 2018_01 I'm totally new to the
K-framework. I have heard of the K-framework
years before and I have watched the
introductory videos and I searched the
archive of this mailing list for words
"translate", "translation", but I did not
find any entries about translation.

Firstly, please correct me (or point to
further study material), if I'm wrong, but
the way I understand the K-framework right
now(2018_01) is that after custom languages

    FooLang_1
    and
    FooLang_2

have been described according to the
K-framework specific, partly visual,
"programming language" (syntax in EBNF +
a set of various structured variable types +
how instances of those variables will be processed,
id est "semantics"; hereafter: KLang_1), then one of the
K-framework interpreters, the KLang_1 interpreter,
uses various rewrite rules to translate the
programs written in FooLang_1 and FooLang_2
to a code that another K-framework interpreter,
which I call KLang_2 interpreter, is able to
execute/compile. Programs written in
FooLang_1 and FooLang_2 are

    normalized

to KLang_2 programs. According to that view, which
I might have wrong, a translation from
FooLang_1 to FooLang_2 would look like:

    a_program_in_KLang_2 = FooLang_1_to_KLang_2(a_program_in_FooLang_1)

    a_program_in_FooLang_2 = KLang_2_to_FooLang_2(a_program_in_KLang_2)

The way I currently, may be mistakenly, understand, the

    <new programming language>_to_KLang_2(...)

has been already implemented, but are there
plans to implement at least some sort of,
may be inefficient, fully automatic form of the

    KLang_2_to_<new programming language>(...)

??

Thank You.

The background of my the question is that the
hardware industry tends to take security issues
either according to "law", which is the 1984, where
back doors are mandated by the local
supermafia("government"), be it Washington or China
or Putin's Russia, ..., or just dismisses the
issues, because the end users, the consumers that
actually pay for everything, do not care about
security, because they just want things quickly
and cheaply and if any supermafia("government")
can ask any bank to list all bank records,
again, according to "law", then the corporate world
could not care less about the security issues.

The only people, who need secure, privacy preserving,
desktop computers, are grassroots activists,
the so called "civil society",
and librarians and museum operators, who
want to make sure that the future
"book burning"(censorship based HDD erasing) events
will not destroy the artifacts at their collection.
That set of people is such a small part of the
planet Earth population that there is no market demand for
the development of properly secure desktop grade
computers. I once mistakenly thought that
the medical industry might care, but
as it turns out, well:

    ----citation--start----
    Software failures in robot assisted surgeries
    are associated with a lawsuit detailing
    a situation where a surgical robot froze
    and the surgery had to be completed by other means.
    ----citation--end------

https://www.asee.org/documents/sections/middle-atlantic/fall-2013/27-Paczuski-Surgical-Robotics-paper.pdf


    (An article/paper, where they experiment
    with autonomous cutting with a surgical robot.)
    https://arxiv.org/pdf/1712.02917.pdf

The idea that medical robot builders
can get by with the same kind of methods
that avionics developers do, have some nice,
small, specialized set of hardware that runs
some nice control software with a relatively
simplistic API, is an unrealistic fantasy, because
a surgeon need to tell the robot, what
kind of an autonomous activity it want the
robot to do and the surgeon certainly needs
a pretty complex, "desktop like", GUI that
probably shows camera images that the surgeon
uses for making his/her decisions. Just,
hack into the surgery robot, show the doctor
some false "security camera" images like in
"Mission Impossible" and other Hollywood action movies
and the doctor "pushes the wrong buttons" even,
if the display system is separate from the
rest of the control system.

As we all know, the initiators of hacks
are almost impossible to prove and
if it's the dissidents that
tend to have more "accidents" than
the rest of the population, then
it's statistically almost impossible to prove that
there is some supermafia("government") "adjustment"
involved. There's even a 1978 movie named "Coma" about
a similar scheme:

    http://www.imdb.com/title/tt0077355/

    https://www.youtube.com/watch?v=klN4SXhtk94

Except that in that movie the victims
were not political dissidents but the victims
were chosen according to the needs of
a supermafia("government") medical research program.

My impression is that a creation of a computer
that has a minimal set of hardware flaws,
has to be a grassroots effort, because there
is no market for that kind of a niche product.
Making custom chips won't help either, because
the semiconductor foundry can be hacked or
the computers of a small, grassroots operated,
semiconductor mini-foundry/workshop can be
hacked. The security wise best option
that I'm currently(2018_01) aware of is
either an FPGA/CPLD computer that has partly
"patchable" hardware or a computer that
uses a huge array of very cheap transputers

    https://en.wikipedia.org/wiki/Transputer

The transputers lack back doors mainly because the
microcontrollers are so cheap that any
special logic block would be prohibited
by the price of the chip or because
none of the spy agencies care to take
on the endeavor of back-dooring the
relatively huge set of different microcontrollers
from different manufacturers. Part of the
assessment is that it is not possible
to audit any logic chip simply by looking
at the number of transistors and their
shapes, because one class of hardware
back-doors is based on not by changing
the number or shapes of the existing
components in the chip, but by changing
the electrical properties of "legal" components.

    ("Stealthy Dopant-Level Hardware Trojans")
    http://vcsg.ecs.umass.edu/publications/BeckerChes13.pdf

That problem would exist even, if the
grassroots activists were operating their own,
fully automated, semiconductor mini-foundry
and putting foundry computers offline won't
prevent the hacks, where the electric schematics
is changed by malware/hacks at the chip developers'
computers. So, even if the grassroots activists
could make their own chips, those chips would
have to be some FPGAs/CPLDs to increase the
probability that the completed hardware/computers
can be patched later.

All of that long story leads me to the
idea that an ideal computer MIGHT be an
array of FPGA/CPLD or extra-cheap microcontroller based
transputers that are connected to each other by
using the Benes network topology

    (The Benes network idea originates
    from the OpenTransputer project by
    David Keller and Andres Amaya Garcia.
    The link is to my copies of their work.)

https://www.softf1.com/cgi-bin/tree1/technology/flaws/mmmv_parasail_projects.bash/raw/2015_06_xx_OpenTransputer_Dissertation_by_David_Keller_and_Andres_Amaya_Garcia.pdf?name=dfb7c1c2ac94897bcfe0d53ed95f66f7ce61d57c


https://www.softf1.com/cgi-bin/tree1/technology/flaws/mmmv_parasail_projects.bash/wiki?name=Reference:+OpenTransputer

The "operating system" of that computer
would be the AntiKernel by
the Andrew Zonenberg and the Bülent Yener

    (Introduction.)
    https://www.youtube.com/watch?v=hxvzmZcNXl4

    (Link to my copy of the other people's work.)

https://www.softf1.com/cgi-bin/tree1/technology/flaws/mmmv_parasail_projects.bash/wiki?name=Reference:+Antikernel+Hardware+Operating+System

which would use some AUTOPARALLELIZING
programming language as its main
system programming language, in my case,
ParaSail by Tucker Taft:

    (Introduction by the Tucker Taft)
    https://youtu.be/bNWTRdAlwUs?t=1m11s

    (My repackaged version of the ParaSail,
    where I used Tucker Taft's advice for
    removing the graphics library dependencies
    and therefore made the software more suitable
    for executing on servers and the Raspberry Pi 3)
    https://technology.softf1.com/software_by_third_parties/ParaSail/

The Linux layer would be an "add-on", just like
the Microsoft has customized the official
Ubuntu userspace for its "Linux Subsystem for Windows".

    https://docs.microsoft.com/en-us/windows/wsl/install-win10

The FPGA-tools would/might be from the Procject IceStorm:

    http://www.clifford.at/icestorm/

For getting the speed out of the array of
relatively slow transputers, there's a need for
translating C to some sub-set of ParaSail or some
other auto-parallelizing programming language.
As the K-Framework project members have done the
difficult job of formally describing the C language,
the K-Framework seems to be the tool for the job.
To add an epic ending to my very first letter
to this mailing list:

    Humanity's destiny depends on computers that
    need an auto-parallelizing programming language
    that can run legacy software only, if the
    legacy hardware is simulated, which is
    impossible to do "legally"

        https://archive.is/2zzMW
        original link:

https://www.forbes.com/sites/tiriasresearch/2017/06/16/intel-threatens-microsoft-and-qualcomm-over-x86-emulation/#ef6592b54f43

   or if the compilers/interpreters of the
   legacy software are ported to the new
   computers and the porting of those
   compilers(GCC + LLVM + Ada GNAT)
   requires a C translator, because
   the old fashioned, single-threaded,
   software has to be auto-parallized to get
   any practical performance out of the
   array of computationally low power transputers.

I do not expect that computer building project
to be ready before 2018+10=2028, but one has to
start from somewhere and one also has to be
able to dump a project, when it turns out that
the original project was not optimal.


Thank You for reading my letter :-)