Can blockchain popular programming languages GO, RUST, TypeScript, and WASM beat Python and JS?

Title: future programming languages that could kill Python and JavaScript
Source: InfoQ by Richard Kenneth

Takeaway:Python and JavaScript are two very powerful programming languages, both of which are mainstream languages that we use to build cross-platform applications. Since both Python and JavaScript are scripting languages, they share many features that require an interpreter to run, are dynamically typed, support automatic memory management, can call eval () to execute scripts, and so on. Over the years, Python and JavaScript have dominated, but there is an old saying that the last wave pushes the last. If one day Python and JavaScript are beaten off the list, who will be the challenger? Richard Kenneth Eng, a retired software engineer, shares his thoughts, listing the languages he thinks are on track to beat Python and JavaScript.

Python and JavaScript are the two most popular programming languages today. But they are unlikely to stay on top forever. Eventually, they will fall out of favor, as all programming languages do. This is likely to happen within the next decade.

What programming languages are expected to replace them? Here's my list of challengers.

Dart



Thanks to the Flutter framework and Google's endorsement, the language quickly became popular. It is similar to the driving force that makes Ruby so popular: the Rails framework.

If Fuchsia, Google's new operating system, is successful, Dart will become its center.

Main advantage: it's a better programming language than JavaScript.

The main drawback: it faces off against JavaScript and its confusing crowd.

Example code of Mandelbrot set:

class Complex {
double _r,_i;

Complex(this._r,this._i);
double get r => _r;
double get i => _i;
String toString() => "($r,$i)";

Complex operator +(Complex other) => new Complex(r+other.r,i+other.i);
Complex operator *(Complex other) =>
new Complex(r*other.r-i*other.i,r*other.i+other.r*i);
double abs() => r*r+i*i;
}

void main() {
double start_x=-1.5;
double start_y=-1.0;
double step_x=0.03;
double step_y=0.1;

for(int y=0;y<20;y++) {
String line="";
for(int x=0;x<70;x++) {
Complex c=new Complex(start_x+step_x*x,start_y+step_y*y);
Complex z=new Complex(0.0, 0.0);
for(int i=0;i<100;i++) {
Z = z * (z) + C;
if(z.abs()>2)
break;
}
}
line+=z.abs()>2 ? " " : "*";
}
print( line);
}
}

Elixir



Elixir is a derived language of Erlang with improved syntax and the same amazing concurrency support as Erlang. As a purely functional language, it has the potential to elevate this paradigm to the mainstream.

Main advantage: it makes functional programming extremely simple. It's perfect for concurrency.

Major downsides: the need to understand the underlying one-time programmable basics can be a daunting task.

Example code of Mandelbrot set:

defmodule Mandelbrot do
def set do
xsize = 59
ysize = 21
minIm = -1.0
maxIm = 1.0
minRe = -2.0
maxRe = 1.0
stepX = (maxRe - minRe) / xsize
stepY = (maxIm - minIm) / ysize
Enum.each(0..ysize, fn y ->
im = minIm + stepY * y
Enum.map(0..xsize, fn x ->
re = minRe + stepX * x
62 - loop(0, re, im, re, im, re*re+im*im)
end) |> IO.puts
end)
end

defp loop(n, _, _, _, _, _) when n>=30, do: n
defp loop(n, _, _, _, _, v) when v>4.0, do: n-1
defp loop(n, re, im, zr, zi, _) do
a szr * zr
b' zi * zi
loop(n+1, re, im, a-b+re, 2*zr*zi+im, a+b)
end
结束

Mandelbrot.set

Golang



Golang, another google-supported language, has proven to be a winner thanks to its lightning compilation speed, simple and efficient concurrency, and remarkable simplicity. The only thing missing is generics, however, which is already on the roadmap.

Main benefits: super simple, great concurrency support.

Main drawback: it lacks generics.

Example code of Mandelbrot set:

package main

import (
"fmt"
"image"
"image/color"
"image/draw"
"image/png"
"math/cmplx"
"You"
)

