Python 和 JavaScript 是两门非常有影响力的编程语言，二者都是我们在打造跨平台应用时会用到的主流语言。由于 Python 和 JavaScript 都是脚本语言，因此它们有很多共同的特性，都需要解释器来运行，都是动态类型，都支持自动内存管理，都可以调用 eval（）来执行脚本等等脚本语言所共有的特性。在过去这些年来，Python 和 JavaScript 占据着主导型地位，但有句话说得好，长江后浪推前浪，青出于蓝胜于蓝。如果将来有一天，Python 和 JavaScript 被打败赶下榜单，那这个挑战者会是谁呢？退休的软件工程师 Richard Kenneth Eng 为我们分享了他的看法，罗列了那些他认为有望打败 Python 和 JavaScript 的编程语言。

Python 和 JavaScript 是当今最热门的两种编程语言。但是，它们不可能永远位居榜首。最终，它们一定会失宠，就像所有的编程语言一样。这很可能在未来十年内就会发生。

哪些编程语言有望取代它们呢？下面就是我列出的挑战者名单。

Dart

由于 Flutter 框架和 Google 的认可，这门语言迅速流行起来。它与使 Ruby 如此流行的驱动力相似：Rails 框架。

如果 Google 的新操作系统 Fuchsia 取得成功的话，Dart 将会成为其中心。

主要优势：它是一种比 JavaScript 更优秀的编程语言。

主要缺点：它面对来自 JavaScript 及其迷惑的群体的对抗。

曼德勃罗分形图（Mandelbrot set）示例代码：

classComplex{
double_r,_i;

Complex(this._r,this._i);
doublegetr => _r;
doublegeti => _i;
StringtoString() =>"($r,$i)";

Complexoperator+(Complex other) =>newComplex(r+other.r,i+other.i);
Complexoperator*(Complex other) =>
newComplex(r*other.r-i*other.i,r*other.i+other.r*i);
doubleabs() => r*r+i*i;
}

voidmain() {
doublestart_x=-1.5;
doublestart_y=-1.0;
doublestep_x=0.03;
doublestep_y=0.1;

for(inty=0;y<20;y++) {
Stringline="";
for(intx=0;x<70;x++) {
Complex c=newComplex(start_x+step_x*x,start_y+step_y*y);
Complex z=newComplex(0.0,0.0);
for(inti=0;i<100;i++) {
z=z*(z)+c;
if(z.abs()>2) {
break;
}
}
line+=z.abs()>2?" ":"*";
}
print(line);
}
}

Elixir

Elixir 是 Erlang 的派生语言，具有改进的语法，以及与 Erlang 相同的、惊人的并发性支持。作为一种纯函数式语言，它很有可能将这一范式提升为主流。

主要优点：它使函数式编程变得异常简单。它非常适合并发性。

主要缺点：需要了解潜在的一次性可编程基础知识，这可能是一项艰巨的任务。

曼德勃罗分形图（Mandelbrot set）示例代码：

defmoduleMandelbrotdo
defsetdo
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,fny ->
im = minIm + stepY * y
Enum.map(0..xsize,fnx ->
re = minRe + stepX * x
62- loop(0, re, im, re, im, re*re+im*im)
end) |> IO.puts
end)
end

defploop(n, _, _, _, _, _)whenn>=30,do:n
defploop(n, _, _, _, _, v)whenv>4.0,do:n-1
defploop(n, re, im, zr, zi, _)do
a = zr * zr
b = zi * zi
loop(n+1, re, im, a-b+re,2*zr*zi+im, a+b)
end
end

Mandelbrot.set

Golang

另一种 Google 支持的语言 Golang，得益于其闪电般的编译速度、简单高效的并发性以及非凡的简单性，它被证明是赢家。唯一缺少的就是泛型，不过，这个特性已经在路线图上了。

主要优点：超级简单，对并发性支持非常好。

主要缺点：它（目前）缺少泛型。

曼德勃罗分形图（Mandelbrot set）示例代码：

packagemain

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

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

funcmandelbrot(acomplex128)float64{
i :=0
forz := a; cmplx.Abs(z) <2&& i < maxEsc; i++ {
z = z*z + a
}
returnfloat64(maxEsc-i) / maxEsc
}

