science –

Constellation reflections

Gavin — Fri, 12 Jun 2026 12:42:27 +0000

This has happened before, but I thought I’d write it down this time, because it’s such a lovely story.

After a few years of quietness while I built ib1.org, a month ago I relaunched the Dgen constellation social directory. I need to note here too that Icebreaker One itself grew out of the Dgen constellation in exactly the same way as this. There’s a straight line, except it’s not really a straight line, it’s a constellation line.

Within two weeks over 60 people had reactivated, and one posted a bid in our Signal channel (thanks Matt) – within days a dozen people had expressed their interest and we had two calls, joined a briefing session with the prospect and now have an active and genuinely multidisciplinary group (banking to sound art) and a bid taking shape.

Some of the individuals coming together hadn’t seen each other for over five years (pre-lockdown) and so, of course, the majority of our calls weren’t about the work, but about catching up with each other, sharing stories and was inspiring to hear. The act of people just getting together to make things is always just lovely and we reflected that, unlike COVID, the current global sentiment is a very different shape, and carries a very different kind of weight.

On one level it doesn’t really matter what happens next, I’m just really happy that we’ve continued to build on our many-parts, loosely joined community … to find a way of getting really lovely people together to make new and unpredictable connections. Everything is all anchored on and around people who just love just doing stuff. If we win this particular commission it’d be amazing of course, but it is almost beside the point: the constellation doing what constellations do is the point. The bid is part of the constellation experiment.

The speed in which I was able to do this (I still run IB1) is supported by the tech that I’ve built very specifically around what I need, rather than someone else’s product or beholden to an enshitified product, is part of what we’re building here: tech that doesn’t enables and gets out of the way, doesn’t track or mess with our data in ways we don’t want. Part of the good side of what ai can enable is that we can all now build the tools (not the agents) we want to see in the world, rather than being someone else’s extractive product. I also have had to reflect that the nickname/handle I’ve used online for the last 20+ years (agentGav, thanks to Manu) now has a certain irony to it!

*** UPDATE *** One of our Constellation has just let me know that “One thing that emerged from the constellation is [anonymised] and I getting married. During the pandemic [anonymised] connected over a project and that’s how we met”. Oh my.

A screenshot of part of our Constellation below for reference, just to bring it to life – if you’d like to join, the link and description is here. If you’d like your own Constellation, please get in touch (yes, of course it’s open source).

ai code example: animated planetary orbit

Gavin — Fri, 21 Jul 2023 20:31:49 +0000

Today’s example of how easy AI can make it to write code. The interactive animation below is the final output from various experiments below.
[My words have this colour background. My instructions to the AI are in bold.
The rest of the content on this page is the AI. All of it, including words, code and highlighting.]

To begin with I just asked it the following:
write html, css and javascript to demonstrate a planet orbiting the sun
It replied…

Creating a realistic 3D planet orbiting the sun requires more advanced graphics and libraries, but I can show you a basic demonstration using HTML, CSS, and JavaScript that simulates a simple planet orbiting the sun

example.html




  
  
  Orbiting Planet

CSS (styles.css):

body {
  margin: 0;
  padding: 0;
  overflow: hidden;
}

.sun {
  width: 100px;
  height: 100px;
  background-color: orange;
  border-radius: 50%;
  position: absolute;
  top: 50%;
  left: 50%;
  transform: translate(-50%, -50%);
}

.planet {
  width: 30px;
  height: 30px;
  background-color: blue;
  border-radius: 50%;
  position: absolute;
  top: 50%;
  left: 50%;
  transform: translate(-50%, -50%);
}

JavaScript (script.js):

let angle = 0;
const orbitRadius = 150;
const orbitSpeed = 0.005;

function animatePlanet() {
  const planet = document.querySelector('.planet');
  const sun = document.querySelector('.sun');
  const sunRect = sun.getBoundingClientRect();
  const centerX = sunRect.left + sunRect.width / 2;
  const centerY = sunRect.top + sunRect.height / 2;

  const x = centerX + orbitRadius * Math.cos(angle);
  const y = centerY + orbitRadius * Math.sin(angle);

  planet.style.left = x + 'px';
  planet.style.top = y + 'px';

  angle += orbitSpeed;
  requestAnimationFrame(animatePlanet);
}

animatePlanet();

This code creates a basic representation of a planet (blue circle) orbiting the sun (orange circle). It uses CSS to position and style the sun and the planet, and JavaScript to calculate the position of the planet as it orbits the sun.

Please note that this is a simplified demonstration and does not include realistic physics or 3D graphics. For more advanced and realistic animations, you would need to use libraries like Three.js or other WebGL frameworks.”

This is pretty astonishing [output]