const (
maxEsc = 100
rMin = -2.
rMax = .5
iMin = -1.
iMax = 1.
width = 750
red = 230
green = 235
blue = 255
)

func mandelbrot(a complex128) float64 {
i := 0
for z := a; cmplx.Abs(z) < 2 && i < maxEsc; i++ {
z = z*z + a
}
return float64(maxEsc-i) / maxEsc
}

func main() {
scale := width / (rMax - rMin)
height := int(scale * (iMax - iMin))
bounds := image.Rect(0, 0, width, height)
b := image.NewNRGBA(bounds)
draw.Draw(b, bounds, image.NewUniform(color.Black), image.ZP, draw.Src)
for x := 0; x < width; x++ {
for y := 0; y < height; y++ {
fEsc :- mandelbrot(complex(
float64(x)/scale+rMin,
float64(y)/scale+iMin))
b.Set(x, y, color.NRGBA{uint8(red * fEsc),
uint8(green * fEsc), uint8(blue * fEsc), 255})

}
}
f, err := os.Create("mandelbrot.png")
if err != nil {
fmt.Println(err)
return
}
if err = png.Encode(f, b); err != nil {
fmt.Println(err)
}
if err = f.Close(); err != nil {
fmt.Println(err)
}
}

Julia



Julia's strength is her excellent support for mathematical calculations. Math-friendly grammar is very useful for mathematicians. If any language can defeat Python, Julia is definitely a contender.

Main advantages: the language was designed for scientists.

Major downside: the language faces the challenge of Python, the king of data science.

Example code of Mandelbrot set:

using Images

@inline function hsv2rgb(h, s, v)
const c = v * s
const x = c * (1 - abs(((h/60) % 2) - 1))
const m = v - c

const r,g,b
if h < 60
(c, x, 0)
elseif h < 120
(x, c, 0)
elseif h < 180
(0, C, x)
elseif h < 240
(0, X, c)
elseif h < 300
(x, 0, C)
else
(c, 0, X)
end

(r + m), (b + m), (g + m)
结束

function mandelbrot()

const w, h = 1000, 1000

const zoom = 0.5
const moveX = 0
const moveY = 0

const img = Array{RGB{Float64}}(h, w)
const maxIter = 30

for x in 1:w
for y in 1:h
i = maxIter
const c' Complex(
(2*x - w) / (w * zoom) + moveX,
(2*y - h) / (h * zoom) + moveY
)
z = c
while abs(z) < 2 && (i -= 1) > 0
z = z-2 + c
end
const r,g,b = hsv2rgb(i / maxIter * 360, 1, i / maxIter)
img[y,x] = RGB{Float64}(r, g, b)
end
end

save("mandelbrot_set.png", img)
结束

almond bread()

Kotlin

Kotlin is the better Java. In fact, it's actually a ready-to-use alternative to Java. Google has made it the premier language for Android development.

Main advantages: it is an updated version of Java.

The main drawback: it's a very large language, even compared to Java.

Example code of Mandelbrot set:

import java.awt.Graphics
import java.awt.image.BufferedImage
import javax.swing.JFrame

class Mandelbrot: JFrame("Mandelbrot Set")
companion object {
private const val MAX_ITER = 570
private const val ZOOM = 150.0
}

private val img: BufferedImage

init {
setBounds(100, 100, 800, 600)
isResizable = false
defaultCloseOperation = EXIT_ON_CLOSE
img = BufferedImage(width, height, BufferedImage.TYPE_INT_RGB)
for (y in 0 until height) {
for (x in 0 until width) {
var zx = 0.0
var zy = 0.0
val cX (x - 400) / ZOOM
val cY = (y - 300) / ZOOM
var iter = MAX_ITER
while (zx * zx + zy * zy < 4.0 && iter > 0)
val tmp - zx - zy - zy - cX
zy = 2.0 * zx * zy + cY
zx = tmp
iter--
}
img.setRGB(x, y, iter or (iter shl 7))
}
}
}

override fun paint(g: Graphics) {
g.drawImage(img, 0, 0, this)
}
}

fun main(args: Array<String>) {
Mandelbrot().isVisible = true
}

