What the hack is Rule 30? Cellular Automata Explained

Introduction

If you ask the same question, what is this Rule 30, then you are not alone. This rule is related to one-dimensional Cellular Automata introduced by Stephen Wolfram in 1983 and later described in his A New Kind Of Science book. Even though, I skimmed through this book previously, I was never able to understand what was it all about. It had some neat diagrams, but I didn’t try to understand how the diagrams where generated. This changed a day ago when I watched an interesting interview that Lex Fridman had with Stephen Wolfram, where they discussed among other things Rule 30, which was the one that Wolfram described first. This rule is capable of generating a complex behavior even though the rule itself is very simple to define.

Elementary Cellular Automaton

The Elementary Cellular Automaton consists of a one-dimensional array of cells that can be in just two sates, namely, black or white color. The cellular automaton starts from initial state, and then transition to the next state based on a certain function. The next state of the automaton is calculated based on the color of current cell and its left and right neighbors’ colors. By the way, that transition function, gives its name to the cellular automaton rule, just like Rule 30.

Rule 30 transition function

Current Sate111110101100011010001000
Next state00011110

Where, for example, the binary digits ‘111’ in the first column indicate the black color of the left, current and right cells, and the values, ‘0’ or ‘1’ indicate what will be the color of the current cell in the next state (iteration) of the automaton. If we write down all the the binary values of the next state together as a single 8 digit binary number, which is 00011110 and convert it to a decimal number we get 30, and hence the name of the Rule 30. In a Boolean form this transition function is

(left, current, right) -> left XOR (current OR right)

We’ll use this function later in the C++ implementation of the Rule 30.

This is how the output from Rule 30 looks like after 20 and 100 steps respectively.

source: WolframAlpha

How to generate Rule 30?

It is easy to implement the Rule 30 using a 64 bit integer in C++. The only drawback is that we can get only 32 steps with the implementation below taken from Wikipedia.

Note: If this is a little bit to much for you now, then skip to the next part where we’ll use WolframAlpha to program it for us.

In the code below a 64 bit integer is used to generate an initial state using a bit mask in line 6. Then the outer for loop generates 32 steps of the Rule 30 by applying the transition function in line 19. The inner loop generates the black (using character ‘1’) and white (using character ‘-‘) colors using state bit mask.

#include <stdint.h>
#include <iostream>

int main() {
 // This is our bit mask with the 32 bit set to '1' for initial state
  uint64_t state = 1u << 31;

  for (int i = 0 ; i < 32 ; i++) {

    for (int j = sizeof(uint64_t) * 8 - 1 ; j  >=  0 ; j--) {
      // Here we decide what should be the color of the current cell based on the current state bit mask.
     // Bitwise operator is used to accomplish this efficiently
      std::cout << char(state  >>  j & 1 ? '1' : '-');
    }
    std::cout << '\n';
    
    // This is just the (left, current, right) -> left XOR (current OR right) functioned mentioned previously
   // Bitwise operators  are used to accomplish this efficiently
    state = (state >> 1) ^ (state | state << 1);
  }
}

It is possible to run this code in the online C++ compile. Just click on the link and then click on the green Run button at the top of the screen. The result looks similar to below.

The full output for 32 steps looks like this

--------------------------------1-------------------------------
-------------------------------111------------------------------
------------------------------11--1-----------------------------
-----------------------------11-1111----------------------------
----------------------------11--1---1---------------------------
---------------------------11-1111-111--------------------------
--------------------------11--1----1--1-------------------------
-------------------------11-1111--111111------------------------
------------------------11--1---111-----1-----------------------
-----------------------11-1111-11--1---111----------------------
----------------------11--1----1-1111-11--1---------------------
---------------------11-1111--11-1----1-1111--------------------
--------------------11--1---111--11--11-1---1-------------------
-------------------11-1111-11--111-111--11-111------------------
------------------11--1----1-111---1--111--1--1-----------------
-----------------11-1111--11-1--1-11111--1111111----------------
----------------11--1---111--1111-1----111------1---------------
---------------11-1111-11--111----11--11--1----111--------------
--------------11--1----1-111--1--11-111-1111--11--1-------------
-------------11-1111--11-1--111111--1---1---111-1111------------
------------11--1---111--1111-----1111-111-11---1---1-----------
-----------11-1111-11--111---1---11----1---1-1-111-111----------
----------11--1----1-111--1-111-11-1--111-11-1-1---1--1---------
---------11-1111--11-1--111-1---1--1111---1--1-11-111111--------
--------11--1---111--1111---11-11111---1-11111-1--1-----1-------
-------11-1111-11--111---1-11--1----1-11-1-----11111---111------
------11--1----1-111--1-11-1-1111--11-1--11---11----1-11--1-----
-----11-1111--11-1--111-1--1-1---111--1111-1-11-1--11-1-1111----
----11--1---111--1111---1111-11-11--111----1-1--1111--1-1---1---
---11-1111-11--111---1-11----1--1-111--1--11-1111---111-11-111--
--11--1----1-111--1-11-1-1--11111-1--111111--1---1-11---1--1--1-
-11-1111--11-1--111-1--1-1111-----1111-----1111-11-1-1-111111111