funcmain(){
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)
forx :=0; x < width; x++ {
fory :=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")
iferr !=nil{
fmt.Println(err)
return
}
iferr = png.Encode(f, b); err !=nil{
fmt.Println(err)
}
iferr = f.Close(); err !=nil{
fmt.Println(err)
}
}

Julia

Julia 的优势在于它对数学计算的出色支持。数学友好的语法对数学家来说非常有用。如果有哪种语言可以推翻 Python，那么 Julia 肯定是一个竞争者。

主要优点：这门语言是为科学家精心设计的。

主要缺点：这门语言面临数据科学之王 Python 的挑战。

曼德勃罗分形图（Mandelbrot set）示例代码：

usingImages

@inlinefunctionhsv2rgb(h, s, v)
constc = v * s
constx = c * (1- abs(((h/60) %2) -1))
constm = v - c

constr,g,b =
ifh <60
(c, x,0)
elseifh <120
(x, c,0)
elseifh <180
(0, c, x)
elseifh <240
(0, x, c)
elseifh <300
(x,0, c)
else
(c,0, x)
end

(r + m), (b + m), (g + m)
end

functionmandelbrot()

constw, h =1000,1000

constzoom =0.5
constmoveX =0
constmoveY =0

constimg =Array{RGB{Float64}}(h, w)
constmaxIter =30

forxin1:w
foryin1:h
i = maxIter
constc =Complex(
(2*x - w) / (w * zoom) + moveX,
(2*y - h) / (h * zoom) + moveY
)
z = c
whileabs(z) <2&& (i -=1) >0
z = z^2+ c
end
constr,g,b = hsv2rgb(i / maxIter *360,1, i / maxIter)
img[y,x] = RGB{Float64}(r, g, b)
end
end

save("mandelbrot_set.png", img)
end

mandelbrot()

Kotlin

Kotlin 是更好的 Java。事实上，它实际上就是 Java 的一个可以立即使用的替代品。Google 已经将其打造成 Android 开发的一流语言。

主要优点：它是一种升级版的 Java。

主要缺点：它是一种非常庞大的语言，即使与 Java 相比也是如此。

曼德勃罗分形图（Mandelbrot set）示例代码：

importjava.awt.Graphics
importjava.awt.image.BufferedImage
importjavax.swing.JFrame

classMandelbrot:JFrame("Mandelbrot Set") {
companionobject{
privateconstvalMAX_ITER =570
privateconstvalZOOM =150.0
}

privatevalimg: BufferedImage

init{
setBounds(100,100,800,600)
isResizable =false
defaultCloseoperation = EXIT_ON_CLOSE
img = BufferedImage(width, height, BufferedImage.TYPE_INT_RGB)
for(yin0until height) {
for(xin0until width) {
varzx =0.0
varzy =0.0
valcX = (x -400) / ZOOM
valcY = (y -300) / ZOOM
variter = MAX_ITER
while(zx * zx + zy * zy <4.0&& iter >0) {
valtmp = zx * zx - zy * zy + cX
zy =2.0* zx * zy + cY
zx = tmp
iter--
}
img.setRGB(x, y, iter or (iter shl7))
}
}
}

overridefunpaint(g:Graphics){
g.drawImage(img,0,0,this)
}
}

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

Lua

主要优点：Lua 是一种小巧、简单、快速、可嵌入、可移植的灵活的语言。

主要缺点：它已经被人们忽视了 26 年，现在会有什么改变呢？

曼德勃罗分形图（Mandelbrot set）示例代码：

localmaxIterations =250
localminX, maxX, minY, maxY =-2.5,2.5,-2.5,2.5
localmiX, mxX, miY, mxY
functionremap( x, t1, t2, s1, s2 )
localf = ( x - t1 ) / ( t2 - t1 )
localg = f * ( s2 - s1 ) + s1
returng;
end
functiondrawMandelbrot()
localpts, a, as, za, b, bs, zb, cnt, clr = {}
forj =0, hei -1do
fori =0, wid -1do
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
ifmath.abs( a ) +math.abs( b ) >16thenbreakend
cnt = cnt +1
end
ifcnt == maxIterationsthenclr =0
elseclr = remap( cnt,0, maxIterations,0,255)
end
pts[1] = { i, j, clr, clr,0,255}
love.graphics.points( pts )
end
end
end
functionstartFractal()
love.graphics.setCanvas( canvas ); love.graphics.clear()
love.graphics.setColor(255,255,255)
drawMandelbrot(); love.graphics.setCanvas()
end
functionlove.load()
wid, hei = love.graphics.getWidth(), love.graphics.getHeight()
canvas = love.graphics.newCanvas( wid, hei )
startFractal()
end
functionlove.mousepressed( x, y, button, istouch )
ifbutton ==1then
startDrag =true; miX = x; miY = y
else
minX =-2.5; maxX =2.5; minY = minX; maxY = maxX
startFractal()
startDrag =false
end
end
functionlove.mousereleased( x, y, button, istouch )
ifstartDragthen
locall
ifx > miXthenmxX = x
elsel = x; mxX = miX; miX = l
end
ify > miYthenmxY = y
elsel = y; mxY = miY; miY = l
end
miX = 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
end
functionlove.draw()
love.graphics.draw( canvas )
end