but I wasn’t happy with it being a circular orbit, so I asked it to:
redo with an elliptical orbit

Creating an elliptical orbit requires more complex mathematical calculations and is beyond the scope of basic HTML, CSS, and JavaScript. However, I can show you an example using the p5.js library, which is a JavaScript library for creative coding and visualization. The p5.js library simplifies handling graphics and animation, making it easier to demonstrate an elliptical orbit.

First, include the p5.js library in your HTML file:




  
  
  Elliptical Orbit

Next, create a JavaScript file (e.g., “sketch.js”) that will handle the animation and display of the elliptical orbit:

let sun;
let planet;
let orbitRadiusX = 150;
let orbitRadiusY = 100;
let angle = 0;
let orbitSpeed = 0.01;

function setup() {
  createCanvas(windowWidth, windowHeight);
  sun = createVector(width / 2, height / 2);
  planet = createVector(sun.x + orbitRadiusX, sun.y);
}

function draw() {
  background(240);

  // Draw the sun
  fill('orange');
  ellipse(sun.x, sun.y, 40, 40);

  // Calculate the position of the planet in the elliptical orbit
  let x = sun.x + orbitRadiusX * cos(angle);
  let y = sun.y + orbitRadiusY * sin(angle);

  // Draw the planet
  fill('blue');
  ellipse(x, y, 20, 20);

  // Update the angle for the next frame
  angle += orbitSpeed;
}

The above code sets up a canvas, defines the sun and planet as vectors, and uses trigonometry to calculate the position of the planet as it moves along an elliptical orbit around the sun. The orbitRadiusX and orbitRadiusY variables determine the shape and size of the elliptical orbit, while the orbitSpeed variable controls the speed of the orbit.

Save these HTML and JavaScript files in the same folder and open the HTML file in a web browser. You should see an animation of a blue planet orbiting an orange sun in an elliptical path. Feel free to adjust the values of orbitRadiusX, orbitRadiusY, and orbitSpeed to experiment with different elliptical orbits.

This is a great example of how game-changing AI is becoming. To see the two bits of code (copy & pasted) in action, click Circular or Elliptical. Remarkable.

And then my friend Andy noticed it wasn’t doing a Keplerian orbit, so
redo with a keplerian orbit
led to this

Creating a Keplerian orbit involves implementing more complex mathematical formulas to simulate the motion of celestial bodies following Kepler’s laws of planetary motion. To do this, we’ll use the p5.js library to handle graphics and animation.

First, include the p5.js library in your HTML file:




  
  
  Keplerian Orbit

Next, create a JavaScript file (e.g., “sketch.js”) that will handle the animation and display of the Keplerian orbit:

let sun;
let planet;
let a; // Semi-major axis
let b; // Semi-minor axis
let angle = 0;
let orbitSpeed = 0.01;

function setup() {
  createCanvas(windowWidth, windowHeight);
  sun = createVector(width / 2, height / 2);
  a = 150; // Set the semi-major axis
  b = 100; // Set the semi-minor axis
  planet = createVector(sun.x + a, sun.y);
}

function draw() {
  background(240);

  // Draw the sun
  fill('orange');
  ellipse(sun.x, sun.y, 40, 40);

  // Calculate the position of the planet in the Keplerian orbit
  let x = sun.x + a * cos(angle);
  let y = sun.y + b * sin(angle);

  // Draw the planet
  fill('blue');
  ellipse(x, y, 20, 20);

  // Update the angle for the next frame
  angle += orbitSpeed;
}

The above code sets up a canvas, defines the sun and planet as vectors, and uses trigonometry to calculate the position of the planet following Kepler’s laws of planetary motion. The a and b variables determine the size and shape of the Keplerian orbit, while the orbitSpeed variable controls the speed of the orbit.

Save these HTML and JavaScript files in the same folder and open the HTML file in a web browser. You should see an animation of a blue planet following a Keplerian orbit around an orange sun. Feel free to adjust the values of a, b, and orbitSpeed to experiment with different Keplerian orbits.

Interesting but still not quite there

So let’s
place the sun at a focus point and add gravity

To add gravity to the Keplerian orbit simulation, we can use Newton’s law of universal gravitation to calculate the gravitational force between the sun and the planet. The force will affect the acceleration of the planet, causing it to move in a curved path around the sun.

Here’s the updated code that includes gravity:

let sun;
let planet;
let a; // Semi-major axis
let b; // Semi-minor axis
let c; // Distance from the center to focus (c = sqrt(a^2 - b^2))
let angle = 0;
let orbitSpeed = 0.01;
let G = 0.5; // Gravitational constant

