10 programming languages that may change the direction of the IT industry __ programming language Frontiers

As a developer, we really need to learn so many new programming languages. The choices we have now are quite rich, with command languages, functional languages, object-oriented languages, dynamic languages, compiled languages, interpreted languages, and scripting languages, among other things. These programming languages, which are in the forefront of the industry, provide a unique analytical perspective for the future of software development work.

Do we really need so many new programming languages? There is no doubt that the choices currently being made by developers are quite rich. command-type languages, functional languages, object-oriented languages, dynamic languages, compiled language interpretive languages, and scripting languages and so on seem to have completely covered all the tasks we might face, and few professionals today have been able to understand all the languages.

However, the new language is still springing up at an alarming rate. Some are designed by students or enthusiasts in the form of personal projects, others from large it vendors. Even small and medium enterprises are unwilling to be weak and actively develop service terminology for the needs of their industries. Why are people so keen on this repetitive work?

The answer is simple, although the language at hand is already quite powerful in terms of functionality and versatility, there is still no single grammatical rule that can best cater to any real need. More importantly, the programming behavior itself is in constant development and change. The rise of multi-core CPUs, the heating up of cloud computing, high mobility and distributed architecture have all brought new technical challenges to developers. Adding the latest features, paradigms, and patterns to existing languages-especially the current language-can be more difficult than impossible. Sometimes it's the best solution to get a new set of languages straight.

So here, I'm going to take you through 10 kinds of programming languages that are in the forefront of the industry, each of which interprets the artistry of software development from a new perspective, solves specific problems with different characteristics, or makes up for the unique flaws of the current mainstream language. Some of them are already quite mature projects, while others are in the early stages of their own development. Some may be unfamiliar and obscure to everyone, but there is no doubt that they are likely to revolutionize the development industry in the future and revolutionize the development of programming tools in the years ahead--at least until the next generation of languages are available.

Experimental programming language first: Dart

JavaScript is tension pile to add basic interactivity to Web pages, but when Web applications reach thousands of of lines of code, the language's limitations will be exposed. That is why Google launched Dart, a language that also carries the ambition of Google to bring new standards to web programming.

Like JavaScript, Dart uses syntax and keywords similar to the C language. The most striking difference between dart and JavaScript, however, is that objects in the former explicitly point to classes and interfaces, which are quite similar to C + + and Java. Dart also allows programmers to selectively declare variables using a static type. Looking back at the designers ' ideas, they should have wanted dart to be as easy to learn, dynamic and smooth as JavaScript, so that developers would be able to spend less time writing code, and product maintenance would be more convenient, At the same time, the impact of small errors will be minimized.

We can't use dart to solve too many practical problems at the moment. The idea is to have the language run on both the client and the server (similar to node.js), but now the only way to get Dart code to run on the client is to convert it to JavaScript by compiling it. It doesn't even work correctly for every browser. However, since Dart is being released as a BSD Open-source license, any vendor that buys a Google version can build it on its own products at will. The only thing Google needs to do is convince the industry to accept a newborn in the programming field.

Experimental programming language second place: Ceylon

Gavin King does not admit that Ceylon, the language he created in Red Hat, bears the historical mission of "the Java Terminator". One of the most dazzling pages of King's experience is the praise he has earned as the creator of the Hibernate--java Object Relationship mapping framework. He likes Java, but he still thinks there's a lot of room for improvement in Java.

King's complaints about Java are focused on lengthy grammatical structures, which lack level-and high-end functionality and support for metaprogramming is fairly weak. Even more frustrating is the lack of declarative syntax for structured data definitions in Java, which in his words makes Java "inseparable from XML." "Ceylon's goal is to solve the above difficult diseases.

King and his team do not intend to start entirely from scratch. Ceylon virtual machines do not appear, and such features convert content to Java byte code through the Ceylon compiler, which runs in the JVM. But Ceylon will never stop at a compiler that simple. One of the big ambitions of the project is to create a new Ceylon SDK system to replace the Java SDK, citing King's assessment of the latter-bloated, clumsy, and never "properly adjusted to the times." ”

This is a daunting task, as Red Hat has not yet released any of its Ceylon tools to date. King says he expects to see a compiler in the year, but won't expect "100% Ceylon" software to come out in a short time.

Experimental programming language third place: go

Interpreters, virtual machines, and managed code are now rage. Do we really need another old language that is used to compile the target content into a local binary file? The team from Google's engineering team--the legendary figure at Robert Griesemer and Bell Labs, Ken Thompson, and Rob Pike--gave a positive answer.

