13 programming languages defining the future of coding
1. R
At heart,
R
is a programming language, but it's more of a standard bearer for the
world's current obsession with using statistics to unlock patterns in
large blocks of data. R was designed by statisticians and scientists to
make their work easier. It comes with most standard functions used in
data analysis and many of the most useful statistical algorithms are
already implemented as freely distributed libraries. It's got most of
what data scientists need to do data-driven science.
Many people end up using R inside an IDE as a high-powered scratchpad for playing with data.
R Studio and
R Commander
are two popular front ends that let you load up your data and play with
it. They make it less of a compile-and-run language and more of an
interactive world in which to do your work.
Highlights: Clever expressions for selecting a subset of the data and analyzing it
Headaches: Aimed at desktops, not the world of big data where technologies like Hadoop rule.
2. Java 8
Java isn't a new language. It's often everyone's first language, thanks to its role as the
lingua franca for AP Computer Science. There are billions of JAR files floating around running the world.
But
Java 8
is a bit different. It comes with new features aimed at offering
functional techniques that can unlock the parallelism in your code. You
don't have to use them. You could stick with all the old Java because it
still works. But if you don't use it, you'll be missing the chance to
offer the Java virtual machine (JVM) even more structure for optimizing
the execution. You'll miss the chance to think functionally and write
cleaner, faster, and less buggy code.
Highlights: Lambda expressions and concurrent code
Headaches: A bolted-on feeling makes us want to jump in with both feet and use Scala (see below).
3. Swift
Apple
saw an opportunity when programming newbies complained about the
endless mess of writing in Objective C. So they introduced
Swift
and strongly implied that it would replace Objective C for writing for
the Mac or the iPhone. They recognized that creating header files and
juggling pointers was antiquated. Swift hides this information, making
it much more like writing in a modern language like Java or Python.
Finally, the language is doing all the scut work, just like the modern
code.
The language specification is broad. It's not just a
syntactic cleanup of Objective C. There are plenty of new features, so
many that they're hard to list. Some coders might even complain that
there's too much to learn, and Swift will make life more complicated for
teams who need to read each other's code. But let's not focus too much
on that. iPhone coders can now spin out code as quickly as others. They
can work with a cleaner syntax and let the language do the busy work.
Highlights: Dramatically cleaner syntax and less low-level juggling of pointers
Headaches: The backward compatibility requires thinking about bits and bytes occasionally.
4. Go
When
Google set out to build a new language to power its server farms, it
decided to build something simple by throwing out many of the more
clever ideas often found in other languages. They wanted to keep
everything, as one creator said, "simple enough to hold in one
programmer's head." There are no complex abstractions or clever
metaprogramming in
Go—just basic features specified in a straightforward syntax.
This
can make things easier for everyone on a team because no one has to
fret when someone else digs up a neat idea from the nether reaches of
the language specification.
Highlights: Just a clean, simple language for manipulating data.
Headaches: Sometimes a clever feature is needed.
5. CoffeeScript
Somewhere along the line, some JavaScript programmers
grew tired of typing all those semicolons and curly brackets. So they created
CoffeeScript,
a preprocessing tool that turns their syntactic shorthand back into
regular JavaScript. It's not as much a language as a way to save time
hitting all those semicolons and curly bracket keys.
Jokers may
claim that CoffeeScript is little more than a way to rest your right
hand's pinkie, but they're missing the point. Cleaner code is easier to
read, and we all benefit when we can parse the code quickly in our
brain. CoffeeScript makes it easier for everyone to understand the code,
and that benefits everyone.
Highlights: Cleaner code
Headaches: Sometimes those brackets make it easier to understand deeply nested code.
6. D
For
many programmers, there's nothing like the very clean, simple world of
C. The syntax is minimal and the structure maps cleanly to the CPU. Some
call it portable Assembly. Even for all these advantages, some C
programmers feel like they're missing out on the advantages built into
newer languages.
That's why
D
is being built. It's meant to update all the logical purity of C and
C++ while adding in modern conveniences such as memory management, type
inference, and bounds checking.
Highlights: Some of the most essential new features in languages.
Headaches: You trade some power away for the safety net.
7. Less.js
Just like CoffeeScript,
Less.js
is really just a preprocessor for your files, one that makes it easier
to create elaborate CSS files. Anyone who has tried to build a list of
layout rules for even the simplest website knows that creating basic CSS
requires plenty of repetition; Less.js handles all this repetition with
loops, variables, and other basic programming constructs. You can, for
instance, create a variable to hold that shade of green used as both a
background and a highlight color. If the boss wants to change it, you
only need to update one spot.
There are more elaborate constructs
such as mixins and nested rules that effectively create blocks of
standard layout commands that can be included in any number of CSS
classes. If someone decides that the bold typeface needs to go, you only
need to fix it at the root and Less.js will push the new rule into all
the other definitions.
Highlights: Simpler code
Headaches: A few good constructs leave you asking for more.
8. MATLAB
Once upon a time,
MATLAB
was a hardcore language for hardcore mathematicians and scientists who
needed to juggle complex systems of equations and find solutions. It's
still that, and more of today's projects need those complex skills. So
MATLAB is finding its way into more applications as developers start
pushing deeper into complex mathematical and statistical analysis. The
core has been tested over the decades by mathematicians and now it's
able to help mere mortals.
Highlights: Fast, stable, and solid algorithms for complex math
Headaches: The math is still complex.
9. Arduino
The
Internet of Things is coming. More and more devices have embedded chips just waiting to be told what to do.
Arduino isn't so much a new language as a set of C or C++ functions that you string together. The compiler does the rest of the work.
Many
of these functions will be a real novelty for programmers, especially
programmers used to creating user interfaces for general computers. You
can read voltages, check the status of pins on the board, and of course,
control just how those LEDs flash to send inscrutable messages to the
people staring at the device.
Highlights: The world of devices is your oyster.
Headaches: It's largely C and C++.
10. CUDA
Most
people take the power of their video cards for granted. They don't even
think about how many triangles the video card is juggling, as long as
their world is a complex, first-person shooter game. But if they would
only look under the hood, they would find a great deal of power ready to
be unlocked by the right programmer. The
CUDA
language is a way for Nvidia to open up the power of their graphics
processing units (GPUs) to work in ways other than killing zombies or
robots.
The key challenge to using CUDA is learning to identify
the parallel parts of your algorithm. Once you find them, you can set up
the CUDA code to blast through these sections using all the inherent
parallel power of the video card. Some jobs, like mining Bitcoins, are
pretty simple, but other challenges, like sorting and molecular
dynamics, may take a bit more thinking. Scientists love using CUDA code
for their large, multidimensional simulations.
Highlights: Very fast performance, at least for parallel code.
Headaches: Identifying the easily parallelizable sections of code isn't always easy.
11. Scala
Everyone
who's taken an advanced course in programming languages knows the
academic world loves the idea of functional programming, which insists
that each function have well-defined inputs and outputs but no way of
messing with other variables. There are dozens of good functional
languages, and it would be impossible to add all of them here.
Scala
is one of the best-known, with one of the larger user bases. It was
engineered to run on the JVM, so anything you write in Scala can run
anywhere that Java runs—which is almost everywhere.
There are good
reasons to believe that functional programming precepts, when followed,
can build stronger code that's easier to optimize and often free of
some of the most maddening bugs. Scala is one way to dip your toe into
these waters.
Highlights: Functional, but flexible enough to play well with others using the JVM
Headaches: Thinking functionally can be difficult for some tasks and applications.
12. Haskell
Scala isn't the only functional language with a serious fan base. One of the most popular functional languages,
Haskell,
is another good place for programmers to begin. It's already being used
for major projects at companies like Facebook. It's delivering real
performance on real projects, something that often isn't the case for
academic code.
Highlights: Already battle tested
Headaches: Thinking functionally can require fixing some bad habits.
13. Jolt
When
XML was the big data format, a functional language called XSLT was one
of the better tools for fiddling with large datasets coded in XML. Now
that JSON has taken over the world,
Jolt
is one of the options for massaging your JSON data and transforming it.
You can write simple filters that extract attributes and JOLT will find
them and morph them as you desire. See also
Tempo and using
XSLT itself.
reference:https://techbeacon.com/13-programming-languages-defining-future-coding