Pharo

Pharo 是 Smalltalk 的现代变体，Smalltalk 是一种非常高效的面向对象编程语言。实际上，Smalltalk 是面向对象编程的典范，它几乎启发了地球上所有其他面向对象编程语言的灵感。最后，没有一种语言比 Smalltalk 更适合面向对象编程了。

Pharo 还是世界上最简单、最优雅的语言之一。 你可以在 15 分钟内学会 Smalltalk 的全部语法 ！

主要优点：它的工作效率非常高效，就像工作效率提高了 5 倍一样！

主要缺点：掌握这种语言，需要一种不同的编程思维。但人们往往害怕改变。

分形树示例代码：

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.
]
].

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

"Execute"

FractalTree new draw.

Rust

Rust 因其内存安全特性：借位检查器而得到了广泛的认可。这个特性实际上消除了所有与内存相关的编程错误。Rust 保证了编程的安全性。

主要优点：它有助于使软件更可靠。

主要缺点：这门语言很难学习，而且借位检查器可能也很难理解。

曼德勃罗分形图（Mandelbrot set）示例代码：

externcrateimage;
externcratenum_complex;

usestd::fs::File;
usenum_complex::Complex;

fnmain() {
letmax_iterations =256u16;
letimg_side =800u32;
letcxmin = -2f32;
letcxmax =1f32;
letcymin = -1.5f32;
letcymax =1.5f32;
letscalex = (cxmax - cxmin) / img_sideasf32;
letscaley = (cymax - cymin) / img_sideasf32;

// Create a new ImgBuf
letmutimgbuf = image::ImageBuffer::new(img_side, img_side);

// Calculate for each pixel
for(x, y, pixel)inimgbuf.enumerate_pixels_mut() {
letcx = cxmin + xasf32* scalex;
letcy = cymin + yasf32* scaley;

letc = Complex::new(cx, cy);
letmutz = Complex::new(0f32,0f32);

letmuti =0;
fortin0..max_iterations {
ifz.norm() >2.0{
break;
}
z = z * z + c;
i = t;
}

*pixel = image::Luma([iasu8]);
}

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

TypeScript

TypeScript 是 JavaScript……带来了好处。它主要是添加了静态类型。与 JavaScript 的兼容性使它成为前端 Web 开发人员的最爱，因为他们已经了解 JavaScript，而且几乎不需要改变他们的工作流程。

主要优点：它就是 JavaScript，因此对 JavaScript 开发人员来说没有什么太大的变化。

主要缺点：它仍然是 JavaScript，所以仍然继承了 JavaScript 的所有包袱。

分形树示例代码：

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

// constants
constdegToRad:number=Math.PI /180.0
consttotalDepth:number=9

/** Helper function that draws a line on the canvas */
functiondrawLine(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 */
functiondrawTree(x1:number, y1:number, angle:number, depth:number):void{
if(depth !==0) {
letx2:number= x1 + (Math.cos(angle * degToRad) * depth *10.0)
lety2: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 是一匹黑马。在未来十年左右的时间里，它可能会衍生出一系列的语言，这些语言有望最终登上榜首。WebAssembly 只是一个编译目标，但没有理由说它不能扩展到 Web 领域以外的地方。至于哪些基于 WebAssembly 的语言可以登上榜首？现在谁也说不准。

作者介绍：

Richard Kenneth Eng，博主。Smalltalk 布道师。退休的软件工程师。《复仇者联盟》粉丝。

原文链接：https://hackernoon.com/programming-languages-of-the-future-b61332kd

链接: https://fly63.com/article/detial/7187