function setup() {
  createCanvas(windowWidth, windowHeight);
  sun = createVector(width / 2, height / 2);
  a = 150; // Set the semi-major axis
  b = 100; // Set the semi-minor axis
  c = sqrt(a * a - b * b);
  planet = createVector(sun.x + c + a, sun.y);
}

function draw() {
  background(240);

  // Draw the sun at the focus point
  fill('orange');
  ellipse(sun.x, sun.y, 40, 40);

  // Calculate the position of the planet in the Keplerian orbit
  let x = sun.x + c + a * cos(angle);
  let y = sun.y + b * sin(angle);

  // Draw the planet
  fill('blue');
  ellipse(x, y, 20, 20);

  // Calculate the distance between the planet and the sun
  let distance = dist(x, y, sun.x, sun.y);

  // Calculate the gravitational force between the planet and the sun
  let force = G * (1 / (distance * distance));

  // Calculate the angle of the force vector
  let forceAngle = atan2(sun.y - y, sun.x - x);

  // Calculate the acceleration of the planet due to gravity
  let acceleration = force / 1; // We can simplify the mass of the planet as 1

  // Update the planet's velocity based on the acceleration
  orbitSpeed += acceleration;

  // Update the angle for the next frame
  angle += orbitSpeed;
}

In this updated code, we introduce the gravitational constant G (you can adjust its value to control the strength of gravity) and calculate the gravitational force between the sun and the planet using Newton’s law of universal gravitation. The planet’s acceleration is then updated based on the gravitational force, and its velocity is adjusted accordingly. The result is a more realistic simulation of a Keplerian orbit with gravity affecting the motion of the planet around the sun.

Save these HTML and JavaScript files in the same folder and open the HTML file in a web browser. You should now see an animation of a blue planet following a Keplerian orbit around an orange sun, with gravity affecting its movement. Feel free to experiment with different values of G and other parameters to observe different orbital behaviors.

Very interesting. It get’s it much more right, but there’s an acceleration that shouldn’t be there. The planet spins faster and faster…

so, rather than try and troubleshoot it, let’s just ask it
why does the speed of the planet accelerate?

Apologies for the confusion in the code. The speed of the planet should not accelerate as a result of gravitational force. In reality, the speed of a planet in a stable orbit around the sun remains constant.

To accurately simulate a stable orbit, we need to use the principles of circular motion and centripetal force. The centripetal force acts perpendicular to the velocity vector, causing the planet to follow a circular path around the sun. In this scenario, the speed of the planet remains constant while its direction continuously changes.

Let’s correct the code to achieve a stable circular orbit:

let sun;
let planet;
let a; // Semi-major axis
let b; // Semi-minor axis
let c; // Distance from the center to focus (c = sqrt(a^2 - b^2))
let angle = 0;
let orbitSpeed = 0.01;
let G = 0.5; // Gravitational constant

function setup() {
  createCanvas(windowWidth, windowHeight);
  sun = createVector(width / 2, height / 2);
  a = 150; // Set the semi-major axis
  b = 100; // Set the semi-minor axis
  c = sqrt(a * a - b * b);
  planet = createVector(sun.x + c + a, sun.y);
}

function draw() {
  background(240);

  // Draw the sun at the focus point
  fill('orange');
  ellipse(sun.x, sun.y, 40, 40);

  // Calculate the position of the planet in the Keplerian orbit
  let x = sun.x + c + a * cos(angle);
  let y = sun.y + b * sin(angle);

  // Draw the planet
  fill('blue');
  ellipse(x, y, 20, 20);

  // Update the angle for the next frame
  angle += orbitSpeed;
}

And, there we have it. We didn’t even need to understand why the planet was accelerating, or if there was a bug in the code, just ask a question and it corrected itself.

I wanted to change the colours and layout a bit, so I asked it to do that too
left-align the scene, make the sun yellow, the background black and the planet blue
and then I thought it’d be fun if we made it interactive, so I asked
add a slider so I can change the value of G and ensure that the animation updates automatically if the value is changed. put the slider at the top in the middle
which it didn’t get right the first time (the slider moved but the planet speed didn’t change) so,
that isn’t updating the value of G in the animation
which fixed it, and then a final bit of fiddling
print the value of G on the screen as well. align the slider so it’s just above the animation
move it 200px left. Keep the value of G next to the slider
and so on, which resulted in the interactive example at the top of this page

And, lastly, for fans of Processing, simply asking it to
rewrite this in Processing
gave this working code

int sunX, sunY;
float a; // Semi-major axis
float b; // Semi-minor axis
float c; // Distance from the center to focus (c = sqrt(a^2 - b^2))
float angle = 0;
float orbitSpeed = 0.01;
float G = 0.5; // Gravitational constant

void setup() {
  size(800, 600);
  sunX = width / 4;
  sunY = height / 2;
  a = 150; // Set the semi-major axis
  b = 100; // Set the semi-minor axis
  c = sqrt(a * a - b * b);
}

