google`AppEngine file system intro

2.20: news.adda/co/google`AppEngine file system intro:
G'AppEngine`concepts:
. projects store objects in buckets
which are like folders but non-nestable;
and have names that are unique across
not just the project but all of g'storage .
. immutability applies only to objects
not filenames, [symbolic vs hard links].
Object names can contain
any combination less than 1024 bytes,
of Unicode characters (UTF-8 encoded)
including "/"
so that you can use old pathnames
while google sees the entire path as one filename,
as the only hierarchy is
(g'storage, some-bucket, some-pathname).
For most operations you can use either of
the following URLs to access an object:
storage.googleapis.com/≺bucket>/≺object>
≺bucket>.storage.googleapis.com/≺object>
www.googleapis.com/storage/v1beta2/b/≺bucket>/o/≺object>?alt=media (JSON API)

microsoft's changes for an insecure internet

5.18:  news.cyb/dev.net/silverlight killed by html5:
subodhnpushpak 2011:

Microsoft Silverlight is an application framework
for writing and running rich Internet applications,
with features and purposes similar to those of Adobe Flash.
. it's being replaced by html5 .

. the cool thing about it was
programming the browser with ironpython
-- or any other .net language --
instead of javascript .

6.10: why:

. the .NET system was designed for competing with java;
the cool idea at that time was mobile code;
but since internet security issues have gotten so thick,
the cool idea now is either minimizing code installs
by using web services with an html interface,
or controlling app quality
with something like Apple's App Store .

. now that html5 offers a multi-media experience,
the .NET and SilverLight plug-in's
are being discouraged as unnecessary installs .
. some apps may seem slow in a browser,
and those will need native code
that should be policed by an App Store .

. to replace .NET's multi-lang feature,
here's how your favorite languages
can be turned into javascript:
# for Python code:
. use Pyjamas, a port of Google Web Toolkit.
# for C, C++, Objective-C:
. use the Emscripten LLVM-to-JavaScript compiler
(eg, if your translator emits Objective-C,
then it can be converted to LLVM byte code,
which can finally be converted to JavaScript ).

. given the move away from mobile code,
Microsoft has evolved from .NET
and its new language C#,
back to a popular language, C++
with Component Extensions, C++/CX .
. its syntax borrows from C++/CLI
but targets native instead of managed code.
. Apple went through such a phase also
when it dropped their new lang, Dylan,
for the popular lang, C,
with oop extensions, Objective-C .
. the .NET developer framework was part of
WPF (Win' Presentation Foundation),
and Silverlight was a .NET-powered flash competitor;
the new platform using c++/CX
is called WinRT (Win' Run Time).

the state of scripting concurrency

4.19: adda/co/the state of scripting concurrency/intro:
[5.30:
. this excerpt from stackoverflow.com
had me looking at concurrency again:]

"( If you have programmed expertly in
Perl Python and in Java for 10 years,
then you'll probably write your program in Perl
because you'll complete the program faster,
the program will have fewer lines of code,
and the language will stay more out of your way.
If you are not an expert in Perl, Python, or Java,
and you have to choose one of those languages,
then I recommend that you choose Python.
... except if threading is important (re: GIL)...)

green threads and the need for GIL:
[5.30:
. processes are full programs running concurrently:
each process has its own space for
both variables and code;
threads are like processes except that
they share the locals and code
of the process that spawned them .
. threads and processes can be either
native -- implemented by the os,
or green -- impl'd by an app (eg, a scripting interpreter).
Erlang provides a green process(vs thread),
which is much more lightweight than a native process
because it does share (read-only) code space .

. a computer with multiple cores
can be truly concurrent:
doing more than one thing at the same time
by contrast, timeslicing is virtual concurrency:
giving each task a slice of computer time .
. the GIL (Global Interpreter Lock)
is a mutual exclusion lock
that prevents true concurrency:
insuring that app threads are timesliced,
rathering than being mapped to multiple cores .
. it's needed when the the interpreter,
it's libraries, or its plugins
are not thread-safe because of
threads being able to share variables
that aren't protected with atomic access:
ie, being able to complete a read or write
before having being interrupted by the timeslicer .

Ruby's support for concurrency:

. IronRuby builds on top of .NET Threads,
so they map 1-1 to OS-threads as well;
JRuby does likewise on the JVM .

[5.30:
. these GIL-free variants of Ruby

provide threads without any warranty:
it's up to you to insure that
all your dependencies are thread safe .

. concurrency models supported by Ruby

include Threads, Processes and
Fibers (systems-level coroutines).
. other abstractions to consider include
Coroutines, Actor Models, Petri Nets, Process Algebras
(particularly CSP and the Pi-Calculus),
Software Transactional Memory
and distributed Map/Reduce algorithms
-- see Go, Occam-Pi, Clojure and Erlang;
Ruby could impl' these with current libraries;
eg, EventMachine or RevActor .

. Ruby needs a standard actor/executor API

-- not platform-specific impl's of actors .

. the future of high performance concurrency

is libdispatch/GCD;
for the java/scala folks, there's HawtDispatch:
(JRuby's port of that is at github/jcd).
. HawtDispatch is a thread pooling and
NIO event notification framework API
modeled after the Apple`libdispatch API
that powers Apple's Grand Central Dispatch (GCD).
It allows you to easily develop
multi-threaded applications
without the usual problems .

]-5.30
python's gil:
Juergen Brendel argues against the GIL;
Guido maintained the GIL is here to stay

until someone can prove its removal
doesn't slow down single-threaded Python code.
. the language doesn't require the GIL
but, the CPython virtual machine
that has historically been unable to shed it.
it was shown that even on the platform
with the fastest locking primitive (Windows at the time)
it slowed down single-threaded execution
nearly two-fold .
. removing the GIL complicates life for
extension module writers
by precluding the use of global mutable data .
There might also be changes in the Python/C API
necessitated by the need to lock certain objects
for the duration of a sequence of calls.

Bob Warfield 2007`analysis of gil:

Guido is Right to Leave the GIL in Python,
Not for Multicore but for Utility Computing
considering large scalability issues
in the world of SaaS, Web 2.0,
and utility computing fabrics;
eg, Amazon EC2(elastic computing).
. a concurrency capability based on threads
has done nothing to access multiple machines
-- for that you need socket-connected processes .
. furthermore,
a simple, safe and reliable concurrency language
should be focused on a [green]process model,
not a thread model.

[5.29:
. concurrent programming has a bad reputation
for being both buggy and undebuggable,
but it's based on work with threads .
5.30:
. to be efficient and safe,
a language needs to pervasively support
green processes:
a unit of concurrency that does share
read-only mem like a thread does
but does not share variable mem .
. pervasive support means that
not only is the standard library thread safe,
but all reusable modules are also .]

another way threads don't scale:

The fundamental problem with threads
is that sharing requires locking
which doesn’t scale (or compose),
and is prone to races and deadlocks .
Erlang features [green]processes
where isolation is enforced by the language
rather than the operating system .

. Erlang is a functional language
with strict copy semantics
and with no pointers or references.

[. it is merely the semantics
that are pass-by-copy;
the impl'details involve
read-only pass-by-reference .]

Why don’t we all switch to Erlang?

Messages have to be copied.
You can’t deep-copy a large data structure
without some performance degradation,
and not all copying can be optimized away
(it requires behind-the-scenes alias analysis).
so, mainstream languages don’t abandon sharing;
instead, they rely on programmer’s discipline
or try to control aliasing.

the MathLink ABI

2019.10.9: summary:
. how I was introduced to the term
ABI (application binary interface)
in which programs and processes
communicate with each other;
I give it the meaning within addx
of a communication that involves
etrees (expression trees) rather than ascii text.

mvc with client-server architecture

6.20: addx/mvc with client-server architecture:

. strict mvc means model lets
controller do the image writing to screen .
. if part of the model includes
generating images,
then these can be composited
by the controller
to wherever the chosen view is .

. the x server allows remote servers
to be treated similar to local servers .
. the addx server model is not
concerned with such networking;
the main point is mvc modularity:
. the servers providing an mvc`model
need to be working for mvc`controllers
not for the human users directly .
. the model can then be used either by
human views or robotic views;
most typically, the point is to provide
more choice for the human
by letting a robot filter what the
model is intending for the human,
similar to the way bodyguards work .
[6.26:
. this isn't meant to escape from
contracts like google's
where the ad's must be human-visible
and the inquiries human-initiated;
it simply means that all models
are capable of robot accessability .
. one way this can help while
fulfilling the google contract
is to have the robot help with
making wise keyword choices:
it presents a list of suggestions
and the human can merely press enter .
. robots can also be reading along
to help humans spot the best leads .
]
. in addition to that mvc architecture,
the model may want to divide itself
into server and client parts
in order to efficiently modify the model
from afar .
[my intuitive assumption:]
. the x window system works on the idea that
it would be most efficient if
the os could provide a generic client part
that many servers could use,
since servers often need to make similar moves .

api:
. don't I need to have a
carefully selected set of api's
in order to know how to do the
x thing (where the model has
separate server and client parts) ?
. one could take it
one example at a time:
cloud computing depends heavily on x:
. some things like controlling the cursor
can't be done quickly eno' by remote .
. if the model does some
major modifications
the data needs to be with the server;
that's where it originates from,
so no problem .
. letting the user quickly scan
large portions of data
means that the data should be
mirrored there too
unless the platform is tiny .

review of higher view:
. mvc works naturally with x,
since the Server = Model
and the Controller along with its
choice of View = Client .
. the View consists of
the Controllers way of arranging
the data in a form that is
optimal for viewing .
. remote does complicate things a bit:
the non-remote controller has
instant access to the model,
but now with the model so far away,
the controller is having to think about
how much to ask for in advance
depending on the size of the local system .


6.26: addx/x protocol/server client terminology:

The term server and client have different meanings.
XServer runs on your graphically rich desktop
(it serves up the view)
X11-client (like app is client of OS)
may run anywhere on the connected network

lwn.net:

The program which provides access to
system resources (display, keyboard, mouse)
is the server.
The shorter-lived applications
which connect to the server
to make use of these shared resources
are the clients.
This is perfectly consistent with
every other use of "(client/server) .
What throws people is that
we're used to thinking of servers as
a particular type of *hardware*,
steadily ticking away the CPU-hours
in some climate-controlled back room,
out of sight, whereas "clients"
are the visible workstation PCs
at everyone's desk.
However, the X client/server terminology
is perfectly reasonable
from a *software* point-of-view,
and X is software, not hardware.

cloud computing

11.21: news.addx/security/cloud computing:

http://www.technologyreview.com/computing/23951/

. If a full cryptographic solution is far-off,

what would a near-term solution look like?

WD: A practical solution will have several properties.

It will require an overall improvement in computer security.

Much of this would result from

care on the part of cloud computing providers

--choosing more secure operating systems such as Open BSD and Solaris--

and keeping those systems carefully configured.

A security-conscious computing services provider

would provision each user with

its own processors, caches, and memory at any given moment

and would clean house between users,

reloading the operating system and zeroing all memory.

A serious potential danger will be any laws intended to

guarantee the ability of law enforcement

to monitor computations that they suspect of supporting criminal activity.

Back doors of this sort complicate security arrangements

with two devastating consequences.

Complexity is the enemy of security.

Once Trojan horses are constructed,

one can never be sure by whom they will be used.

1439:

. afraid of gmail? the dod's internet eavesdropping machine

will pick it up anyway;

even crypts will be cracked in a couple years,

and when they are,

they give some insight into who we are,

which in turn may signal

who needs closer survailence via other means .