Interesting to see where Bellcore alumni landed - Scott Stornetta wrote his distributed ledger paper there in 1992

Not sure where to put this - it’s really information theory, I guess. Worrisome to consider your phone company laying the groundwork for the open air prison video game. Stornetta and Haber were at Bellcore when they wrote the original blockchain timestamp document. I came across this list of alumni. The column of where they are now (or last known employer) is an eye opener.



Amidst interrogating the cybernetic behemoth – and its seemingly infinite tentacles – the telecommunications/information theory pipeline is truly staggering . . . This Frankenmonster has grown to epic proportions, and I can only guess that most of the “seeders” (progenitors) on this list are just regular people having very little clue about what they have been involved in (?).

Following is an article featuring an alum who did not make it on the attached list:

Bell Labs, renamed from the original Volta Laboratory founded by Alexander Graham Bell, has been credited with many amazing advancements in the fields of computer science and telecommunication like the invention of the C Programming language and the operating system Unix. It has a great and complicated history as a subsidiary of the American Telephone and Telegraph Company. When an anti-trust supreme court case broke up AT&T in 1982, Bell Labs was retained by AT&T while the local operations of AT&T were split up into the Regional Bell Operating Companies.

This separation meant that a whole sector of what was previously the AT&T company had no central organization for research and development – it was cut off from Bell Labs. The Regional Bell Operating Companies needed a place to centralize software, research, training, and settings. That’s why Bell Communications Research, Inc or Bellcore was created.

Bellcore was never a part of the official “Bell Labs” but it certainly is connected in that the administrative work that was previously being done in the historical Bell Labs now was being done in Bellcore. In fact, much of the staff and corporate culture of Bellcore was carried over from Bell Labs. Bellcore is better known as Telcordia- the later name given to this operation. The practical running and work culture of Bellcore has historically been and to some extent still is a mystery.

With respect to the mysterious work culture and operations of Bellcore/Bell Labs . . . I am currently watching the Apple TV series, Severance. Even though it is presented as a sci-fi thriller, considering that it was filmed at Bell Labs – and the fictional company is called Lumon Industries (reminiscent of Lucent Technologies?) – I can’t help but recognize that there may be some significant “tells” and “reveals” embedded in the plot line/imagery. I will plan to report back in this regard, as I progress through the series . . .

@AMcD As you pointed out to me last night, Nokia began in 1865 as a paper mill company:

From its humble beginning in 1865 as a single paper mill operation, Nokia has found and nurtured success over the years in a range of industrial sectors including cable, paper products, rubber boots, tires, televisions and mobile phones.

Also absent from the alumni compilation is J. Turner Whitted . . .

Turner Whitted joined NVIDIA in 2014 after 15 years at Microsoft Research where he founded the hardware devices group and managed the graphics group along with a variety of other groups devoted to HCI. He was a co-inventor of the signal processing algorithm for ClearTypeTM. He co-founded Numerical Design Limited in 1983 and served as president and technical director until 1996. Earlier, as a member of the technical staff at Bell Laboratories, he introduced recursive ray tracing as an implementation of global illumination. In his early career he designed digital test equipment, antenna measurement systems, and components of a sonar signal processor.

This is SUPER IMPORTANT in relation to the cybernetic mixed reality game infrastructure – for anyone reading this who may be compelled to learn more (and teach us) about the nitty gritty technical details:

Ray tracing links us directly back to Voronoi patterning:

This chapter describes acceleration of ray tracing via Voronoi diagrams. Ray tracing, despite its unique simulation potentialities, is generally known as a time-consuming method of image synthesis. Although the method itself is classical, much research effort is still directed toward improving its effectiveness. A survey of ray tracing acceleration techniques has been given. Following their terminology, the method presented in the chapter is a space subdivision technique. Their common characteristic is the reduction of ray-object tests by subdividing the object scene. The operation is in two parts. First, a preprocessing phase decomposes the scene into disjoint territories called cells. A list associated with each cell contains references to those objects that have nonempty intersections with it. The chapter discusses Voronoi diagrams. These diagrams are among the most frequently studied structures in discrete and computational geometry. They are not only elegant but also very powerful, having an almost inexhaustible treasury of applications. In this chapter, Voronoi diagrams are applied to methods of ray tracing. A d -dimensional diagram solver (coded in C++) is also provided.

A New Ray-Tracying Acceleration Algorithm Based on Voronoi Diagram

  • Authors:

  • Zheng-Wu Yuan

  • Dan-Dan Wang

Authors Info & Claims

CSSS '12: Proceedings of the 2012 International Conference on Computer Science and Service SystemAugust 2012 Pages 292–295

Online:11 August 2012Publication History

I am leaving the aforementioned links as placeholders for now, and I will attempt to elaborate more here, or begin a new thread . . .

1 Like
1 Like

From ray tracing (see response above), we get ray marching . . .

Ray tracing