Compare the image above to the one generated using WolframAlpha symbolic language in the Wolfram Notebook.

Using WolframAlpha to generate Rule 30

WolframAlpha is a computational knowledge engine developed by Wolfram Research. It is embedded in Mathematica symbolic language and it has a declarative programming style. Which means that you specify what you want to be done instead of how it should be done.

For example, to generate Rule 30 and visualize it one simple writes

ArrayPlot[CellularAutomaton[30, {{1},0}, 64]]

where CellularAutomaton function generates 64 states of the automaton, starting with a one black cell in accordance with the Rule 30 generation function, and ArrayPlot function prints the result.

And the output is

Please follow the this link to the Wolfram Notebook where the various Elementary Cellular Automata Rules are generated.

Summary

Playing with cellular automat rules seems like an interesting game to play, plus doing it using WolframAlpha language is a piece of cake.

Better understanding with Optimization for Machine Learning

Long awaited book from Machine Learning Mastery

Recently, I’ve been reading the new Optimization for Machine Learning book from the Machine Learning Mastery written by Jason Brownlee. It just so happened that I read it fully from start to end, since I was one of the technical reviewers of the book. The book was interesting to read thanks to a number of ingredients.

As always Jason was able to write an engaging book with practical advice that can be actioned right away using open source software on Linux, Windows or MacOS. Apart from this the book has just enough clearly explained theoretical material so that even beginning machine learning practitioners can play with optimization algorithms described in the book.

What I liked and what surprised me in the book

Personally, I think it was while reading and working with this book, that I truly understood what an optimizations is. How it is used in machine learning. What is an optimization algorithm, like gradient descent and how to implement one from scratch. I also very much enjoyed the chapter about Global Optimization with various types of Evolution Algorithms. What was funny, that about two weeks after I finished reading the book I came across Donald Hoffman’s The Interface Theory of Perception with relation to consciousness which is based on The Theory of Evolution by Natural Selection. For example, one of his papers written with colleagues namely Does evolution favor true perception? provides an example of Genetic Algorithm (GA) which very much resembles the GA in Chapter 17 of the book. It is highly recommended reading for anyone interested in how consciousness arises in the mind. By the way, does it?

Overall

The Optimization for Machine Learning book is what you come to expect from Machine Learning Mastery books. It’s interesting, it’s practical and it makes you understand what is that you are doing in Machine Learning. As always, each chapter has extensive references to tutorials, technical papers and books on machine learning. So don’t wait and start reading it, maybe you’ll come up with a new theory of how consciousness emerges in the mind.

References

Donald D. Hoffman, Manish Singh, Justin Mark, “Does evolution favor true perceptions?”, Proceedings Volume 8651, Human Vision and Electronic Imaging XVIII; 865104 (2013)

Playing with the 3D Donut-shaped C code in JavaScript

Background

Having seen a short YouTube video by Lex Fridman about Donut-shaped C code that generates a 3D spinning donut where in comments he encouraged to look at the code and play with I did just that.

But before this, I went to the Donut math: how donut.c works link where the author of that code Andy Sloane described how he came from geometry and math to implementation of the donut in C.

The Andy Sloane’s tutorial has two visualizations that you can launch and also the JavaScript implementation of the donut. One visualization is of ASCII donut while another one uses <canvas>: The Graphics Canvas element to create a visualization.

Playing with the code

The easiest way to play with the 3D spinning donut in JavaScript is to use JSFiddle online editor. When the editor is opened you see four main areas, just like in almost any other JS editor, which are HTML, CSS, JavaScript and Result.

To be able to start playing with donut code like crazy we need to do a number of things.

First

First, there is a need to create a basic HTML page with a number of buttons, a <pre> tag to store ASCII generated donut and a <canvas> tag to be able to show another type of donut animation. To do this just copy and paste into HTML area of JSFiddle editor the code below

<html>
  <body>
    <button onclick="anim1();">toggle ASCII animation</button>
    <button onclick="anim2();">toggle canvas animation</button>
    <pre id="d" style="background-color:#000; color:#ccc; font-size: 10pt;"></pre>
    <canvas id="canvasdonut" width="300" height="240">
    </canvas>
  </body>
</html>

Second

Second, there is a need to copy and past JS code from Andy’s page or copy and paste the code below into JS area of the JSFiddle editor