void draw() {
  background(0); // Set background color to black

  // Draw the sun at the focus point
  fill(255, 255, 0); // Change sun color to yellow
  ellipse(sunX, sunY, 40, 40);

  // Calculate the position of the planet in the Keplerian orbit
  float x = sunX + c + a * cos(angle);
  float y = sunY + b * sin(angle);

  // Draw the planet
  fill(0, 0, 255); // Change planet color to blue
  ellipse(x, y, 20, 20);

  // Update the angle for the next frame based on the slider value
  angle += G * orbitSpeed; // Use G to modify orbit speed

  // Display the value of G next to the slider
  fill(255);
  textSize(20);
  text("Gravitational Constant (G): " + G, 20, 20);
}

// Event handler for the slider
void mouseReleased() {
  if (mouseX >= 20 && mouseX <= 320 && mouseY >= 40 && mouseY <= 60) {
    // Map the x-coordinate of the mouse to a value between 0 and 2 for G
    G = map(mouseX, 20, 320, 0, 2);
  }
}

Testing out this AI thing

Gavin — Fri, 24 Mar 2023 17:58:08 +0000

create an algorithm for trading based on 1% value swings

Here’s a basic algorithm for trading based on 1% value swings:

Define your target security: Select a security that you wish to trade based on 1% value swings.
Set your trading parameters: Define the parameters for your trades, including the amount of capital you’re willing to invest, your desired profit margin, and your stop-loss limit.
Monitor the security’s value: Continuously monitor the value of your target security. You can use various tools such as trading software, financial news sources, or chart analysis to track its value.
Identify 1% value swings: When the security’s value changes by 1% in either direction, take note of it.
Buy or sell: If the value of the security has decreased by 1%, and you believe it will rebound, consider buying the security. Conversely, if the value of the security has increased by 1%, and you believe it may drop, consider selling the security.
Set stop-loss limit: To manage risk, set a stop-loss limit for each trade. This is the maximum amount of money you’re willing to lose if the trade doesn’t go in your favor.
Take profit: Set a profit target for each trade, which is the desired amount of profit you want to earn. When the security’s value reaches this target, close the trade and take your profit.
Repeat the process: Continue monitoring the security’s value, identifying 1% swings, and making trades as necessary.

Note: This is a basic algorithm, and there are many factors to consider when trading, such as market conditions, liquidity, volatility, and more. It’s important to do your research and fully understand the risks involved before implementing any trading strategy.

2. write this is pseudocode

Sure, here’s the pseudocode for the trading algorithm based on 1% value swings:

Note that this is a basic pseudocode and it does not include error handling or other advanced features. Additionally, some variables and functions may need to be defined and implemented separately.

3. write this in python

Sure, here’s an example implementation of the trading algorithm based on 1% value swings in Python:

target_security = "AAPL"  # define the target security

# define the trading parameters
capital = 1000
profit_margin = 1.01  # 1% profit margin
stop_loss = 0.99  # 1% stop-loss limit

while True:
    current_value = get_current_value(target_security)  # get the current value of the target security
    if current_value >= profit_margin:
        sell(target_security)  # sell the security if it has increased by 1%
    elif current_value <= stop_loss:
        buy(target_security)  # buy the security if it has decreased by 1%
    else:
        continue  # otherwise, continue monitoring the value

    # set stop-loss limit and profit target
    stop_loss_value = current_value * stop_loss
    profit_target_value = current_value * profit_margin

    while True:
        updated_value = get_current_value(target_security)  # get the updated value of the target security
        if updated_value <= stop_loss_value:
            sell(target_security)  # sell the security if it hits the stop-loss limit
            break
        elif updated_value >= profit_target_value:
            sell(target_security)  # sell the security if it hits the profit target
            break
        else:
            continue  # otherwise, continue monitoring the value

Note that this is just an example implementation and may need to be adapted to your specific trading platform or strategy. Also, the get_current_value, buy, and sell functions are not defined here and need to be implemented separately based on the API or service you’re using.

And now for some fun

write this for a quantum computer

While quantum computers have the potential to solve certain financial problems more efficiently than classical computers, it’s currently unclear how exactly they could be used for trading based on 1% value swings. As quantum computing is still in its early stages of development, there are few, if any, quantum trading algorithms that have been developed and tested at scale.

However, one possible approach to leveraging quantum computing for trading is by using quantum machine learning algorithms to analyze financial data and identify patterns that can be used to make trading decisions. For example, one could use quantum annealing to optimize portfolio selection and risk management, or quantum algorithms to perform efficient optimization of trading strategies.