Go is a general-purpose programming language and applies to a variety of job requirements, from application development to system programming. In this sense, it is closer to C or C + +, rather than Java or C #. But like the latter, the go includes a variety of modern features, including garbage collection, run-time mapping, and support for parallelism.

Equally important, go is designed to reduce the difficulty of programming. Its basic syntax is very similar to C language, but eliminates redundant syntax and boilerplate files, while simplifying the operation of common functions such as object definitions. The goal of the Go Project team is to create a language that has the same kind of code as a dynamic scripting language and to provide powerful functionality like a compiled language.

Go is still in the process of being created, and its language specification may still be changed. That is to say, we can now start to try to use it. Google has created a corresponding tool and compiler for it, and the documentation is also quite rich; for example, the effective go tutorial is a good starting point for everyone to learn about the difference between went and other early languages.

Experimental programming language-fourth: F #

Functional programming has been popular with both computer scientists and academia, but a purely functional language such as Lisp and Haskell is often considered impossible to use in software development in practical applications. For functional code, the most common complaint is that they are difficult to integrate with the library by code written in command languages such as C + + and Java.

Speaking of F # (pronounced "f=sharp"), this Microsoft-launched language is designed to be both functional and practical. Because F # is a primary language in the. NET common language runtime (CLR), it has access to all of the same libraries and features in other CLR languages, including C # and Visual Basic.

F # code is somewhat similar to OCaml, but it also has quite a few interesting features. For example, digital data in F # can be assigned to a unit of measurement, which in turn serves the scientific class. F # also provides the necessary theoretical support for functions such as asynchronous I/O, CPU parallelism, and GPU load sharing.

After a long gestation period in the Microsoft Research Center, F # is now finally available with visual Studio 20,101. Even better, Microsoft this time out of the common sense of the card, the F # compiler and code library through the Apache Open Source license in front of us, you can not only use this language, but also to introduce it to the Mac and Linux system (through the mono running tool).

Experimental language-fifth: Opa

Web development work is recognized as a complex and incomparable. Even the simplest Web application requires countless lines of code to be used interchangeably with multiple languages: HTML and JavaScript processing clients, Java or PHP should be server, SQL responsible database, and so on.

Opa actually does not intend to replace any one of these languages alone. Instead, it exists in the hope of simply wiping out a variety of scenarios at once by setting a new set of specifications for Web programming. In a OPA application, the client UI, server-side logic, and database I/O are all implemented by the same language-the OPA itself.

To accomplish this, OPA needs to integrate the client with the server-side framework. The OPA compiler determines whether a particular program should run on the client, server, or both, and the compiler will then output the code necessary to run it. For client-side programs, the compiler converts OPA code content into the appropriate JavaScript code, including Ajax calls.

Of course, such an integrated system of scale also hides some backstage institutions. OPA's operating environment bundles its Web servers with the database management system, which means that we cannot replace their locations with other independent alternatives. This can be a bit of a disappointment, but it's worth the effort to keep the standards meticulous and complete, and enable data-driven Web applications to be expressed in just dozens of lines of code. The OPA project is fully open source and currently supports 64-bit Linux and Mac OS x platforms, and more ports will be open as the work progresses.

Experimental programming language--sixth: Fantom

Whether we should consider Java and the when developing our own applications. NET's support. If you use Fantom to write code, then nothing to worry about, not even the switch platform. This is because Fantom is designed to take into account the portability of cross-platform features. The Fantom project includes not only compilers capable of outputting byte code for the JVM or. NET CLI, but also a set of abstract APIs that can hold Java and. NET interfaces, creating a set of additional portable tiers.

Fanrom's portability also has a further expansion plan. The current Fantom to JavaScript compiler is already available, and we can expect to see a variety of extension projects including LLVM compilers, parrot virtual machines, and iOS version objective-c.

But never take portability as the only raison fantom language. Although it is still essentially based on the C language, it is also fully improved on the original model. The Fantom language attempts to gain a neutral status in some controversial grammatical discussions, such as solidity and dynamics, or interfaces and classes. It not only increases the description of the data structure and the simplified description of the serialized object, but also includes the strong support to the function design and the parallelism creation work.

Fantom is an Open-source project based on the Academic free license version 3.0 and is now available on Windows and UNIX-class platforms, including Mac OS X.

Experimental programming language--seventh: Zimbu

Most programming languages borrow some functionality or syntax from other early languages. and Zimbu this copycat spirit to play to the extreme. As a moolenaar of the Vim text editor Bram, Zimbu's goal is to become a fast, grammatically concise language that adapts to porting requirements and facilitates reading, and ultimately enables application code from any graphical user interface to run in the target operating system kernel.