(function() {
var _onload = function() {
  var pretag = document.getElementById('d');
  var canvastag = document.getElementById('canvasdonut');

  var tmr1 = undefined, tmr2 = undefined;
  var A=1, B=1;

  // This is copied, pasted, reformatted, and ported directly from my original
  // donut.c code
  var asciiframe=function() {
    var b=[];
    var z=[];
    A += 0.07;
    B += 0.03;
    var cA=Math.cos(A), sA=Math.sin(A),
        cB=Math.cos(B), sB=Math.sin(B);
    for(var k=0;k<1760;k++) {
      b[k]=k%80 == 79 ? "\n" : " ";
      z[k]=0;
    }
    for(var j=0;j<6.28;j+=0.07) { // j <=> theta
      var ct=Math.cos(j),st=Math.sin(j);
      for(i=0;i<6.28;i+=0.02) {   // i <=> phi
        var sp=Math.sin(i),cp=Math.cos(i),
            h=ct+2, // R1 + R2*cos(theta)
            D=1/(sp*h*sA+st*cA+5), // this is 1/z
            t=sp*h*cA-st*sA; // this is a clever factoring of some of the terms in x' and y'

        var x=0|(40+30*D*(cp*h*cB-t*sB)),
            y=0|(12+15*D*(cp*h*sB+t*cB)),
            o=x+80*y,
            N=0|(8*((st*sA-sp*ct*cA)*cB-sp*ct*sA-st*cA-cp*ct*sB));
        if(y<22 && y>=0 && x>=0 && x<79 && D>z[o])
        {
          z[o]=D;
          b[o]=".,-~:;=!*#$@"[N>0?N:0];
        }
      }
    }
    pretag.innerHTML = b.join("");
  };

  window.anim1 = function() {
    if(tmr1 === undefined) {
      tmr1 = setInterval(asciiframe, 50);
    } else {
      clearInterval(tmr1);
      tmr1 = undefined;
    }
  };

  // This is a reimplementation according to my math derivation on the page
  var R1 = 1;
  var R2 = 2;
  var K1 = 150;
  var K2 = 5;
  var canvasframe=function() {
    var ctx = canvastag.getContext('2d');
    ctx.fillStyle ='#000';
    ctx.fillRect(0, 0, ctx.canvas.width, ctx.canvas.height);

    if(tmr1 === undefined) { // only update A and B if the first animation isn't doing it already
      A += 0.07;
      B += 0.03;
    }
    // precompute cosines and sines of A, B, theta, phi, same as before
    var cA=Math.cos(A), sA=Math.sin(A),
        cB=Math.cos(B), sB=Math.sin(B);
    for(var j=0;j<6.28;j+=0.3) { // j <=> theta
      var ct=Math.cos(j),st=Math.sin(j); // cosine theta, sine theta
      for(i=0;i<6.28;i+=0.1) {   // i <=> phi
        var sp=Math.sin(i),cp=Math.cos(i); // cosine phi, sine phi
        var ox = R2 + R1*ct, // object x, y = (R2,0,0) + (R1 cos theta, R1 sin theta, 0)
            oy = R1*st;

        var x = ox*(cB*cp + sA*sB*sp) - oy*cA*sB; // final 3D x coordinate
        var y = ox*(sB*cp - sA*cB*sp) + oy*cA*cB; // final 3D y
        var ooz = 1/(K2 + cA*ox*sp + sA*oy); // one over z
        var xp=(150+K1*ooz*x); // x' = screen space coordinate, translated and scaled to fit our 320x240 canvas element
        var yp=(120-K1*ooz*y); // y' (it's negative here because in our output, positive y goes down but in our 3D space, positive y goes up)
        // luminance, scaled back to 0 to 1
        var L=0.7*(cp*ct*sB - cA*ct*sp - sA*st + cB*(cA*st - ct*sA*sp));
        if(L > 0) {
          ctx.fillStyle = 'rgba(255,255,255,'+L+')';
          ctx.fillRect(xp, yp, 1.5, 1.5);
        }
      }
    }
  }


  window.anim2 = function() {
    if(tmr2 === undefined) {
      tmr2 = setInterval(canvasframe, 50);
    } else {
      clearInterval(tmr2);
      tmr2 = undefined;
    }
  };

  asciiframe();
  canvasframe();
}

if(document.all)
  window.attachEvent('onload',_onload);
else
  window.addEventListener("load",_onload,false);
})();

Third

After HTML and JavaScript areas were populated click on the Run button (as indicated by me with number 1) in the screenshot below and you should see in the Result area on the right two buttons and two donuts (indicated with number 2).

When each button is clicked relevant animation is turned on. Both of them could run in parallel.

This is how it looks like in real-time

Playground

If you want understand the math of how it’s done then first read the explanation by Andy Sloane here. If you want jump right into messing around with the code then stay here.

Need for speed

To change the speed of the animations Ctrl + F in the JSFiddle and search for setInterval function