Here’s an example of how one could use the Qiskit framework in Python to implement a simple quantum machine learning algorithm for financial prediction:

import numpy as np
from qiskit import Aer
from qiskit.circuit.library import ZZFeatureMap
from qiskit.aqua.algorithms import VQC
from qiskit.aqua.components.optimizers import COBYLA

# Define the target security and trading parameters
target_security = "AAPL"
capital = 1000
profit_margin = 1.01
stop_loss = 0.99

# Define the quantum feature map and backend
feature_map = ZZFeatureMap(feature_dimension=2)
backend = Aer.get_backend('qasm_simulator')

# Define the VQC classifier and optimizer
classifier = VQC(feature_map, None, None)
optimizer = COBYLA()

# Train the classifier on historical financial data
data = np.array([[0.5, 0.1], [0.1, 0.9], [0.2, 0.8], [0.3, 0.7], [0.4, 0.6]])
labels = np.array([0, 1, 1, 0, 0])
classifier.train(data, labels)

# Use the classifier to make trading decisions
while True:
    current_data = np.array([[get_current_price(target_security), get_current_volume(target_security)]])
    predicted_label = classifier.predict(current_data)[0]
    if predicted_label == 0:
        buy(target_security)
    elif predicted_label == 1:
        sell(target_security)
    else:
        continue

    # Set the stop-loss limit and profit target
    stop_loss_value = get_current_price(target_security) * stop_loss
    profit_target_value = get_current_price(target_security) * profit_margin

    while True:
        updated_price = get_current_price(target_security)
        if updated_price <= stop_loss_value:
            sell(target_security)
            break
        elif updated_price >= profit_target_value:
            sell(target_security)
            break
        else:
            continue

Again, note that this is just a simple example of how one could use quantum machine learning for trading, and many details would need to be filled in depending on the specific application and data available.

So, there we have it. I can now learn how to write code for a quantum computer that might have some bearing on financial insights, with zero knowledge.

An open environmental risk standard?

Gavin — Sun, 18 Nov 2018 00:00:55 +0000

UPDATE 2019-02: briefing note here

Working with Europe’s leading climate innovation fund, Climate KIC, we are initiating the creation of an Open Environmental Risk Standard for the insurance sector to:

develop an open standard for sharing environmental risk modelling information;
create sufficient momentum to reach an ‘escape velocity’ that drives engagement and adoption;
to enable a step-change in economic, social and environmental outcomes that unlocks the multi-trillion dollar market opportunity in the use and application of risk information.

If you are interested in getting involved, please email gavin@dgen.net

Climate KIC is the largest climate change focussed incubator in the world, with a network across 13 European countries

BBookproject launches

Gavin — Sun, 28 Oct 2018 13:55:43 +0000

Constellator Anna Versteeg has launched her new project: https://bbookproject.com

“a collaboration between medics, scientists, researchers, writers, artists, designers and the general public, exploring science and culture, the empirical and the human, to compile a people centered piece of work to create public awareness & debate around the breast, to question beliefs and prejudices, to share information, promote diversity (no breast is the same), encourage confidence and a positive change to the many troubling perceptions towards breasts.”

Quantum Quipu

Gavin — Sun, 01 Jul 2018 00:00:49 +0000

How the visual language of technology comes around every 1,000 years or so…

“talking knots were recording devices fashioned from strings. The Inca people used them for collecting data and keeping records, monitoring tax obligations, properly collecting census records, calendrical information, and for military organization” (more about Quipu and its decoding)

“we illustrate a step-by-step process for the design of a generic quantum computation device which implements a Turing-equivalent finite state machine capable of using superposition for all instructions, data, and state. In other words, it can execute completely separate branching instructions in quantum superposition.” (more about QQFSM — A Quantum Finite-State Machine).

Also see:

Quantum knots — experimental observations of knots in quantum matter — knotted solitary waves, or knot solitons, in the quantum-mechanical field describing a gas of superfluid atoms, also known as a Bose–Einstein condensate.

Quipu: High-performance Simulation of Quantum Circuits using Stabilizer Frames

A quantum city?

Gavin — Sat, 12 May 2018 12:40:56 +0000

Light pipes for photons, in triangles and loops

(in the photo, the oblongs are loops of fibre to create delays and the lines all fibre optics)

About 18 months ago (thanks to Libby) I attended a discussion about some of the most advanced quantum computing research in the world.

At the time I thought this must have been how it felt when people first made electrical circuits: the excitement of being able to channel and control electrons, that we now take for granted, but this time with light.

It felt like magic to me that we could control photons within such a beautiful design and wondered, given we see electrical circuits as a visual equivalent to cities, how quantum computers might indicate the future of our city design?

I love Stanza’s work for this (and many) reasons.

