But the TechAeris report suggests copresence will do
more than what GCM does today. Based on a source that scanned the latest
Google Play Services build, numerous references to copresence were
found along with images alluding to peer-to-peer file transfers, similar
to how Apple’s
AirDrop works between iOS and OS X. One of the images in the software
appears to be song sharing between an iPhone and an Android device.
Copresence could even be location-based, where the appropriate app
could tell you when other friends are nearby and in range for transfers
or direct communications. Obviously, without an official Google
announcement we don’t know what this project is about. All of the
evidence so far suggests, however, that a new cross-platform
communication method is in the works.
The big languages are popular for a reason: They offer a huge foundation
of open source code, libraries, and frameworks that make finishing the
job easier. This is the result of years of momentum in which they are
chosen time and again for new projects, and expertise in their nuances
grow worthwhile and plentiful.
Sometimes the vast resources of the popular, mainstream programming
languages aren’t enough to solve your particular problem. Sometimes you
have to look beyond the obvious to find the right language, where the
right structure makes the difference while offering that extra feature
to help your code run significantly faster without endless tweaking and
optimizing. This language produces vastly more stable and accurate code
because it prevents you from programming sloppy or wrong code.
The world is filled with thousands of clever languages that aren't C#,
Java, or JavaScript. Some are treasured by only a few, but many have
flourishing communities connected by a common love for the language's
facility in solving certain problems. There may not be tens of millions
of programmers who know the syntax, but sometimes there is value in
doing things a little different, as experimenting with any new language
can pay significant dividends on future projects.
The following nine languages should be on every programmer’s radar. They
may not be the best for every job -- many are aimed at specialized
tasks. But they all offer upsides that are worth investigating and
investing in. There may be a day when one of these languages proves to
be exactly what your project -- or boss -- needs.
Erlang: Functional programming for real-time systems
Erlang began deep inside the spooky realms of telephone switches at
Ericsson, the Swedish telco. When Ericsson programmers began bragging
about its "nine 9s" performance, by delivering 99.9999999 percent of the
data with Erlang, the developers outside Ericsson started taking
notice.
Erlang’s secret is the functional paradigm. Most of the code is forced
to operate in its own little world where it can't corrupt the rest of
the system through side effects. The functions do all their work
internally, running in little "processes" that act like sandboxes and
only talk to each other through mail messages. You can't merely grab a
pointer and make a quick change to the state anywhere in the stack. You
have to stay inside the call hierarchy. It may require a bit more
thought, but mistakes are less likely to propagate.
The model also makes it simpler for runtime code to determine what can
run at the same time. With concurrency so easy to detect, the runtime
scheduler can take advantage of the very low overhead in setting up and
ripping down a process. Erlang fans like to brag about running 20
million "processes" at the same time on a Web server.
If you're building a real-time system with no room for dropped data,
such as a billing system for a mobile phone switch, then check out
Erlang.
Go: Simple and dynamic
Google wasn’t the first organization to survey the collection of
languages, only to find them cluttered, complex, and often slow. In
2009, the company released its solution: a statically typed language
that looks like C but includes background intelligence to save
programmers from having to specify types and juggle malloc calls. With
Go, programmers can have the terseness and structure of compiled C,
along with the ease of using a dynamic script language.
While Sun and Apple followed a similar path in creating Java and Swift,
respectively, Google made one significantly different decision with Go:
The language’s creators wanted to keep Go "simple enough to hold in one
programmer's head." Rob Pike, one of Go’s creators, famously told Ars
Technica that "sometimes you can get more in the long run by taking
things away." Thus, there are few zippy extras like generics, type
inheritance, or assertions, only clean, simple blocks of if-then-else
code manipulating strings, arrays, and hash tables.
The language is reportedly well-established inside of Google's vast
empire and is gaining acceptance in other places where dynamic-language
lovers of Python and Ruby can be coaxed into accepting some of the rigor
that comes from a compiled language.
If you're a startup trying to catch Google's eye and need to build some server-side business logic, Go is a great place to start.
Groovy: Scripting goodness for Java
The Java world is surprisingly flexible.
Say what you will about its belts-and-suspenders approach, like
specifying the type for every variable, ending every line with a
semicolon, and writing access methods for classes that simply return the
value. But it looked at the dynamic languages gaining traction and
built its own version that's tightly integrated with Java.
Groovy offers programmers the ability to toss aside all the humdrum
conventions of brackets and semicolons, to write simpler programs that
can leverage all that existing Java code. Everything runs on the JVM.
Not only that, everything links tightly to Java JARs, so you can enjoy
your existing code. The Groovy code runs like a dynamically typed
scripting language with full access to the data in statically typed Java
objects.
Groovy programmers think they have the best of both worlds. There's all
of the immense power of the Java code base with all of the fun of using
closures, operator overloading, and polymorphic iteration -- not to
mention the simplicity of using the question mark to indicate a check
for null pointers. It's so much simpler than typing another if-then
statement to test nullity. Naturally, all of this flexibility tends to
create as much logic with a tiny fraction of the keystrokes. Who can't
love that?
Finally, all of the Java programmers who've envied the simplicity of
dynamic languages can join the party without leaving the realm of Java.
OCaml: Complex data hierarchy juggler
Some programmers don't want to specify the types of their variables, and
for them we've built the dynamic languages. Others enjoy the certainty
of specifying whether a variable holds an integer, string, or maybe an
object. For them, many of the compiled languages offer all the support
they want.
Then there are those who dream of elaborate type hierarchies and even
speak of creating "algebras" of types. They imagine lists and tables of
heterogeneous types that are brought together to express complex,
multileveled data extravaganzas. They speak of polymorphism,
pattern-matching primitives, and data encapsulation. This is just the
beginning of the complex, highly structured world of types, metatypes,
and metametatypes they desire.
For them, there is OCaml, a serious effort by the programming language
community to popularize many of the aforementioned ideas. There's object
support, automatic memory management, and device portability. There are
even OCaml apps available from Apple’s App Store.
An ideal project for OCaml might be building a symbolic math website to teach algebra.
CoffeeScript: JavaScript made clean and simple
Technically, CoffeeScript isn't a language. It's a preprocessor that
converts what you write into JavaScript. But it looks different because
it's missing plenty of the punctuation. You might think it is Ruby or
Python, though the guts behave like JavaScript.
CoffeeScript began when semicolon haters
were forced to program in JavaScript because that was what Web browsers
spoke. Changing the way the Web works would have been an insurmountable
task, so they wrote their own preprocessor instead. The result?
Programmers can write cleaner code and let CoffeeScript turn it back
into the punctuation-heavy JavaScript Web browsers demand.
Missing semicolons are only the beginning. With CoffeeScript, you can
create a variable without typing var. You can define a function without
typing function or wrapping it in curly brackets. In fact, curly
brackets are pretty much nonexistent in CoffeeScript. The code is so
much more concise that it looks like a modernist building compared to a
Gothic cathedral. This is why many of the newest JavaScript frameworks
are often written in CoffeeScript and compiled.
Scala: Functional programming on the JVM
If you need the code simplicity of object-oriented hierarchies for your
project but love the functional paradigm, you have several choices. If
Java is your realm, Scala is the choice for you.
Scala runs on the JVM, bringing all the clean design strictures of
functional programming to the Java world by delivering code that fits
with the Java class specifications and links with other JAR files. If
those other JAR files have side effects and other imperative nasty
headaches, so be it. Your code will be clean.
The type mechanism is strongly static and the compiler does all the work
to infer types. There's no distinction between primitive types and
object types because Scala wants everything to descend from one
ur-object call Any. The syntax is much simpler and cleaner than Java;
Scala folks call it "low ceremony." You can leave your paragraph-long CamelCase variable names back in Java Land.
Scala offers many of the features expected of functional languages, such
as lazy evaluation, tail recursion, and immutable variables, but have
been modified to work with the JVM. The basic metatypes or collection
variables, like linked lists or hash tables, can be either mutable or
immutable. Tail recursion works with simpler examples, but not with
elaborate, mutually recursive examples. The ideas are all there, even if
the implementation may be limited by the JVM. Then again, it also comes
with all the ubiquity of the Java platform and the deep collection of
existing Java code written by the open source community. That's not a
bad trade-off for many practical problems.
If you must juggle the data in a thousand-processor cluster and have a pile of legacy Java code, Scala is a great solution.
Dart: JavaScript without the JavaScript
Being popular is not all it's cracked up to be. JavaScript may be used
in more stacks than ever, but familiarity leads to contempt -- and
contempt leads to people looking for replacements. Dart is a new
programming language for Web browsers from Google.
Dart isn't much of a departure from the basic idea of JavaScript. It
works in the background to animate all the DIVs and Web form objects
that we see. The designers simply wanted to clean up the nastier,
annoying parts of JavaScript while making it simpler. They couldn't
depart too far from the underlying architecture because they wanted to
compile Dart down to JavaScript to help speed adoption.
The highlight may be the extra functions that fold in many de facto
JavaScript libraries. You don't need JQuery or any of the other common
libraries to modify some part of the HTML page. It's all there with a
reasonably clean syntax. Also, more sophisticated data types and
syntactic shorthand tricks will save a few keystrokes. Google is pushing
hard by offering open source development tools for all of the major
platforms.
If you are building a dynamic Web app and are tired of JavaScript, Dart
offers a clean syntax for creating multiple dancing DIVs filled with
data from various Web sources.
Haskell: Functional programming, pure and simple
For more than 20 years, the academics working on functional programming
have been actively developing Haskell, a language designed to
encapsulate their ideas about the evils of side effects. It is one of
the purer expressions of the functional programming ideal, with a
careful mechanism for handling I/O channels and other unavoidable side
effects. The rest of the code, though, should be perfectly functional.
The community is very active, with more than a dozen variants of Haskell
waiting for you to explore. Some are stand-alone, and others are
integrated with more mainstream efforts like Java (Jaskell, Frege) or
Python (Scotch). Most of the names seem to be references to Scotland, a
hotbed of Haskell research, or philosopher/logicians who form the
intellectual provenance for many of the ideas expressed in Haskell. If
you believe that your data structures will be complex and full of many
types, Haskell will help you keep them straight.
Julia: Bringing speed to Python land
The world of scientific programming is filled with Python lovers who
enjoy the simple syntax and the freedom to avoid thinking of gnarly
details like pointers and bytes. For all its strengths, however, Python
is often maddeningly slow, which can be a problem if you're crunching
large data sets as is common in the world of scientific computing. To
speed up matters, many scientists turn to writing the most important
routines at the core in C, which is much faster. But that saddles them
with software written in two languages and is thus much harder to
revise, fix, or extend.
Julia is a solution to this complexity.
Its creators took the clean syntax adored by Python programmers and
tweaked it so that the code can be compiled in the background. That way,
you can set up a notebook or an interactive session like with Python,
but any code you create will be compiled immediately.
The guts of Julia are fascinating. They provide a powerful type
inference engine that can help ensure faster code. If you enjoy
metaprogramming, the language is flexible enough to be extended. The
most valuable additions, however, may be Julia’s simple mechanisms for
distributing parallel algorithms across a cluster. A number of serious
libraries already tackle many of the most common numerical algorithms
for data analysis.
The best news, though, may be the high speeds. Many basic benchmarks run
30 times faster than Python and often run a bit faster than C code. If
you have too much data but enjoy Python’s syntax, Julia is the next
language to learn.