tmr1 = setInterval(asciiframe, 50);

tmr2 = setInterval(canvasframe, 50);

The second argument controls the speed of rotation of the donut. Increasing it makes it rotate faster and vice versa.

Paint it black

To change the background color of the donut created with the <canvas> animation search for ctx.fillStyle =’#000′;

ctx.fillStyle='#000'; //this is currently black

To change the color of the donut created with the <canvas> animation search for ctx.fillStyle = ‘rgba(255,255,255,’+L+’)’;

ctx.fillStyle = 'rgba(255,255,255,'+L+')'; // update any of the first three arguments which stand for Red, Green, Black in RGB.

See you

There are plenty other things you can try with this code. So why are you waiting? Just do it!

Salesforce Trailhead: An interesting approach to learning with inconclusive outcomes

What’s new?

Recently, I have changed jobs and in my new position I use Salesforce CRM platform. In comparison to my previous positions to become a productive developer in this area there is a very different approach to learning.

First of all, Salesforce created the Trailhead site that contains a large number of e-learning courses, which are more like tutorials that supposed to teach certain practical aspect of the Salesforce platform. These tutorials are called Trails which in turn consist of smaller Modules, which consist of even smaller Units. The units are small and don’t take a lot of time to go through.

To engage people interested in learning Salesforce, accomplishing units, modules and trails gives you points and badges. There are two additional types of activities that trailhead consist of which are Projects and Superbadges. These two are more hands-on oriented with Superbadges being a kind of real taste of what it’s like to work with production type of Salesforce CRM platform. Last but not least is a Trailmix which is an option to compose a freestyle collection of Superbadges, Trails, Projects or Modules in one bundle.

Overall, the structure of the Trailhead looks something like this

  • Trailhead
    • Hands-on learning
      • Suberbadge
      • Project
        • Units
    • Trail
      • Modules
        • Units
    • Module
      • Units
    • Trailmix
      • Superbadge
      • Projects
      • Trails
      • Modules
        • Units
Trailmix creation wizard

Some food for thoughts

After attempting and finishing each type of the e-learning in Trailhead I have some thoughts for improvements to this approach.

First of all, the e-learning concept is fresh and works good. It allows one to learn with his/her own pace. In addition, the content quality is good and assignments can be carried out in the free instances of Salesforce CRM that Salesforce provides a learner for free.

Second, the points and badges are really creating, at least in my opinion, a contest feeling where one competes with oneself.

After praising the learning platform comes my harsh criticism.

  1. There is no time stamp of when and also by whom the content was created. I deem this essential since I want to know is the content out of date, can I trust and rely on it. Also, it’s good to give a credit to creator of the content.
  2. There is no small amount of modules that have too much wording in them which is kind of repetitive and takes valuable time to read.
  3. The Modules present content in such a manner that doing it feels like being a machine, just type what they say as a dummy, and then by some magic the platform validates what’s done without providing too much useful feedback if something went wrong. This is especially frustrating while doing Superbadges. It’s easy to check that hundreds of novice Salesforce developers were daunted by the unintelligent feedback on the superbadge steps verification.
  4. In addition, it feels like doing modules is useless in comparison to doing a superbadge. Which means modules are only good as part of superbadges.
  5. But even superbadge doesn’t represent a real production Salesforce CRM environment and is a vanilla version of it, lacking crucial details, that make it or break it in the world of software development.

What can be done to improve the drawbacks?

  1. It would be nice for Modules and Projects to have an overview of how the content is used in a real life Salesforce development, by providing real use cases, even partially, without resorting to some kind of unreal companies with funny names.
  2. Superbadges should also be more production oriented with good and intelligent feedback or explanation of how one can debug the Salesforce CRM environment to understands what’s wrong with the implementation.
  3. It would be nice to try to incorporate the Trails, Modules etc. as part of the Salesforce CRM platform itself. This could assist in better understanding of how to work the CRM tool efficiently.
  4. The points and badges systems seems fine, but it’s possible to collect points without really understanding what the content means which defeats the point of having points altogether.

All in all

Trailhead is an interesting and engaging platform to learn Salesforce, but there are things that could and should be improved to make things better for the novice and seasoned Salesforce developers, admins etc.

The Fabric of Reality : 24 years later

The Fabric Of Reality, the first book by David Deutsch, was written back in 1997. It have been twenty four years since then and it is interesting to see how the book feels to be read in 2021. Yes, you are right 24 years has passed since then. Even though this was the first book David Deutsch wrote, the first book I read was his second. It was The Beginning of Infinity that I read and found it very insightful that caused me to check other books David Deutsch wrote.

The Fabric of Reality describes four strands:

the quantum physics of the multiverse, Popperian epistemology, the Darwin-Dawkins theory of evolution and a strengthened version of Turing’s theory of universal computation.