“The age of privacy is over. Imagine walking out the door, and knowing every single action, movement, sound, micro movement, pulse, and thread of information is being tracked, monitored, stored, analyzed, interpreted, and logged. The world we will live in seems to be a much bigger brother than the Orwellian vision, it is the mother of big brother.”

What if Nature were not collective but distributive?

Nomos asks if “the Quantum City is, different from the Mechanical and the Dynamic City, not strictly rational” and posits another angle that is highly aligned with contemporary cultural development (from the co-op movement to distributed ledgers/blockchain)

Arida has mapped [2002] the evolution of world views from the Roman Empire to Quantum theory, and the close links between science and urban form. He looked at the way we can design and live in quantum cities, exploring methodologies that can frame quantum urbanism: this work continues on the website http://www.quantumcity.com “Urbanism Needs a Conceptual Revolution”.

In one example (of many), IAAC created its framing of the quantised city [video, 2012], blending data from IoT sensors, cloud computing and combining environmental and energy data as part of urban architecture.

CAAD has published [2015] ‘A Quantum City, Mastering the Generic’, self-described as “a love letter to the city and intellectual culture”, it introduces Orlando — neither an authoritarian functionary, nor a restless activist, nor a comfortable member of a bourgeoisie, but a citizen of the digital age, a Quantum Citizen. https://www.caad.arch.ethz.ch/blog/a-quantum-city-mastering-the-generic

It feels to me that there is a line of enquiry to use the subjectivity of art to question the objectivity of science, political dogma, urban design and notions of truth.

What are the visual loops that could be examined between the circuit designs of quantum computers, city architecture, building design and social constructs?

How does this interface with our notions of Data Infrastructure?

Is there something to learn from combining quantum computing, art, urban design and cultural uncertainty?

Adventures in acoustic cosmology

Gavin — Mon, 03 Jul 2017 07:00:36 +0000

ROYAL ASTRONOMICAL SOCIETY PRESS RELEASE

RAS PR 17/30 (NAM 13)

3^rd July 2017

A project that explores whether there is a musical equivalent to the curvature of spacetime will be presented on Thursday 6^th July by Gavin Starks at the National Astronomy Meeting at the University of Hull.

Starks, who has a background in radio astronomy and electronic music, been working on developing an ‘acoustic cosmology’ for more than 20 years in collaboration with Prof Andy Newsam of Liverpool John Moores University. Their aim is to test whether mathematical relationships that describe cosmology and quantum mechanics can be applied to a sonic universe, or ‘soniverse’.

Starks explains: “If we look at the way that music has evolved from mediaeval plainsong to the algorithms that generate current chart-hits, we can see parallels developing in the way we describe music and descriptions of our perception of the universe. We can now create new types of sound from scratch – electronic sounds that simply couldn’t have existed before. It leads us to think about a digital sound world that we can’t enter, because it physically doesn’t exist. The question is – what next?

“We are starting to develop completely new forms of manipulating the microstructure of sound, as well as the macroenvironment in which we experience it. This raises questions about whether we can create a soniverse based on a set of fundamental equations, in the same way that we can create mathematical models of the universe.”

Starting with a single wavelength ‘sonon’, a fundamental particle in the soniverse equivalent to a photon, Starks has attempted to define its properties and the physics that may apply to it. The project’s initial model of ‘wave-time’ has three independent dimensions: the individual sonon wavelength, instrument time (the duration that an individual instrument plays) and performance time (duration equal to the length of an individual piece).

Some of the relationships explored to date are causal (i.e. the physics is consistent within the soniverse) and some are aesthetic (i.e. they describe a subjective musical construct). Many have direct parallels in the physical universe. For example, the listener in the soniverse is analogous to the observer in quantum mechanics: a sonon is only rendered musical or not when it is heard. A temporal gravity allows the clustering of sonons to create rhythms or musical phrases. Wave-time can be bent by clusters of sonons, in the same way that gravity distorts space-time in the universe.

Starks believes that bringing together cutting-edge science and understanding of musical structure creates the opportunity for discovery: “There’s a long common history between physics and music, for instance people built columns in cathedrals at a height linked to the resonant frequency, even before they understood the nature of pressure dynamics. It’s a relatively recent phenomenon that art and science are treated as different disciplines. By bringing them back together, and creating a common language, we can find different ways of interpreting and thinking about both music and cosmology.”

Newsam adds: “As astronomers, our experience of the universe is essentially visual – images, graphs, and so on. With the soniverse, we hope to create a new way to appreciate the cosmos, using our instinctive grasp of music and tone to explore relationships between different objects and cosmological models.”

Media contacts

NAM press office

Robert Massey, Royal Astronomical Society, rm@ras.org.uk