Moon



Main advantages: Lua is a small, simple, fast, embeddable, portable and flexible language.

The main drawback: it has been ignored for 26 years. What will change now?

Example code of Mandelbrot set:

local maxIterations = 250
local minX, maxX, minY, maxY = -2.5, 2.5, -2.5, 2.5
local miX, mxX, miY, mxY
function remap( x, t1, t2, s1, s2 )
local f = ( x - t1 ) / ( t2 - t1 )
local g = f * ( s2 - s1 ) + s1
return g;
结束
function drawMandelbrot()
place pts, a, as, za, b, bs, zb, cnt, clr = {}
for j = 0, hei - 1 do
for i = 0, wid - 1 do
a = remap( i, 0, wid, minX, maxX )
b = remap( j, 0, hei, minY, maxY )
cnt = 0; za = a; zb = b
while( cnt < maxIterations ) do
as = a * a - b * b; bs = 2 * a * b
a = za + as; b = zb + bs
if math.abs( a ) + math.abs( b ) > 16 then break end
cnt = cnt + 1
end
if cnt 'maxIterations then clr' 0
else clr = remap( cnt, 0, maxIterations, 0, 255 )
end
pts[1] = { i, j, clr, clr, 0, 255 }
love.graphics.points( pts )
end
end
结束
function startFractal()
love.graphics.setCanvas( canvas ); love.graphics.clear()
love.graphics.setColor( 255, 255, 255 )
drawMandelbrot(); love.graphics.setCanvas()
结束
function love.load()
wid, hei = love.graphics.getWidth(), love.graphics.getHeight()
canvas = love.graphics.newCanvas( wid, hei )
startFractal()
结束
function love.mousepressed( x, y, button, istouch )
if button == 1 then
startDrag = true; miX = x; miY = y
else
minX = -2.5; maxX = 2.5; minY = minX; maxY = maxX
startFractal()
startDrag = false
end
结束
function love.mousereleased( x, y, button, istouch )
if startDrag then
local l
if x > miX then mxX = x
else l = x; mxX = miX; miX = l
end
if y > miY then mxY = y
else l'y; mxY's miY; miY' l
end
miX s remap( miX, 0, wid, minX, maxX )
mxX - remap (mxX, 0, wid, minX, maxX)
miY = remap( miY, 0, hei, minY, maxY )
mxY = remap( mxY, 0, hei, minY, maxY )
minX = miX; maxX = mxX; minY = miY; maxY = mxY
startFractal()
end
结束
function love.draw()
love.graphics.draw( canvas )
结束

Pharo



Pharo is a modern variant of Smalltalk, a very efficient object-oriented programming language. In fact, Smalltalk is an example of object-oriented programming that has inspired almost every other object-oriented programming language on the planet. Finally, no language is better suited to object-oriented programming than Smalltalk.

Pharo is also one of the simplest and most elegant languages in the world. You can learn the full syntax of Smalltalk in 15 minutes!

Main advantages: it works very efficiently, as if the work efficiency increased by 5 times!

The main drawback: mastering the language requires a different programming mindset. But people are often afraid of change.

Sample fractal tree code:

Object subclass: #FractalTree
instanceVariableNames: ''
classVariableNames: ''
poolDictionaries: ''
category: 'RosettaCode'

"Methods for FractalTree class"

tree: aPoint length: aLength angle: anAngle
| p a |

(aLength > 10) ifTrue: [
p := Pen new.
p up.
p goto: aPoint.
p turn: anAngle.
p down.
5 timesRepeat: [
p go: aLength / 5.
p turn: 5.
].
a := anAngle - 30.
3 timesRepeat: [
self tree: p location length: aLength * 0.7 angle: a.
a := a + 30.
]
].

画
Display restoreAfter: [
Display fillWhite.
self tree: 700@700 length: 200 angle: 0.
]

"Execute"

FractalTree new draw.

Rust



Rust is widely recognized for its memory security feature: the borrow checker. This feature virtually eliminates all memory-related programming errors. Rust guarantees programming security.