Because of its innate zimbu, the grammar is also quite unique, but at the same time it is rich in functionality. It uses expressions and operators similar to the C language, but uses its own set of keywords, data types, and block structure systems. In addition, it supports functions such as memory management, threads, and channels.

Portability has always been a key issue. Although Zimbu is a compiled language, its compiler outputs ANSI C code, which makes the file only available from a platform with a local C compiler.

Unfortunately, the Zimbu project is now in its infancy. While its compiler has been able to create some demo examples for itself and other programs, not all Zimbu valid code can run correctly. However, the expected functions are not perfect at present, some of them are only hastily set up, so I believe that as long as the time taken, these problems can be properly resolved. In addition, the language specification is likely to change over time, such as adding new keywords, types, and syntax when necessary. So there is no unified conclusion about the documents and other materials. However, if you are interested in this language, the initial tools have been published on the basis of the Apache license.

Experimental programming language--eighth: X10

Parallel processing is one of the unique ecological circles in the field of software development, but with the popularization of multi core CPU and distributed computing technology, Parallelization has become the main direction of future development. Unfortunately, today, the programming language is still not able to keep up with the pace of the times. This is why the IBM Research Center has painstakingly developed X10, a pragmatic language that aims to improve developer productivity, and hopes to improve development efficiency by "10 times times" on the existing basis.

X10 uses the partitioned Global address space (abbreviation) programming model to solve parallel class tasks. Code and data are separate units, located in one or more "spaces," which makes it easier to transform single-threaded byte code (individual space) into a single core or multiple core processor (multiple spaces) in a high-performance cluster.

X10 code is generally similar to Java; in fact, the X10 runtime environment can be applied directly to the JVM as a local executable and as a class file. The X10 compiler can output C + + or Java-type source code. Achieving direct interoperability With the Java language is the direction of the project.

For the moment, though, the language is still in the process of development, but it is quite mature. Its compilers and operating environments support a range of platforms, including Linux, Mac OS x, and Windows. Including eclipse based IDE and debugging tools are already published on the basis of the Eclipse Public License.

Experimental programming language--nineth: HaXe

Most languages can be used to write portable code. The C language compiler works on almost every CPU architecture, while Java byte code works in all the JVM-capable environments. But Haxe (pronounced "hex") can do more than portability. It is a cross-platform language that can accommodate a variety of different types of operating environments-including local binary interpreters and virtual machines.

Developers can use Haxe to write programs and then compile the results into object code, such as JavaScript, PHP, Flash/actionscript, or NEKOVM, and so on, while other output modules like C # and Java are still in the research and development phase. In addition to the core language, there is a haxe standard library as a complement, its target function is also complete, and the unique function of the target platform is equipped with a dedicated function library.

Haxe is syntactically similar to the C language, and the collection of functions is quite rich. Its main advantage is to evade the inherent defects of the target platform itself. Haxe, for example, has a rigorous categorization of JavaScript, which adds generic statements and type derivations based on ActionScript, and completely eliminates the grammatical design omissions and clutter of PHP language.

While still in the development phase, Haxe has become commercially operational under the impetus of its creator motion twin gaming studio, so we should look at it with a serious eye. It supports Linux, Mac OS x, and Windows platforms, and uses a combination of several open source classes to license the distribution pattern.

Experimental programming language--tenth: Chapel

In the field of High-performance computing, few companies have the limelight to cover Cray, so it's no surprise that Cray's original programming language chapel be able to make the list. This is a language designed primarily to take into account the actual needs of supercomputers and clusters.

Chapel is part of the Cray Company's Cascade program, which is ambitious, with some of its planned funding being provided by the U.S. Defense Department's Advanced Research Projects Agency, or DARPA. The objective of this paper is to extract the abstract parallel algorithm from the underlying hardware to improve the performance of the existing architectures and to make the parallel class programs more portable.

Chapel's grammar is derived from many sources. In addition to a few of our common mainstream language (such as C, C + + and Java), it also from such as Fortran and MATLAB, such as scientific programming language to learn a lot of conceptual content. Its parallel processing ability is closely related to ZPL and high performance Fortran to some extent, and other Cray early project is its learning goal.

One of the most compelling features of chapel is its "multiresolution programming" feature, which allows developers to introduce more abstract code into their applications and add more detail to the implementation to make the definition more explicit.

Chapel is still in the development phase. It is currently capable of running on top of Cray supercomputers and various high-performance clusters, and can be ported to most Unix-class systems, including Mac OS X and Windows systems with Cygwin installed. The language source code uses the BSD type open source license.

Original link: http://www.infoworld.com/d/application-development/10-programming-languages-could-shake-it-181548?page=0,0