Anita Heward, Royal Astronomical Society, anitaheward@btinternet.com

Morgan Hollis, Royal Astronomical Society, mh@ras.org.uk

Science contacts

Gavin Starks, Dgen, binarydust.org, gavin@dgen.net, @agentGav

Andy Newsam, Professor of Astronomy Education and Engagement, Director of the National Schools’ Observatory, Liverpool John Moores University, andy@schoolsobservatory.org.uk

Multimedia

Blog post with embedded player, video and more information: http://www.binarydust.org/2017/05/18/listen-to-the-radio-cube-of-the-antennae-galaxies/

This data-cube is based on an optical image of the “Antennae Galaxies” colliding, as taken by the Hubble Space Telescope and a radio-image taken by ALMA. Each pixel actually represents a spectrum of frequencies across the electromagnetic radio spectrum

The data-cube works in two ways.

Firstly, the radio frequencies have been transformed into visible colours, so you can see a slice of the cube.
Secondly, the electromagnetic spectrum has been transformed into an acoustic spectrum. Remember light≠sound: the frequency of electromagnetic radiation (‘light’) has been transformed into a frequency of pressure wave (sound).

By clicking the image and moving your cursor around you can “play” a spectrum of the colliding galaxies. Underneath, you can see a visual representation of the frequency spectrum. Spend some time moving slowly around the red(redshifted) areas – there is a surprising richness to the harmonics for such a simple sonification.

Note: the data-cube is 8MB and could take between 20 seconds to several minutes to appear if you are on a slow connection.

Audio

Inspired by the discovery of the first double-pulsar system (ranked as the 6th most important scientific discovery of 2004), and specially written to celebrate the 10th anniversary of RT32 – a reclaimed 32m Radio Telescope in the middle of the Latvian forests (the VIRAC Radio Telescope in Irbene) brought to life over a decade, after being trashed by the Soviet military, as the only radio telescope in the world that is dedicated to both science and art.

The full name of the piece is ds² – series 1 (PSR J0737-3039B) http://www.binarydust.org/2010/01/04/ds2-series-1/

Further information:

Further information on the project can be found at: http://www.binarydust.org/2017/01/27/escape-into-the-multiverse/

Notes for editors