Main advantages: it helps to make the software more reliable.

Major downsides: the language is difficult to learn, and borrowing checkers can be difficult to understand.

Example code of Mandelbrot set:

extern crate image;
extern crate num_complex;

use std::fs::File;
use num_complex::Complex;

fn main() {
let max_iterations = 256u16;
let img_side = 800u32;
let cxmin = -2f32;
let cxmax = 1f32;
let cymin = -1.5f32;
let cymax = 1.5f32;
let scalex = (cxmax - cxmin) / img_side as f32;
let scaley = (cymax - cymin) / img_side as f32;

// Create a new ImgBuf
let mut imgbuf = image::ImageBuffer::new(img_side, img_side);

// Calculate for each pixel
for (x, y, pixel) in imgbuf.enumerate_pixels_mut() {
let cx = cxmin + x as f32 * scalex;
let cy = cymin + y as f32 * scaley;

let c = Complex::new(cx, cy);
let mut z = Complex::new(0f32, 0f32);

let mut i = 0;
for t in 0..max_iterations {
if z.norm() > 2.0
break;
}
z = z * z + c;
i = t;
}

*pixel = image::Luma([i as u8]);
}

// Save image
let fout = &mut File::create("fractal.png").unwrap();
image::ImageLuma8(imgbuf).save(fout, image::PNG).unwrap();
}

TypeScript



TypeScript is JavaScript... Has brought benefits. It basically adds static types. Its compatibility with JavaScript makes it a favorite of front-end Web developers because they already know JavaScript and rarely need to change their workflow.

The main benefit: it's JavaScript, so it doesn't change much for JavaScript developers.

The main drawback: it's still JavaScript, so it still inherits all the baggage of JavaScript.

Sample fractal tree code:

// Set up canvas for drawing
var canvas: HTMLCanvasElement = document.createElement('canvas')
canvas.width = 600
canvas.height = 500
document.body.appendChild(canvas)
var ctx: CanvasRenderingContext2D = canvas.getContext('2d')
ctx.fillStyle = '#000'
ctx.lineWidth = 1

Constant
const degToRad: number = Math.PI / 180.0
const totalDepth: number = 9

/** Helper function that draws a line on the canvas */
function drawLine(x1: number, y1: number, x2: number, y2: number): void {
ctx.moveTo(x1, y1)
ctx.lineTo (x2, y2)
}

/** Draws a branch at the given point and angle and then calls itself twice */
function drawTree(x1: number, y1: number, angle: number, depth: number): void {
if (depth !== 0) {
let x2: number = x1 + (Math.cos(angle * degToRad) * depth * 10.0)
let y2: number = y1 + (Math.sin(angle * degToRad) * depth * 10.0)
drawLine(x1, y1, x2, y2)
drawTree(x2, y2, angle - 20, depth - 1)
drawTree(x2, y2, angle + 20, depth - 1)
}
}

// actual drawing of tree
ctx.beginPath()
drawTree(300, 500, -90, totalDepth)
ctx.closePath()
ctx.stroke()

WebAssembly



WebAssembly is a dark horse. In the next decade or so, it could spawn a host of languages that could eventually top the list. WebAssembly is just a compilation target, but there's no reason it can't be extended beyond the Web realm. As for which webassembly-based languages make it to the top of the list? Now no one knows.

The authors introduce

Richard Kenneth Eng is a blogger. Smalltalk evangelist. Retired software engineer. Avengers fans. This article was originally published on the Hacker Noon blog. It was translated and Shared by InfoQ with the authorization of the original author Richard Kenneth Eng.

Text link:https://hackernoon.com/programming-languages-of-the-future-b61332kd
Related reading:What is Rust and what are some well-known blockchain projects developed with Rust?
Source:https://mp.weixin.qq.com/s/6XsH71CKaVikqnL6kVPqtg

Welcome to join the official BlockBeats community:

Telegram Subscription Group: https://t.me/theblockbeats

Telegram Discussion Group: https://t.me/BlockBeats_App

Official Twitter Account: https://twitter.com/BlockBeatsAsia