The Fabric of Reality, p. 366

It provides a unified approach of how the world could be explained and apprehended. The book uses the Popperian explanation based approach to scientific understanding of the world. The first chapters of the book provide a reader with a gentle introduction why the Inductivism is a dead end as a scientific approach and then transitions to showing the benefits of using explanation based view of scientific discovery.

Since, I first read The Beginning of Infinity which was written in 2011 it was nice to know that it builds on the previous book and expands on some of its topics, literary, that science is about providing explanations to why things are the way they are, instead of claiming that science is about inferring theories from data observed in experiments.

In my opinion, two of the more interesting parts were about the objective existence of the multiverse, which is the only feasible explanation of the interference of particles in two slit experiment, and the universal image generator and universal virtual-reality generator. Back in 1997 computers were quite slow in comparison to what we got nowadays. Graphical Processing Units (GPU) as we know them now were non-existent, but nevertheless David Deutsch described his thoughts on the subject of virtual realty in such a way that it is still refreshing to read it when Oculus Rift – VR Headset and Microsoft HoloLense are here.

David Deutsch’s take on that mathematics is not some abstract subject detached from reality, but to the contrary a filed of study that is about physically existing entities at first sounds daring. But if you think about it you’ll see that we and mathematicians live in a physical world, and think using physically existing brains that are responsible for us to have thoughts and intuitions about mathematical objects, and imagination in general.

The book is not that easy to read, especially the chapters about spacetime and time travel, which were quite convoluted at times. Nevertheless, the book is worth reading, since it provides ample food for thoughts and have some daring unification of theories that on the surface seem not connected.

If you follow David Deutsch’s activities you could have known that some theories described in the book made it into Constructor Theory that David Deutsch and Chiara Marletto developing for about a decade. Particularly, the chapter about The Nature of Mathematics talks about a proof being a physical process or a type of computation.

Constructor theory expresses physical laws exclusively in terms of what physical transformations, or tasks, are possible versus which are impossible, and why. By allowing such counterfactual statements into fundamental physics, it allows new physical laws to be expressed, for instance those of the constructor theory of information.

Wikipedia

All in all, The Fabric of Realty book still feels like a contemporary book. Its content is still fresh and worth reading. The book is quite independent from its successor The Beginning of Infinity, but both are sources for interesting and insightful ideas and worth your time.

How to Push Local Notification With React Native

This post is written by my good friend Aviad Holy who’s a team leader at Checkmarx and an Android enthusiast.

Installation and linking

Prerequisites

To see React Native live without installing anything check out Snack.

With my current setup (Windows 10 64 bit and Android phone)

  • I installed all prerequisites above
  • Started development server
C:\Users\xyz\AppData\Roaming>cd AwesomeProject

C:\Users\xyz\AppData\Roaming\AwesomeProject>yarn start
yarn run v1.22.10
  • Scanned QR Code shown in the development server
  • And I saw app started on my Android phone

Now you’re ready to follow Aviad’s tutorial below

I was looking for a simple solution to generate a local push notification in one of my projects,  when I came across this wonderful package that does exactly what is need and suitable for both iOS and Android, https://github.com/zo0r/react-native-push-notification.

The package has pretty good documentation, with only minor things missing to make it work straightforward. In the following guide I will present the configuration required and a suggested implementation to get you start pushing notifications locally. 

This guide targets Android since I encounter a lot of questions around it.

  • pending on your requests a dedicated guide for ios may be published as well.

Installation and linking, the short story.

  • yarn add react-native-push-notification
  • android/build.gradle
ext {
        buildToolsVersion = "29.0.3"
        minSdkVersion = 21
        compileSdkVersion = 29
        targetSdkVersion = 29
        ndkVersion = "20.1.5948944"
        googlePlayServicesVersion = "+" // default: "+"
        firebaseMessagingVersion = "+" // default: "+"
        supportLibVersion = "23.1.1" // default: 23.1.1
    }
  • android/app/src/main/AndroidManifest.xml
<span class="has-inline-color has-black-color">...
<uses-permission android:name="android.permission.VIBRATE" />
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
...
<application
...>
<meta-data  android:name="com.dieam.reactnativepushnotification.notification_foreground"
    android:value="false"/>
      <meta-data  android:name="com.dieam.reactnativepushnotification.notification_color"
          android:resource="@color/white"/>
      <receiver android:name="com.dieam.reactnativepushnotification.modules.RNPushNotificationActions" />
      <receiver android:name="com.dieam.reactnativepushnotification.modules.RNPushNotificationPublisher" />
      <receiver android:name="com.dieam.reactnativepushnotification.modules.RNPushNotificationBootEventReceiver">
        <intent-filter>
          <action android:name="android.intent.action.BOOT_COMPLETED" />
          <action android:name="android.intent.action.QUICKBOOT_POWERON" />
          <action android:name="com.htc.intent.action.QUICKBOOT_POWERON"/>
        </intent-filter>
      </receiver>