We all know about ray tracing, where you shoot out a ray for each pixel and use fancy math to recursively bounce it around and color the pixel. If you repeat this process for every pixel, you can get a lovely rendering of your scene that, if made by a talented artist, can look almost indistinguishable from real life.

Ray trace diagram.svg

Unfortunately, ray tracing has some downsides, namely that it can be insanely slow. A single frame can take hours to render, which may be fine for animated movies since their creator most likely has very powerful computers dedicated to rendering, however it’s quite a nuisance for hobbyists since they usually don’t have gigantic renderfarms all to themselves.

However, there is another.

Ray marching

Enter ray marching: the unappreciated cousin of ray tracing.
Ray marching is quite similar to ray tracing, however it has some interesting quirks that make it an interesting option for real-time graphics demos and games.
First, I should note that ray marching is not a replacement for rasterization nor ray tracing, it’s just a cool alternative.
Alright! Let’s get started.

How it works

Ray marching is, as I said previously, quite similar to ray tracing. The difference is that ray marching “marches” rays along their vectors and then uses distance equations to decide how far to march the ray, or if it has intersected with an object. We can then return stuff from the marching function like the position it intersected at, how many times it marched, or how far it marched.

How to implement it

Now that you know roughly how it works, let’s actually make a ray marcher. We’ll use GLSL, so you’ll need to set up OpenGL or use something like Shadertoy. If you don’t feel like following along, here’s the code on Shadertoy

First of all, we need some stuff at the top of the shader:

#version 420
// you can change #version if you want to
// the resolution, set to the window's dimensions.
uniform vec2 resolution;
// uncomment if you are going to implement a movement system
//uniform vec3 camPos;

Let’s start with the simplest part, a distance estimator. Specifically, a sphere’s DE:

float sphereDE(vec3 pos, vec3 spherePos, float size) {
    return length(pos - spherePos) - size;

This one is super simple and pretty self explanatory so I won’t really explain it, however keep in mind that other DEs are more complex than this. If you don’t feel like spheres are for you than here’s a big list of other shapes.

Now we can write the marching function which does the actual marching!

vec3 march(vec3 origin, vec3 direction) {
    float rayDist = 0.0;
    const int NUM_STEPS = 32; // doesn't matter much right now
    const float MIN_DIST = 0.001; // threshold for intersection
    const float MAX_DIST = 1000.0; // oops we went into space

    for(int i = 0; i < NUM_STEPS; i++) {
        vec3 current_pos = origin + rayDist*direction;

        // Use our distance estimator to find the distance
        float _distance = sphereDE(current_pos, vec3(0.0), 1.0);

        if(_distance < MIN_DIST) {
            // We hit an object! This just adds a subtle shading effect.
            return vec3(rayDist/float(NUM_STEPS)*4.0);

        if(rayDist > MAX_DIST) {
            // We have gone too far

        // Add the marched distance to total
        rayDist += _distance;
    // The ray didn't hit anything so return a color (black, for now)
    return vec3(0.0);

Now we have all we need to raymarch except a main function.
Let’s write it:

void main( out vec4 fragColor, in vec2 fragCoord ) {
    // normalized coordinates, resolution should be the window/screens pixel dimensions.
    vec2 uv = fragCoord / resolution.xy * 2.0 - 1.0;
    uv = uv / vec2(0.6, 1.0);

    // camPos can be a uniform if you want to move around
    vec3 camPos = vec3(0.0, 0.0, -3.0);
    vec3 rayDir = vec3(uv, 1.0);

    // march!
    vec3 shaded_color = march(camPos, rayDir);

    // set the color!
    fragColor = vec4(shaded_color, 1.0);

And we are done! Once you’ve put these together, you should be able to see a circle that subtly gets lighter towards the edges.


While what we just made was cool and all, it’s not that exciting. It’s monochrome, dull, and there’s not much to it other than a sphere.
We cold make a struct for a ray, and then we’d be able to return all sorts of useful values:

struct Ray {float distance; vec3 endPos; float minDist; bool hit;};

So here is my final version:

const int NUM_STEPS = 32; // doesn't matter much right now
const float MIN_DIST = 0.001; // threshold for intersection
const float MAX_DIST = 1000.0; // oops we went into space

struct Ray {float totalDist; float minDist; vec3 endPos; bool hit;};

// The distance estimator for a sphere
float sphereDE(vec3 pos, vec3 spherePos, float size) {
    return length(pos - spherePos) - size;

Ray march(vec3 origin, vec3 direction) {
    float rayDist = 0.0;
    float minDist = MAX_DIST;

    for(int i = 0; i < NUM_STEPS; i++) {
        vec3 current_pos = origin + rayDist * direction;

        // Use our distance estimator to find the distance
        float _distance = sphereDE(current_pos, vec3(0.0), 1.0);

        minDist = _distance < minDist ? _distance : minDist;

        if(_distance < MIN_DIST) {
            // We hit an object!
            return Ray(rayDist, minDist, current_pos, true);

        if(rayDist > MAX_DIST) {
            // We have gone too far

        // Add the marched distance to total
        rayDist += _distance;
    return Ray(MAX_DIST, minDist, origin + rayDist * direction, false);

void mainImage( out vec4 fragColor, in vec2 fragCoord )
    // Normalized pixel coordinates (from 0 to 1)
    vec2 uv = fragCoord / iResolution.xy * 2.0 - 1.0;

    // scale the ra
    uv = uv / vec2(0.6, 1.0);

    vec3 camPos = vec3(0.0, 0.0, -3.0);
    vec3 rayDir = vec3(uv, 1.0);

    Ray marched = march(camPos, rayDir);

    vec3 color = marched.hit ? 
        vec3(marched.totalDist/pow(float(NUM_STEPS), 0.8)*4.0) : // shading
        vec3(0.0) + vec3(pow(clamp(-1.0 * marched.minDist + 1.0, 0.0, 1.0), 4.0) / 2.0); // glow

    fragColor = vec4(color,1.0);

Here’s how it looks!
There are infinity other additions you can make like colors, CSG (boolean operations between DEs), or more shapes to play around with. However my fingers are getting really tired so I’m going to stop here.

I also highly recommend watching CodeParade’s intro video about ray marching as well as his video about marble marcher, a game made with ray marching and pretty fractals.

Because I referenced ray tracing/ray marching above . . .

RE: Leo Blondel (signaling pathway genes/virtual reality via ray marching/network biology/computational biology)

See more on Leo Blondel on this JOGL thread: Just One Giant Lab (JOGL), Thomas Landrain, AXA Research Fund, ARPANET, Randy Rettberg, Tom Knight, International Genetically Engineered Machine (iGEM), Gingko Bioworks - #3 by leo.

Computational approaches to developmental biology





Thesis advisor: Professor Cassandra G. Extavour


The origin and evolution of new genes is an active topic of research, relying on the taxonomical diversity now present in sequence databases. Using those databases, we described how oskar, a key determinant of germ cell determination, likely arose from a horizontal gene transfer and then described its evolution and conservation in insects. The number of ovarioles, the egg-producing unit of the insect ovary, is hypothesized to inform the individualʼs reproductive capacity. Using network biology approaches, we analyzed the effect of signaling pathway genes on the number of ovarioles and eggs laid by Drosophila melanogaster. We found putative gene modules regulating both traits and predicted novel genes affecting both phenotypes. The specification of germ layers is a central mechanism of the embryogenesis of animals, but the underlying molecular mechanisms have only been extensively studied in model organisms. Using Parhyale hawaiensis, a crustacean amphipod, I generated preliminary methods for the generation of single cell RNA sequencing of early embryogenesis, as well as recorded with light sheet microscopy the first three days of embryogenesis. The preliminary analyses of the sequencing datasets were inconclusive, but, analyzing one of the microscopy datasets, I described new preliminary cellular dynamic results. Finally, to observe and annotate 4D microscopy datasets, I developed a tool that allows the visualization of large volumetric datasets in Virtual Reality.


Cyberspace. A consensual hallucination experienced daily by billions of legitimate operators, in every nation, by children being taught mathematical concepts… A graphic representation of data abstracted from banks
of every computer in the human system. Unthinkable complexity. Lines of light ranged in the nonspace of the mind, clusters and constellations of data. Like city lights, receding…

William Gibson, Neuromancer, 1989

Diving in the third dimension, virtual reality for the analysis of volumetric microscopy

p. 283

…rendering technique is a set of instructions that will take the elements in a virtual environment, and generate an image that can be visualized on a screen. *One technique to render volumetric images is called Ray Marching. (p. 290-291 – See the Voronoi pattern)

So as not to confuse . . . it seems the following Vincent Blondel is NOT the same as the one referenced by Leo Blondel

Nonetheless (despite being seemingly unrelated, except having the same last name), the work of this particular Vincent Blondel seems key to telecom infrastructure, information theory, and
social physics . . .

In this paper, we review some advances made recently in the study of mobile phone datasets. This area of research has emerged a decade ago, with the increasing availability of large-scale anonymized datasets, and has grown into a stand-alone topic. We survey the contributions made so far on the social networks that can be constructed with such data, the study of personal mobility , geographical partitioning , urban planning , and help towards development as well as security and privacy issues .

Vincent Blondel, Gautier Krings, Isabelle Thomas

Regions and borders of mobile telephony in Belgium and in the Brussels metropolitan zone

Vincent Daniel Blondel (born April 28, 1965) is a Belgian professor of applied mathematics and current rector of the University of Louvain (UCLouvain) and a visiting professor at the Massachusetts Institute of Technology (MIT). Blondel’s research lies in the area of mathematical control theory and theoretical computer science. He is mostly known for his contributions in computational complexity in control,[1] multi-agent coordination[2] and complex networks.[3][4]

1 Like