2020年编程语言展望

最新推荐文章于 2021-12-10 22:23:10 发布

dfsgwe1231

最新推荐文章于 2021-12-10 22:23:10 发布

阅读量313

点赞数

文章标签： javascript java python ViewUI

Python和JavaScript是当今最热门的两种编程语言。但是，它们不能永远保持在最高位置。最终，它们必须不受欢迎，就像所有语言一样。这很可能在未来十年左右的时间内发生。

哪些语言可以代替它们？这是我的挑战者名单...

镖

得益于Flutter框架和Google的热情，这种语言迅速流行起来。它与使Ruby如此流行的相同推动力相似：Rails框架。

而且，如果Google的“樱红色”风靡一时，Dart将会成为它的中心。

关键优势：它是一种比JavaScript更好的语言。

关键缺点：它与JavaScript及其成群的部落对抗。

Mandelbrot样本集：

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

关键优势：它使功能编程异常容易。并发性很棒。

关键缺点：您需要了解潜在的OTP基础，这可能是一项艰巨的任务。

Mandelbrot样本集：

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)
  end
end
 
Mandelbrot.set

高朗

谷歌支持的另一种语言Golang已证明是赢家，这得益于其迅捷的编译速度，轻松高效的并发性以及非凡的简便性。唯一缺少的是泛型，而且此功能还在路线图上。

关键优势：它非常简单，并发性很好。

关键缺点：（目前）缺少泛型。

Mandelbrot样本集：

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）的强项是对数学计算的出色支持。数学友好的语法非常适合数据科学家。如果有任何一种语言可以推翻Python，那么这绝对是竞争者。

关键优势：为科学家精心设计。

关键缺点：它与数据科学之王Python对抗。

Mandelbrot样本集：

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()

科特林

科特林是更好的Java。实际上，它实际上是Java的直接替代。 Google已经使其成为Android开发的一流语言。

关键优势：它是强大的Java。

关键缺点：与Java相比，它是一种很大的语言。

Mandelbrot样本集：

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 * 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
}

a

关键优势：Lua是一种小型，简单，快速，可嵌入，可移植且灵活的语言。

关键缺点：已经被忽略了26年。现在会发生什么变化？

Mandelbrot样本集：

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 ;
end
function 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
    end
end
function startFractal ( )
    love . graphics . setCanvas (  canvas  ); love . graphics . clear ( )
    love . graphics . setColor (  255 , 255 , 255  )
    drawMandelbrot ( ); love . graphics . setCanvas ( )
end
function love . load ( )
    wid , hei = love . graphics . getWidth ( ), love . graphics . getHeight ( )
    canvas = love . graphics . newCanvas (  wid, hei  )
    startFractal ( )
end
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
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 = 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
function love . draw ( )
    love . graphics . draw (  canvas  )
end

法罗

Pharo是Smalltalk的现代变体，Smalltalk是一种非常有生产力的面向对象语言。实际上，Smalltalk是OOP 的典范，并且已经启发了地球上几乎所有其他OOP语言。最后，没有一种语言能比Smalltalk更好地实现OOP。

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承诺编程会更安全。

关键优势：它有助于使软件更加可靠。

关键缺点：学习困难，借位检查器可能很难理解。

Mandelbrot样本集：

extern crate image;
extern crate num_complex;
 
use std::fs::File;
use num_complex::Complex;
 
fn main() {
    let max_iterations = 256 u16;
    let img_side = 800 u32;
    let cxmin = -2 f32;
    let cxmax = 1 f32;
    let cymin = -1.5 f32;
    let cymax = 1.5 f32;
    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 ( 0 f32, 0 f32);
 
        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是JavaScript…具有优势。它主要添加静态类型。与JavaScript的兼容性使其成为前端Web开发人员的最爱，因为他们已经了解JavaScript，并且几乎不需要更改其工作流程。

关键优势：它是JavaScript，因此JavaScript开发人员没有太大变化。

关键缺点：它仍然是JavaScript，因此您继承了它的所有包g。

分形树样本：

// 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
 
// constants
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()