...
</application></span>


  • create /app/src/main/res/values/colors.xml
<span class="has-inline-color has-black-color"><resources>
    <color name='white'>#FFF</color>
</resources></span>


  • android/settings.gradle
include ':react-native-push-notification'
project(':react-native-push-notification').projectDir = file('../node_modules/react-native-push-notification/android')
  • android/app/build.gradle
dependencies {
...
    implementation project(':react-native-push-notification')
...
}

Usage

  • create a new file src/handlers/notificationsInit.js to initialize our push notification

Pay attention that for Android, creating a notification channel and setting the request permission as  “iOS only” is a must, as presented in the following example.

<span class="has-inline-color has-black-color">import PushNotification from 'react-native-push-notification';
import { Platform } from 'react-native';
 
export const notificationsInit = () => {
    PushNotification.createChannel({
        channelId: 'channel-id-1',
        channelName: 'channel-name-1',
        playSound: true,
        soundName: 'default',
        importance: 4,
        vibrate: true,
    }, (created) => colnsloe.log(`createChannel returned '${created}'`)
    );
    PushNotification.configure({
        onRegister: function (token) {
            console.log('TOKEN:', token);
        },
        onNotification: function (notification) {
            console.log('NOTIFICATION:', notification);
        },
        permissions: {
            alert: true,
            badge: true,
            sound: true,
        },
        requestPermissions: Platform.OS === 'ios',
        popInitialNotification: true,
    });
}</span>


  • create a new file src/handlers/notifications.js
<span class="has-inline-color has-black-color">import PushNotification from 'react-native-push-notification';
 
export const showNotification = (title, message) => {
    PushNotification.localNotification({
        channelId: 'channel-id-1',
        title: title,
        message: message,
    })
}
export const showScheduleNotification = (title, message) => {
    PushNotification.localNotificationSchedule({
        channelId: 'channel-id-1',
        title: title,
        message: message,
        date: new Date(Date.now() + 3 * 1000),
        allowWhileIdle: true, 
    })
}
export const handleNotificationCancel = () => {
    PushNotification.cancelAllLocalNotifications();
}
</span>

  • Import and initialize notificationsInit in App.js
<span class="has-inline-color has-black-color">import React from 'react';
import { View } from 'react-native';
import { notificationsInit } from './src/handlers/notificationsInit';
 
const App = () => {
 
  notificationsInit;
 
  return (
      <View>
      </View>
  );
};
 
export default App;</span>


  • Now, lets display the notification
  • create a new file src/components/TestNotifications.js
<span class="has-inline-color has-black-color">import React from 'react';
import { View, TouchableOpacity, StyleSheet, Text } from 'react-native';
import {
    showNotification,
    showScheduleNotification,
    handleNotificationCancel
} from '../handlers/notifications';
 
export default class TestNotifications extends React.Component {
 
    onTriggerPressHandle = () => {
        showNotification('Simple notification', 'simple notification triggered, nice work');
        console.log('simple notification triggered');
    }
 
    onSchedulePressHandle = () => {
        console.log('schedule notification triggered');
        showScheduleNotification('Schedualed notification', 'Schedualed notification triggered, nice work');
    }
 
    onCancelHandle = () => {
        handleNotificationCancel();
        console.log('cancel notification triggered');
    }
 
    render() {
        return (
            <View>
                <Text style={styles.title}>Click to try</Text>
                <TouchableOpacity
                    style={styles.button}
                    onPress={this.onTriggerPressHandle}>
                    <Text style={styles.text}>Simple notification</Text>
                </TouchableOpacity>
                <TouchableOpacity
                    style={styles.button}
                    onPress={this.onSchedulePressHandle}>
                    <Text style={styles.text}>{'--Scheduled notification--\nFire in 3 secondes'}</Text>
                </TouchableOpacity>
                <TouchableOpacity
                    style={[styles.button, {backgroundColor: 'red'}]}
                    onPress={this.onCancelHandle}>
                    <Text style={styles.text}>Cancel all notification</Text>
                </TouchableOpacity>
            </View>
        );
    }
}
 
const styles = StyleSheet.create({
    button: {
        backgroundColor: 'dodgerblue',
        height: 80,
        borderRadius: 10,
        margin: 20,
        justifyContent: 'center'
    },
    text: {
        color: 'white',
        textAlign: 'center',
        fontSize: 20,
    },
    title: {
        backgroundColor:'dimgrey',
        color: 'white',</span>
        <span class="has-inline-color has-black-color">textAlign: 'center',
        textAlignVertical: 'center',
        fontSize: 30,
        height: 100,
        marginBottom: 20,
    }
});</span>


  • import TestNotifications component to App.js
