Programmers love to sneer at the world of
fashion where trends blow through like breezes. Skirt lengths rise and fall,
pigments come and go, ties get fatter, then thinner. But in the world of
technology, rigor, science, math, and precision rule over fad.
Image Courtesy http://www.infoworld.com/article/3039935/application-development/21-hot-programming-trends-and-21-going-cold.html
That's not to say
programming is a profession devoid of trends. The difference is that
programming trends are driven by greater efficiency, increased customization,
and ease of use. The new technologies that deliver one or more of these eclipse
the previous generation. It's a meritocracy, not a whimsy-ocracy.
[ Find out how to handle the
real-world problems faced by developers, with InfoWorld's professional
programmer's business survival guide. | Keep up with hot topics in
programming with InfoWorld's Application
Development newsletter. ]
What follows is a list
of what's hot and what's not among today's programmers. Not everyone will agree
with what's A-listed, what's D-listed, and what's been left out. That's what
makes programming an endlessly fascinating profession: rapid change, passionate
debate, sudden comebacks.
Hot: Preprocessors
Not: Full language stacks
It wasn't long ago that people who created a new programming language had to
build everything that turned code into the bits fed to the silicon. Then
someone figured out they could piggyback on the work that came before. Now
people with a clever idea simply write a preprocessor that translates the new
code into something old with a rich set of libraries and APIs.
The scripting
languages like Python or JavaScript were once limited to little projects, but
now they’re the foundation for serious work. And those who didn’t like
JavaScript created CoffeeScript, a preprocessor that lets them code, again,
without the onerous punctuation. There are dozens of variations preslicing and
predicing the syntax in a different way.
The folks who loved
dynamic typing created Groovy,
a simpler version of Java without the overly insistent punctuation. There seem
to be dozens of
languages like Scala or Clojure that
run on the JVM, but there's only one JVM. You can run many languages on .Net’s
VM. Why reinvent the wheel?
Hot: Docker
Not: Hypervisors
This isn’t exactly
true. The hypervisors have their place, and many Docker containers run inside
of operating systems running on top of hypervisors. However, Docker containers
are soooo much
smaller than virtual machine images, and that makes them much easier to use and
deploy.
When developers can,
they prefer to ship only Docker containers, thanks to the ease with which they
can be juggled during deployment. Clever companies such as Joyent are figuring
out how to squeeze even more fat out of the stack so that the containers can
run, as they like to say, on “bare metal.”
Hot: JavaScript MV* frameworks
Not: JavaScript files
Long ago, everyone
learned to write JavaScript to pop up an alert box or check to see that the
email address in the form contained an @ sign. Now HTML Ajax apps are so
sophisticated that few people start from scratch. It's simpler to adopt an
elaborate framework and write a bit of glue code to implement your business
logic.
There are now dozens of
frameworks like Kendo,
Sencha, jQuery Mobile, AngularJS, Ember, Backbone, Meteor JS, and many more,
all ready to handle the events and content for your Web apps and pages.
Those are merely the
Web apps. There are also a number tuned to offering cross-platform development
for the smartphone/tablet world. Technologies likeNativeScript, PhoneGap, and Sencha Touch are a few of the options for creating
apps out of HTML5 technology
Hot: CSS frameworks
Not: Generic Cascading Style Sheets
Once upon a time,
adding a bit of pizzazz to a Web page meant opening the CSS file and including
a new command like
font-style:italic
. Then you saved the
file and went to lunch after a hard morning's work. Now Web pages are so
sophisticated that it's impossible to fill a file with such simple commands.
One tweak to a color and everything goes out of whack. It's like they say about
conspiracies and ecologies: Everything is interconnected.
That's where CSS
frameworks like SASS and its cousins Compass have found solid footing. They
encourage literate, stable coding by offering programming constructs such as
real variables, nesting blocks, and mix-ins. It may not sound like much newness
in the programming layer, but it's a big leap forward for the design layer.
Hot: SVG + JavaScript on Canvas
Not: Flash
Flash has been
driving people crazy for years, but the artists have always loved the results.
The antialiased rendering looks great, and many talented artists have built a
deep stack of Flash code to offer sophisticated transitions and animations.
Now that the
JavaScript layer has the ability to do much of the same, browser manufacturers
and developers are cheering for the end of Flash. They see better integration
with the DOM layer coming from new formats like SVG (Scalable Vector Graphics).
The SVG and HTML comprise one big pile of tags, and that's often easier for Web
developers to use. Then there are large APIs that offer elaborate drawing on
the Canvas object, often with the help of video cards. Put them together and
you're left with few reasons to use Flash anymore.
Hot: Almost big data (analysis without Hadoop)
Not: Big data (with Hadoop)
Everyone likes to
feel like the Big Man on Campus, and if they aren't, they're looking for a
campus of the appropriate size where they can stand out. It's no surprise then
that when the words "big data" started flowing through the executive
suite, the suits started asking for the biggest, most powerful big data systems as if they were purchasing a yacht or
a skyscraper.
The funny thing is,
many problems aren't big enough to use the fanciest big data solutions. Sure,
companies like Google or Yahoo track all of our Web browsing; they have data
files measured in petabytes or yottabytes. But most companies have data sets
that can easily fit in the RAM of a basic PC. I'm writing this on a PC with
16GB of RAM -- enough for a billion events with a handful of bytes. In most
algorithms, the data doesn't need to be read into memory because streaming it
from an SSD is fine.
There will be instances that demand the fast response times of
dozens of machines in a Hadoop cloud running in parallel, but many will do fine
plugging along on a single machine without the hassles of coordination or
communication.
Hot: Spark
Not: Hadoop
It’s not so much
that Hadoop is cooling off. It’s more that Spark is red hot, making the Hadoop
model look a bit old. Spark borrows some of the best ideas of Hadoop’s approach
to extracting meaning from large volumes of data and updates them with a few
solid improvements that make the code run much, much faster. The biggest may be
the way that Spark keeps data in fast memory instead of requiring everything be
written to the distributed file system.
Of course many
people are merging the two by using Spark’s processing speed on data stored in
Hadoop’s distributed file system. They’re more partners than competitors.
Hot: Artificial intelligence/machine learning
Not: Big data
No one knows what
the phrase “artificial intelligence” means, and that helps the marketers,
especially since the term “big data” has run its course. They’re grabbing terms
from artificial intelligence and upgrading the sophistication of the big,
number-crunching algorithms that plow through our log files and clickstreams.
By borrowing the more sophisticated algorithms from the 50-odd years of AI
research, we stand a better chance than ever of finding that signal in the
noise. Tools run the gamut from machine learning frameworks to cognitive
computing, all the way up to IBM’s Watson, which you can now ping to solve your
problems. Each offers its own level of machine intelligence, and with this, the
promise of taking over more of the data analysis and forensics for us.
Hot: Game frameworks
Not: Native game development
Once upon a time,
game development meant hiring plenty of developers who wrote everything in C
from scratch. Sure, it cost a bazillion dollars, but it looked great. Now, no
one can afford the luxury of custom code. Most games developers gave up their
pride years ago and use libraries like Unity, Corona, or LibGDX to build their
systems. They don't write C code as much as instructions for the libraries. Is
it a shame that our games aren't handcrafted with pride but stamped out using
the same engine? Nope. Most of the developers are relieved -- because they
don't have to deal with the details, they can concentrate on the game play,
narrative arc, characters, and art.
Hot: Single-page Web apps
Not: Websites
Remember when URLs
pointed to Web pages filled with static text and images? How simple and quaint
to put all information in a network of separate Web pages called a website. The
design team would spend hours haggling over the site map and trying to make it
easy enough to navigate.
New Web apps are
front ends to large databases filled with content. When the Web app wants
information, it pulls it from the database and pours it into the local mold.
There's no need to mark up the data with all the Web extras needed to build a
Web page. The data layer is completely separate from the presentation and
formatting layer. Here, the rise of mobile computing is another factor: a
single, responsive-designed Web page that work like an app -- all the better to
avoid the turmoil of the app stores.
Hot: Mobile Web apps
Not: Native mobile apps
Let's say you have a great idea for mobile content. You could rush off and
write separate versions for iOS, Android, Windows 8, and maybe even BlackBerry
OS or one of the others. Each requires a separate team speaking a different
programming language. Then each platform's app store exerts its own pound of
flesh before the app can be delivered to the users.
Or you could build
one HTML app and put it on a website to run on all the platforms. If there's a
change, you don't need to return to the app store, begging for a quick review
of a bug fix. Now that the HTML layer is getting faster and running on faster
chips, this approach can compete with native apps better on even more
complicated and interactive apps.
Hot: Android
Not: iOS
Was it only a few
years ago that lines snaked out of Apple's store? Times change. While the
iPhone and iPad continue to have dedicated fans who love their rich,
sophisticated UI, the raw sales numbers continue to favor Android. Some reports
even say that more than 80 percent of phones sold were Androids.
The reason may be as
simple as cost. While iOS devices still cost a pretty penny, the Android world
is flooded with plenty of competition that's producing tablets for as low as
one-fifth the price. Saving money is always a temptation.
But another factor
may be the effect of open source. Anyone can compete in the marketplace -- and
they do. There are big Android tablets and little ones. There are Android
cameras and even Android refrigerators. No one has to say, "Mother, may
I?" to Google to innovate. If they have an idea, they follow their mind.
Apple, though, is learning from the Android
space. The iPhone 6 comes with different screen sizes, and what do you know?
The lines are starting to reappear.
Hot: GPU
Not: CPU
When software was
simple and the instructions were arranged in a nice line, the CPU was king of
the computer because it did all of the heavy lifting. Now that video games are
filled with extensive graphical routines that can run in parallel, the video
card runs the show. It's easy to spend $500, $600, or more on a fancy video
card, and some serious gamers use more than one. That's more than double the
price of many basic desktops. Gamers aren't the only ones bragging about their
GPU cards. Computer scientists are now converting many parallel applications to
run hundreds of times faster on the GPU.
Hot: GitHub
Not: Résumés
Sure, you could
learn about a candidate by reading a puffed-up list of accomplishments that
include vice president of the junior high chess club. Butreading someone's actual code is so much richer and more
instructive. Do they write good comments? Do they waste too much time breaking
items into tiny classes that do little? Is there a real architecture with room
for expansion? All these questions can be answered by a glimpse at their code.
This is why
participating in open source projects is becoming more and more important for
finding a job. Sharing the code from a proprietary project is hard, but open
source code can go everywhere.
Hot: Renting
Not: Buying
When Amazon rolled
out its sales for computers and other electronics on Black Friday, the company
forgot to include hypeworthy deals for its cloud. Give it time. Not so long
ago, companies opened their own data center and hired their own staff to run
the computers they purchased outright. Now they rent the computers, the data
center, the staff, and even the software by the hour. No one wants the hassles
of owning anything. It's all a good idea, at least until the website goes viral
and you realize you're paying for everything by the click. Now if only Amazon
finds a way todeliver the cloud with its drones, the trends
will converge.
Hot: Cloud complexity
Not: Cloud simplicity
The early days of
cloud computing saw vendors emphasizing how easy it was to click a button and
get a running machine. Simplicity was king.
Now choosing the right
machine and figuring out the right discount program could take more time than
writing the code. There are dozens of machine profiles available, and most
cloud providers support some of the older models. All offer unique levels of
performance, so you better be ready to benchmark them to decide which is the
most cost-effective for you. Is it worth it to save 12 cents per hour by
getting by with less RAM? It sure could be if you’re spinning up 100 machines
for months at a time.
To make matters more
complex, the cloud companies offer several options for getting discounts by
paying in advance or buying in bulk. You have to put them in the spreadsheet
too. It’s enough to invest in an online course on cloud cost engineering.
Hot: IaaS
Not: PaaS
Who doesn’t want to be
coddled? Who doesn’t want extra help? Yes, developers often like having all of
the extra support that comes from working with a full PaaS. There are plenty of
extra features, some of which are actually useful.
But there’s one big
fear: Platform means lock-in. Sometimes the trade-off is worth it, but
sometimes it’s a nightmare. IaaS options are more open to change. If you don’t
like your Ubuntu server running in an IaaS rack, you can install your own
Ubuntu server in your office and go it alone. It's not quite as easy with a
PaaS.
Hot: Web interfaces
Not: IDEs
A long time ago,
people used a command-line compiler. Then someone integrated that with an
editor and other tools to create the IDE. Now it's time for the IDE to be
eclipsed (ha) by browser-based tools that let you edit the code, often of a
working system. If you don't like how WordPress functions, it comes with a
built-in editor that lets you change the code right then and there. Microsoft's
Azure lets you write JavaScript glue code right in its portal. These systems
don't offer the best debugging environments, and there's something dangerous
about editing production code, but the idea has legs.
You can start Cloud9, Aptana, and Mozilla’s WebIDE, but keep exploring. The Web interfaces
are becoming more and more powerful. It’s possible, for instance, to build an
entirebig data analysis project in Microsoft’s Azure website.
Hot: Node.js
Not: JavaEE, Ruby on Rails
The server world has
always thrived on the threaded model that let the operating system indulge any
wayward, inefficient, or dissolute behavior by programmers. Whatever foolish
loop or wasteful computation programmers coded, the OS would balance
performance by switching between the threads.
Then Node.js came along with the JavaScript callback model of
programming, and the code ran really fast -- faster than anyone expected was
possible from a toy language once used only for alert boxes. Suddenly the
overhead of creating new threads became obvious and Node.js took off. Problems
arise when programmers don't behave well, but the responsibility has largely
been good for them. Making resource constraints obvious to programmers usually
produces faster code.
The Node.js world
also benefits from offering harmony between browser and server. The same code
runs on both making it easier for developers to move around features and
duplicate functionality. As a result, Node.js layers have become the hottest
stacks on the Internet.
Hot: PHP 7.0
Not: Old PHP
In the past, PHP was
a simple way to knock out a few dynamic Web pages. If you needed a bit of
variety, you could embed simple code between HTML tags. It was basic enough for
Web developers to embrace it, but slow enough to draw sneers from hard-core
programmers.
That’s old news because some PHP lovers at places like WordPress
and Facebook have been competing to execute PHP code faster than ever by incorporating
the Just-in-Time compiler technology that once made Java such a high-performing
solution. Now tools like the HipHop Virtual Machine and PHP 7.0 are delivering speeds that may be twice as fast as the old
versions. Take that, Node.js and Java.
Hot: Just-in-time education
Not: Four years up front
The
computer-mediated courses aren’t new anymore, and everyone is enjoying the
advantage of watching a video lecture with buttons for speeding up, slowing
down, or asking the prof to repeat that last point. The online forums are also
improvements over the old seminar rooms where only one blowhard could dominate
the discussion at a time.
But it’s not only
the nature of and technology behind online coursework that’s upending the
education industrial complex; it’s also the flexibility to learn whenever and
wherever you need to. This is changing the dynamic as people no longer have to
invest four years of outrageous tuition on a big collection of courses that may
or may not be relevant to their lives. Why take courses on compilers until you
know you’ll actually work on a compiler? If the boss wants to switch from a
relational database to a NoSQL engine, then you can invest the time in a course
in modern data stores. You get fresh information when you need it and don’t
clutter your brain with quickly rotting ideas.
No comments:
Post a Comment