Running from 2 to 7 July, the RAS National Astronomy Meeting 2017 (NAM 2017, http://nam2017.org) takes place this year at the University of Hull. NAM 2017 will bring together around 500 space scientists and astronomers to discuss the latest research in their respective fields. The conference is principally sponsored by the Royal Astronomical Society and the Science and Technology Facilities Council.

T: http://twitter.com/rasnam2017

The Royal Astronomical Society (RAS, www.ras.org.uk), founded in 1820, encourages and promotes the study of astronomy, solar-system science, geophysics and closely related branches of science. The RAS organises scientific meetings, publishes international research and review journals, recognises outstanding achievements by the award of medals and prizes, maintains an extensive library, supports education through grants and outreach activities and represents UK astronomy nationally and internationally. Its more than 4000 members (Fellows), a third based overseas, include scientific researchers in universities, observatories and laboratories as well as historians of astronomy and others.

T: https://twitter.com/royalastrosoc

F: https://facebook.com/royalastrosoc

The Science and Technology Facilities Council (STFC, www.stfc.ac.uk) is keeping the UK at the forefront of international science and has a broad science portfolio and works with the academic and industrial communities to share its expertise in materials science, space and ground-based astronomy technologies, laser science, microelectronics, wafer scale manufacturing, particle and nuclear physics, alternative energy production, radio communications and radar.

STFC’s Astronomy and Space Science programme provides support for a wide range of facilities, research groups and individuals in order to investigate some of the highest priority questions in astrophysics, cosmology and solar system science. STFC’s astronomy and space science programme is delivered through grant funding for research activities, and also through support of technical activities at STFC’s UK Astronomy Technology Centre and RAL Space at the Rutherford Appleton Laboratory. STFC also supports UK astronomy through the international European Southern Observatory.

T: https://twitter.com/stfc_matters

Data is not the new oil. Data > Oil

Gavin — Wed, 10 May 2017 19:26:41 +0000

“The world’s most valuable resource is no longer oil, but data” says The Economist

“Data is the new oil”, said Clive Humby and many others [*update: or “new water”, “new electricity” etc… ugh]

Some people have described why it is and that it’ll be a new currency.

2014 Wired said it was and that “data infrastructure should become a profit centre”

In 2012 Forbes asked “Is Data The New Oil?”, saying “Data is just like crude. It’s valuable, but if unrefined it cannot really be used. It has to be changed into gas, plastic, chemicals…”

And, while it’s easy to run with these kinds of comparisons, they are shallow.

They miss at least three critical attributes.

Data doesn’t run out — data can be for everyone
You can make a copy of the data for (effectively) zero cost
Data increases in value the more it is connected

The economic model for a commodity that doesn’t run out is more like solar power than oil.

The value of data is not based on scarcity (even if you think it currently is, it wont be).

The economic model for a commodity that increases in volume and value the more it is connected is, well, more like the web. It might be more accurate to say that the ‘web of data’ is the new ‘web of documents’. Extrapolating… the value of data is greater than the value of oil.

Oh, and since I’m a climate geek, setting aside the carbon footprint of the internet (which is big), data doesn’t cause catastrophic climate change in the same way that oil does. Although, we may soon need data sequestration for all our binary dust.

And, lest we forget how organisations often relate to data, here is a potential vision for the future of data—if we don’t pay more attention.

(NB: original photo is copyright Richard Olsenius and used with permission here)

Other links

https://hbr.org/2012/11/data-humans-and-the-new-oil by Jer Thorpe

https://www.forbes.com/sites/bernardmarr/2018/03/05/heres-why-data-is-not-the-new-oil/

Data is the new Water I: Water gives life (oil takes it)

The AMEE story (part one)

Gavin — Fri, 10 Mar 2017 13:41:38 +0000

In 2005, I was working with climate change charity Global Cool and global hedge fund Man Group (in my spare time) to try and create a global movement around climate change awareness and action.

While chairing the working group that created the “Global Cool Tonne” (which became one of the first UK Government’s Gold Standard offset mechanisms) I became very concerned about the transparency and credibility of the information being used in the market. As a result of this I started to pull together ideas about how to solve that problem.

To create long-term, scalable change I believe you need credible, transparent information. We have all witnessed that the Carbon markets have suffered greatly from a lack of such credibility.

Andrew Conway and I studied astrophysics together at Glasgow University, and have been friends for over 20 years. Diggory Briercliffe and I worked together to to design and build Virgin Net’s web systems, and have been friends for over 15 years.

The genesis of AMEE (in 2006) was the combination of three events: (1) a conversation with Diggory to discuss the potential of representing emissions data and a computational and transactional engine, in a web-service API. (2) a conversation with Andrew to discuss the potential of codifying Government and environmental standards in such an open platform, and (3) a presentation I gave to Climate Change Capital presenting my ideas for treating carbon as a global currency – with CO2e values mapped against every line-item on financial statements.

I funded the initial development through Dgen and, via various friends and colleagues, we were noticed by Bryony Worthington from Defra, who was lead author on the Climate Change Act. The Friday before Christmas in 2006 I was called into Defra to explain what our plans were for helping to open up Government data (the bedrock of the calculations used in carbon footprinting). At the end of that meeting I was asked to write a white paper for UK Secretary of State, David Miliband, to go in his briefcase on the Monday so he could digest it over Christmas.

We began working directly with Defra on 2nd Jan 2007. Six months later, the Secretary of State went on national television to launch the project, “Act on CO2”.

There were many “firsts” that came from this project:

The first Government standard for domestic footprinting in the world
The first national climate change campaign in the world
The first Government-backed open data initiative around carbon footprinting data
The world’s largest survey of domestic energy and carbon consumption (1.8 million homes)
Proper separation of data of personal identity from underlying profile data from a data protection perspective

AMEE was also one of the first commercial companies to pioneer access to open Government data using a web-service API, and to address privacy issues by anonymising citizen information as the default setting within our solution. As a result AMEE was held as an exemplar by both Government and industry leaders, such as the Open Knowledge Foundation, and referred to as “the magical machine behind most carbon calculators”.

This “founding team” of AMEE included Anna Clayton, Andrew Conway, Diggory Briercliffe, Marcus Bointon, and Chris John.

While they remained an integral part of the project for some time, Diggory, Chris and Marcus chose to continue running their own companies, while Andrew chose to continue to run his own venture and join AMEE. Anna continued as project and account manager.

After DECC’s official launch, AMEE adoption grew exponentially – over 1.8M end-user profiles through Act on CO2, Google, Morgan Stanley, Radiohead, The Energy Savings Trust, Dopplr, EEDA, The RSA, and many others signing up and pioneering use of the service.

After presenting at the 2008 O’Reilly conference, ETech, I met with Mark from OATV. On the strength of this and meeting with the AMEE team, OATV led (within 3 weeks) our $2m Series A investment with Union Square Ventures, and catapulted us on our journey to provide Environmental Intelligence — Everywhere.

After our investment, we added Bryony Worthington (now Baroness Worthington), Jamie Andrews, James Smith, Calum Alexander, Dickon Ausden, and James Hetherington to the startup team, shaping the core of the AMEE platform and its content.

Part two to follow….