<span class="has-inline-color has-black-color">import React from 'react';
import TestNotifications from './src/components/TestNotifications';
import { View } from 'react-native';
import { notificationsInit } from './src/handlers/notificationsInit';
 
const App = () => {
 
  notificationsInit;
 
  return (
      <View>
        <TestNotifications />
      </View>
  );
};
 
export default App;</span>


Try out the buttons to trigger the notifications

Feel free to clone and play with this project sample

https://github.com/aviadh314/RN-local-push-notification.git

Java Code Geeks
Web Code Geeks

Books About Space. We Have A Liftoff!

Photo by SpaceX on Unsplash

This post continues the series of posts describing books I read end-to-end and classified in accordance with some criteria. This time we are talking about books on space and space exploration. You may also check related posts: this, this, this, and this, I wrote previously.

Aviation Books Classified

As I mentioned previously, this post is about organizing the books I read about aviation in a particular structure that could be useful to other readers. This post is based partially on the post I wrote about the origins of Stealth technology and the post on aviation related books in general. In short, my classification is about civil and military aviation with some sub-categories inside each branch of aviation.

Aviation

  • Civil Aviation
    • Biographies of plane engineers
      • 747 by Joe Sutter. This book could be of interest to people who not only want to learn about the 747, but also want to know who developed it, why and how it happened. Joe Sutter produced an interesting nerative that is fun to read.
    • Biographies of jet engine engineers
      • The Power to Fly: An Engineer’s Life by Brian H. Rowe. This book provides you with an information of how jet engines were developed in General Electric Engines and also provides you with author’s personal advice on engineering and management.
      • Herman the German: Just Lucky I Guess by Gerhard Neumann. While I read the book by Brian H. Rowe he mentioned that his boss at GE Aviation Engines was Gerhard Neumann who was quite a personality. I was curious so I bought this book. It was very adventurous reading to say the least. It seems like Gerhard Neumann had the most adventurous life of any person on earth. Surely, more adventurous, than Indiana Jones could ever dream of.
  • Military Aviation
    • Jet Fighter Planes
      • Hornet: The inside Story of The F/A-18 by Orr Kelly. This books provides many details of how F/A-18 was conceived, designed and developed. I was very impressed with the book, taking into consideration, that at first I thought about F/A-18 as an ugly plane.
    • Biographies of military jet planes engineers
      • Kelly: More Than My Share of It All by Kelly Johnson. Well, I guess there is no need to introduce who Kelly Johnson was. And if there is a need to do this, then he’s the father of Skunk Works which brought you U-2, A-12, SR-71 and other Area 51 planes.
      • Skunk Works: A Personal Memoir of My Years of Lockheed by Ben Rich. This book is very exciting and it talks about F-117 design and development also touching on SR-71 and other planes developed by Skunk Works. Ben Rich started as a thermodynamics specialist of SR-71 in Kelly Johnson team, later to succeed him as Skunk Works director. By the way, his son Michael D. Rich is the CEO of RAND corporation.
    • Low Observable Technology aka Stealth

The Book Struggle Within

This is a story of struggle, love and hate, but it’s not a movie. Instead, it’s a post about my love-hate relationship with digital versus print books. I think readers who like reading both print and e-books could understand what I am talking about. There is a constant tension, even a fight, between each book type and the pros and cons they have. I personally tend to read print books, though when it’s dark and there is no good lighting available there is nothing like reading an e-book.

Well, that’s the main point, these two kinds of books are not contradictory, but could be viewed as a complementary solutions. Each type has its advantages and disadvantages, but when combining advantages of both print and e-books we got the best out of all worlds.

Print books advantages as I see them

As biological agents living in a physical world we tend to like things that we can touch, hold and feel. So it’s not a big surprise that physical print books are so appealing to us. The book having a good and colorful cover draws attention and has a seductive forces to it. You can take it, flip through it quickly. Check whether are there any good diagrams, or pictures. Jump to the end of the book to check how it ends. In addition, the books have a smell to them and their weight provides a reassurance that knowledge could be a real force in the world.

  • I value the most the flipping part and fast navigation through the print books.

Well what are the disadvantages?

Print books, being physical objects take a lot of space, which could be an issue and storing them requires a book shelf or shelves. If you happen to travel or simply wants to take a few books with you to read on the go, then you’d better be in a good physical shape and have a big suitcase, which is kind of problematic to say the least (I mean the suitcase).

Also, print books are usually cost more then their digital counterparts, so buying them isn’t cheap. But both digital and print books could be rented or borrowed in the library making them less expensive as a product.

With a print book you need a good lighting, good weather conditions, preferably without pouring rain, when you outside, and a table with a chair. Non of this is required for digital books, for example, when reading on a mobile phone.

E-books advantages as I see them

