原文标题:《未来有望干掉 Python 和 JavaScript 的编程语言》 原文来源: InfoQ 作者:Richard Kenneth 导读: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) end end
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.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 }
Lua
主要优点:Lua 是一种小巧、简单、快速、可嵌入、可移植的灵活的语言。
主要缺点:它已经被人们忽视了 26 年,现在会有什么改变呢?
曼德勃罗分形图(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; 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
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 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() WebAssembly
WebAssembly 是一匹黑马。在未来十年左右的时间里,它可能会衍生出一系列的语言,这些语言有望最终登上榜首。WebAssembly 只是一个编译目标,但没有理由说它不能扩展到 Web 领域以外的地方。至于哪些基于 WebAssembly 的语言可以登上榜首?现在谁也说不准。
作者介绍
Richard Kenneth Eng,博主。Smalltalk 布道师。退休的软件工程师。《复仇者联盟》粉丝。本文最初发表 Hacker Noon 博客,经原作者 Richard Kenneth Eng 授权,InfoQ 中文站翻译并分享。
原文链接:https://hackernoon.com/programming-languages-of-the-future-b61332kd 相关阅读:《Rust 是什么,有哪些知名区块链项目是用 Rust 开发的?》 来源链接:https://mp.weixin.qq.com/s/6XsH71CKaVikqnL6kVPqtg
区块律动 BlockBeats 提醒,根据银保监会等五部门于 2018 年 8 月发布《关于防范以「虚拟货币」「区块链」名义进行非法集资的风险提示》的文件,请广大公众理性看待区块链,不要盲目相信天花乱坠的承诺,树立正确的货币观念和投资理念,切实提高风险意识;对发现的违法犯罪线索,可积极向有关部门举报反映。
—-
编译者/作者:区块律动BlockBeat
玩币族申明:玩币族作为开放的资讯翻译/分享平台,所提供的所有资讯仅代表作者个人观点,与玩币族平台立场无关,且不构成任何投资理财建议。文章版权归原作者所有。
|