未来有望干掉 Python 和 JavaScript 的编程语言

2020年1月8日 271点热度 0人点赞 0条评论

作者丨Richard Kenneth Eng

译者丨刘志勇

策划丨Tina

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）示例代码：

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

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

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

曼德勃罗分形图（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 = zr * zr    b = zi * zi    loop(n+1, re, im, a-b+re, 2*zr*zi+im, a+b)  endend
Mandelbrot.set

Golang

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

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

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

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

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

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

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

曼德勃罗分形图（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)end
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)end
mandelbrot()

Kotlin

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

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

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

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

import java.awt.Graphicsimport java.awt.image.BufferedImageimport 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 * 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}

Lua

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

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

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

local maxIterations = 250local minX, maxX, minY, maxY = -2.5, 2.5, -2.5, 2.5local miX, mxX, miY, mxYfunction remap( x, t1, t2, s1, s2 )    local f = ( x - t1 ) / ( t2 - t1 )    local g = f * ( s2 - s1 ) + s1    return g;endfunction drawMandelbrot()    local 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    endendfunction startFractal()    love.graphics.setCanvas( canvas ); love.graphics.clear()    love.graphics.setColor( 255, 255, 255 )    drawMandelbrot(); love.graphics.setCanvas()endfunction love.load()    wid, hei = love.graphics.getWidth(), love.graphics.getHeight()    canvas = love.graphics.newCanvas( wid, hei )    startFractal()endfunction 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    endendfunction 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 = 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()    endendfunction love.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）示例代码：

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

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

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

分形树示例代码：

// Set up canvas for drawingvar canvas: HTMLCanvasElement = document.createElement('canvas')canvas.width = 600canvas.height = 500document.body.appendChild(canvas)var ctx: CanvasRenderingContext2D = canvas.getContext('2d')ctx.fillStyle = '#000'ctx.lineWidth = 1
// constantsconst degToRad: number = Math.PI / 180.0const 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 treectx.beginPath()drawTree(300, 500, -90, totalDepth)ctx.closePath()ctx.stroke()