E-books are cost effective, take almost no physical space, except for the container where they reside as bytes in memory. Nowadays, they can be read on a dedicated devices, computers, mobile phones. The e-books themselves could be stored locally or read in the cloud. There are a number of good mobile phone applications and dedicated websites that provide a reader with conveniences of reading, searching, translating and highlighting the content of the digital books. When the time comes to move around, you can carry almost unlimited number of e-books, limited by the memory space you have on you device (or a remote server). All in all, the e-books sound like a clear winner in the print versus digital books fight.

  • I value the most reading in the dark, searching and translating capabilities.

But…

E-books disadvantages

Though, e-books could be read in complete darkness, it points out that the device that they are stored in requires electricity, hence a battery that should be charged. When the battery is empty good bye. Nowadays, reading a digital book requires downloading it from a cloud storage locally, which means there is a need in an internet connection, which too could be interrupted. In addition, since digital books are presented in strictly two dimensional format it is impossible to flip through them like could be done with a print book, and jumping back and forth quickly is also hardly possible, if at all. But searching them for a particular word or phrase, or translating content is a charm in comparison to print counterparts (strictly speaking it’s an advantage, ops). In addition, when you try reading and working with the content from a number of books in parallel (which happens to me) all you need is a regular table. To achieve the same feat with an e-book you need a big size monitor, and I mean really big.

Conclusion

Unless there will be invented a hybrid of a print and e-book, that would require almost no electricity (or would have a long lasting battery) and could be flipped in 3D space (say like a hologram), we are destined to use both approaches depending on circumstances where the reading process should take place.

  • One side note I forgot to mention, we have physical books (scrolls) that survived for thousands of years, but our electronic devices that store e-books definitely would not.

Infinite Powers to explain

This post continues a series of post were I provide my thoughts on books that I deem worth reading.

This time it is the Infinite Powers book by Steven Strogatz that takes the reader into a realm of taming infinity to grasp nature’s secrets. The title of the book ambiguously plays on a method of using power series to approximate curves and powers which such a method, when exercised skillfully, brought to humankind. The book artfully describes how deferential and integral calculus was developed from Archimedes efforts to measure quadrature of curves through Descartes and Fermat, culminating in calculus invented by Isaac Newton in England and Gottfried Wilhelm Leibniz in Germany working independently. Lots of examples are provided showing how calculus is essential in many of inventions that are an important part of the modern civilization, be it GPS navigation, microwave ovens or the development of effective treatments to viruses induced diseases.

The power of insight

What I liked about the book is how the author is capable of explaining mathematical concepts, that usually require a solid mathematical background, mostly using analogies and down to earth explanations. Though, what I also liked that a mathematically inclined readers were not ignored, since what could, possibly, explained using proper mathematical notation was described as such. It is difficult to appreciate the beauty of calculus without using the mathematical symbols standing for derivative (differentials) and integral, that are so familiar to many people. I should say any person who studied at school should be familiar with them, and if not, the book provides a gentle and very intuitive explanation of what derivative stands for and why it is required, the same goes for integral.

As an example of a good explanation, I want to emphasize a Pizza Proof that is used to find an area of a circle. Since I recalled the formula for it being A = pi * R2, it was very interesting to see how the Pizza Proof showed clearly that A = R*C/2, where R is a radius of a circle and C its length. I think since school time I was curious where the power of two came in the area formula that I remembered. So, using the Pizza Proof result and substituting the C in it with the known formula for the length of the circle which is C = pi * 2R (which derivation was also explained in the book ) we get A = pi * R2. It was a nice insight, first one of many that the book provided.

I also liked how the method used by Fermat to find the maximum value of a curve, using a smart approach of double intersection, provides a correct result similar to what using derivatives would give. Another example, that was also insightful showed how the concept of derivative and curve interpolation could be used to find patterns in the seasonal changes of day length compared to the rate of change of day length, which both could be approximated by a sinusoidal function with a quarter cycle shift (pi/4 phase shift).

One can’t explain math without using it

Importantly, the concept of derivative was developed and shown very clearly using proper mathematical notation which should be clear even to readers coming from non-mathematical background, since the explanations gradually and systematically build up from simple to more advanced, as a reader progresses through the book (which means that the book should be read continuously). Then the concept of integral is shown quite remarkably well and the two concepts combined to showcase the Fundamental Theorem of Calculus about the duality of derivatives and integrals.

As I always mention, this book passes the test of providing references to other resources on the subject, like original papers of Newton or The Archimedes Palimpsest, which I was unaware of before reading the book.

Summary

It could be that reading Infinite Powers would provide your with appreciation of how calculus is essential in our day to day life and understanding of the world around us. And, maybe, show why mathematics could be beautiful in its own way and also applicable and useful, which could be an unexpected revelation to some.

Other resources