Top Programming Languages to Learn in 2017

One of the most common questions I get asked is this:

“What programming languages should I learn?”

It’s a valid question of course, but it’s almost like someone asking:

“What car should I buy?”

The answer depends on a lot of things in this case. What is your budget? Do you want new or old? Must it be big or small? What specs would you like? etc.

Bringing it back to web development terms, it follows the same pattern of the car scenario.

What is your current web development knowledge? What is the purpose of you studying programming? How much time do you have available? Do you want to work for yourself or for a company? Do you prefer frontend or backend? How much are you willing to invest on learning? etc.

Before getting started, I must mention that programmers are interesting people. If I were to mention ‘x’ programming language, you will get those who say, “but what about ‘y’ programming language?”

Bottom line is this is not a list mentioning all the programming languages available. It’s just a simplified and relevant list for 2017.

With that said, I will try my best to answer this question without offending too many people and at the same time, helping others.

So, “how do you measure the popularity of a programming language?”

According to Wikipedia, it’s not that easy.

Based on what I can see after going through reputable sites like: TIOBE, Trendy Skills, PYPL, Indeed, Google Trends and others, and after speaking with many in the industry, the trend for 2017 is this:

• JavaScript
• Java
• Python
• TypeScript
• PHP
• Ruby on Rails
• Elixir
• Rust
• Go
• C#
• Swift

To make things easier to understand, I’ve colour coded it:

The popular programming languages for 2017 are in ORANGE.

The GREEN programming languages are ones you should not neglect.

If you want to become a frontend web developer:

Not sure what a frontend web developer is? Click here 
(HTML & CSS are not ‘programming languages’ but I’m putting this in here for beginners)

HTML is the foundation of every website. It’s the ‘raw shell’ and layout of a website.

HTML has an updated version called HTML5 which is dynamic (you can create awesome sites using less code and it does more).

HTML5 is definitely a good 'language' to study within the next 3 years. Steve Jobs has an interesting forecast about it here.

Some cool sites that make use of HTML5 are Peugeot and Lacoste.

Learn HTML here, here and here. Learn HTML5 here and here.

CSS makes the website stylish. This is a great example of what CSS can do.

CSS3 is the latest version of CSS. It’s more dynamic and works hand-in-hand with HTML5. Just like salt and pepper goes together, so it is with HTML5 and CSS3.

Learn CSS here, here and here. Learn CSS3 here.

JavaScript is the most commonly used programming language in the world. 
A simple example of what JavaScript can do is: If this, then that.

ES2017 (the updated JavaScript) is launching later this year which will make many developers emotional (with joy).

Once you’ve grasped JavaScript, learn jQuery (a library of different ‘plugins’ to add to your code which saves you a lot of time and makes it much easier for you to add a feature).

Learn JavaScript here, here, here, here and here. Learn jQuery here, here and here.

TypeScript is a statically typed language that compiles to JavaScript. Version 2.1 includes all the new features of JavaScript with optional static types.

Other benefits are stronger checks against bugs in your code and typos, async/await and more.

It’s also the most popular language for writing Angular 2 apps.

Learn TypeScript here, here, and here.

If you want to become a backend web developer:

Not sure what a backend web developer is? Click here 

Java is always a good long term bet and looking at the stats, it doesn’t seem to be going away any time soon.

It’s used by over 10 million developers and 15 billion (that’s not a typo) devices run Java worldwide!

Java is used to create Android Apps, software, games and website content.

Some websites that use Java are LinkedIn, eBay and Amazon.

Keep an eye out for Java 9 in 2017.

Learn Java here, here, here, here, here, here, here and here.

Python is similar to PHP and Ruby in the sense that it is an object-orientated language. It closely resembles the English language so it’s a great language to learn for beginners as well as seasoned professionals.

Sites like Instagram, YouTube, Reddit and NASA use aspects of Python.

Python 3.6 was released last month so take a look at the features here.

Learn Python here, here, here, here, here, here and here.

PHP is the most popular server-side programming language. It's often used as the foundation of CMS’ (Content Management Systems) like WordPress and big websites like Facebook and Wikipedia.

PHP 7.1 was released last month so take a look at the features here.

Learn PHP here, here, here, here and here.

Ruby on Rails (a noteworthy framework) is like ‘jQuery for JavaScript’. It makes it much easier to use Ruby, but it’s advised that you have a good understanding of Ruby before you utilize Rails.

The reason why Ruby on Rails is a great and popular choice is because many businesses (small and large) make use of it. Some businesses are: Airbnb, Groupon, Twitter and Shopify.

Make sure you have a decent understanding of JavaScript as you will need to use JavaScript when you advance in Rails. Also make sure you know Git and GitHub (recommended).

Ruby on Rails 5.1 was released last month so take a look at the features here.

Learn Ruby on Rails here, here, here and here.

Get Michael Hartl’s Ruby on Rails Guide here.

Rust is a general-purpose language that helps developers create fast, secure applications which takes advantage of the powerful features of modern multi-core processors.

It’s also the most loved language on Stackoverflow for 2016 which says a lot.

Sites that use Rust are: Dropbox and Coursera.

Learn Rust here and here.

Elixir is a dynamic, functional language designed for building scalable and maintainable applications.

One of the main benefits is concurrency. In short, it’s great for large applications that handle a lot of tasks at once.

Sites that use Elixir are: Pinterest, Moz and Bleacher Report.

Learn Elixir here, here, and here.

Go (or GOLANG) is created by Google and it's gaining popularity which will only grow in 2017.

It compiles fast and it has an excellent standard library that is also great with concurrent programs as well.

Sites that use go are: Netflix, YouTube and Adobe.

Learn Go here, here and here.

C# (‘see-sharp’) is not only limited to the programming language for Microsoft’s .NET Framework.

It’s also used for Windows applications and Android/iOS Apps with the technology from Xamarin.

Version 7.0 will be released in 2017 with some amazing features.

Learn C# here, here, here and here.

Swift is one of the fastest growing programming languages in history! It’s built by Apple (not the granny smith apple) and they have big plans for it so it would be good to take note of it as the popularity grows.

Swift is what you learn if you’d like to become an iOS App Developer.

Their latest release is 3.0.2 which you can check out here.

For the best Swift courses out there, learn here, here and here.

If you want to become a fullstack web developer:

Not sure what a fullstack web developer is? Click here

Learn HTML, CSS, Bootstrap, TypeScript, and 2 backend languages that you prefer.

Remember, it’s NOT about how much you KNOW, but rather what you DO with what you know.

What I mean by this is just because you know JavaScript, Python, C#, Elixir, etc, etc. like a grand master, it does not mean that you are guaranteed a job.

The biggest myth in programming is:

“I know more programming languages than you, so I will be more successful.“

THIS IS THE MOST PATHETIC LIE I HAVE EVER HEARD.

You can know the most advanced programming languages, but if you can’t apply it properly and create a website or web app that meets the client’s needs then what is the point with all that knowledge?

Scenario:

‘Bob’ knows HTML, CSS, JavaScript, Bootstrap, SQL, Java and PHP, technically he should (by conventional norm) be able to create way better websites/apps than someone like ‘Fred’ who only knows HTML, CSS, Bootstrap and basic JavaScript.

Of course this is not always true. ‘Fred’ could just APPLY his knowledge and skills better than ‘Bob’ and create far better sites that look good and achieves the client's needs.

Read More

Making GIFs From Video Files With Python

Sometimes producing a good animated GIF requires a few advanced tweaks, for which scripting can help. So I added a GIF export feature to MoviePy, a Python package originally written for video editing.

For this demo we will make a few GIFs out of this trailer:

You can download it with this command if you have Youtube-dl installed:

1	youtube-dl 2Jw-AeaU5WI -o frozen_trailer.mp4

Converting a video excerpt into a GIF

In what follows we import MoviePy, we open the video file, we select the part between 1’22.65 (1 minute 22.65 seconds) and 1’23.2, reduce its size (to 30% of the original) and save it as a GIF:

1 2 3 4 5 6

from moviepy.editor import * clip = (VideoFileClip("frozen_trailer.mp4") .subclip((1,22.65),(1,23.2)) .resize(0.3)) clip.write_gif("use_your_head.gif")

Cropping the image

For my next GIF I will only keep the center of the screen. If you intend to use MoviePy, note that you can preview a clip with clip.preview(). During the preview clicking on a pixel will print its position, which is convenient for cropping with precision.

1 2 3 4 5

kris_sven = (VideoFileClip("frozen_trailer.mp4") .subclip((1,13.4),(1,13.9)) .resize(0.5) .crop(x1=145,x2=400)) # remove left-right borders kris_sven.write_gif("kris_sven.gif")

Freezing a region

Many GIF makers like to freeze some parts of the GIF to reduce the file size and/or focus the attention on one part of the animation.

In the next GIF we freeze the left part of the clip. To do so we take a snapshot of the clip at t=0.2 seconds, we crop this snapshot to only keep the left half, then we make a composite clip which superimposes the cropped snapshot on the original clip:

1 2 3 4 5 6 7 8 9 10 11 12

anna_olaf = (VideoFileClip("frozen_trailer.mp4") .subclip(87.9,88.1) .speedx(0.5) # Play at half speed .resize(.4)) snapshot = (anna_olaf .crop(x2= anna_olaf.w/2) # remove right half .to_ImageClip(0.2) # snapshot of the clip at t=0.2s .set_duration(anna_olaf.duration)) composition = CompositeVideoClip([anna_olaf, snapshot]) composition.write_gif('anna_olaf.gif', fps=15)

Freezing a more complicated region

This time we will apply a custom mask to the snapshot to specify where it will be transparent (and let the animated part appear) .

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

import moviepy.video.tools.drawing as dw anna_kris = (VideoFileClip("frozen_trailer.mp4", audio=False) .subclip((1,38.15),(1,38.5)) .resize(.5)) # coordinates p1,p2 define the edges of the mask mask = dw.color_split(anna_kris.size, p1=(445, 20), p2=(345, 275), grad_width=5) # blur the mask's edges snapshot = (anna_kris.to_ImageClip() .set_duration(anna_kris.duration) .set_mask(ImageClip(mask, ismask=True)) composition = CompositeVideoClip([anna_kris,snapshot]).speedx(0.2) # 'fuzz' (0-100) below is for gif compression composition.write_gif('anna_kris.gif', fps=15, fuzz=3)

Time-symetrization

Surely you have noticed that in the previous GIFs, the end did not always look like the beginning. As a consequence, you could see a disruption every time the animation was restarted. A way to avoid this is to time-symetrize the clip, i.e. to make the clip play once forwards, then once backwards. This way the end of the clip really is the beginning of the clip. This creates a GIF that can loop fluidly, without a real beginning or end.

1 2 3 4 5 6 7 8 9 10 11 12 13

def time_symetrize(clip): """ Returns the clip played forwards then backwards. In case you are wondering, vfx (short for Video FX) is loaded by >>> from moviepy.editor import * """ return concatenate([clip, clip.fx( vfx.time_mirror )]) clip = (VideoFileClip("frozen_trailer.mp4", audio=False) .subclip(36.5,36.9) .resize(0.5) .crop(x1=189, x2=433) .fx( time_symetrize )) clip.write_gif('sven.gif', fps=15, fuzz=2)

Ok, this might be a bad example of time symetrization,it makes the snow flakes go upwards in the second half of the animation.

Adding some text

In the next GIF there will be a text clip superimposed on the video clip.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

olaf = (VideoFileClip("frozen_trailer.mp4", audio=False) .subclip((1,21.6),(1,22.1)) .resize(.5) .speedx(0.5) .fx( time_symetrize )) # Many options are available for the text (requires ImageMagick) text = (TextClip("In my nightmares\nI see rabbits.", fontsize=30, color='white', font='Amiri-Bold', interline=-25) .set_pos((20,190)) .set_duration(olaf.duration)) composition = CompositeVideoClip( [olaf, text] ) composition.write_gif('olaf.gif', fps=10, fuzz=2)

Making the gif loopable

The following GIF features a lot of snow falling. Therefore it cannot be made loopable using time-symetrization (or you will snow floating upwards !). So we will make this animation loopable by having the beginning of the animation appear progressively (fade in) just before the end of the clip. The montage here is a little complicated, I cannot explain it better than with this picture:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

castle = (VideoFileClip("frozen_trailer.mp4", audio=False) .subclip(22.8,23.2) .speedx(0.2) .resize(.4)) d = castle.duration castle = castle.crossfadein(d/2) composition = (CompositeVideoClip([castle, castle.set_start(d/2), castle.set_start(d)]) .subclip(d/2, 3*d/2)) composition.write_gif('castle.gif', fps=5,fuzz=5)

Another example of a GIF made loopable

The next clip (from the movie Charade) was almost loopable: you can see Carry Grant smiling, then making a funny face, then coming back to normal. The problem is that at the end of the excerpt Cary is not exactly in the same position, and he is not smiling as he was at the beginning. To correct this, we take a snapshot of the first frame and we make it appear progressively at the end. This seems to do the trick.

1 2 3 4 5 6 7 8 9 10 11 12

carry = (VideoFileClip("charade.mp4", audio=False) .subclip((1,51,18.3),(1,51,20.6)) .crop(x1=102, y1=2, x2=297, y2=202)) d = carry.duration snapshot = (carry.to_ImageClip() .set_duration(d/6) .crossfadein(d/6) .set_start(5*d/6)) composition = CompositeVideoClip([carry, snapshot]) composition.write_gif('carry.gif', fps=carry.fps, fuzz=3)

Big finish: background removal

Let’s dive further into the scripting madness: we consider this video around 2’16 (edit: not the video I originally used, it was removed by the Youtube user, I add to find another link):

And we will remove the background to make this gif (with transparent background):

The main difficulty was to find what the background of the scene is. To do so, the script gathers a few images in which the little pigs are are different positions (so that every part part of the background is visible on at least several (actually most) of the slides, then it takes the pixel-per-pixel median of these pictures, which gives the background.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

# Requires Scikit Images installed import numpy as np import skimage.morphology as skm import skimage.filter as skf from moviepy.editor import * ### LOAD THE CLIP pigsPolka = (VideoFileClip("pigs_in_a_polka.mp4")) .subclip((2,16.85),(2,35)) .resize(.5) .crop(x1=140, y1=41, x2=454, y2=314)) ### COMPUTE THE BACKGROUND # There is no single frame showing the background only (there # is always a little pig in the screen) so we use the median of # several carefully chosen frames to reconstitute the background. # I must have spent half an hour to find the right set of frames. times = (list(np.linspace(2.3,4.2,30))+ list(np.linspace(6.0,7.1,30))+ 8*[6.2]) frames_bg = [pigsPolka.get_frame(t) for t in times] background = np.percentile(np.array(frames_bg), 50,axis=0) ### MASK GENERATION def make_mask_frame(t): """ Computes the mask for the frame at time t """ # THRESHOLD THE PIXEL-TO-PIXEL DIFFERENCE # BETWEEN THE FRAME AND THE BACKGROUND im = pigsPolka.get_frame(t) mask = ((im-background)**2).sum(axis=2) > 1500 # REMOVE SMALL OBJECTS mask = skm.remove_small_objects(mask) # REMOVE SMALL HOLES (BY DILATIATION/EROSION) selem=np.array([[1,1,1],[1,1,1],[1,1,1]]) for i in range(2): mask = skm.binary_dilation(mask,selem) for i in range(2): mask = skm.binary_erosion(mask,selem) # BLUR THE MASK A LITTLE mask = skf.gaussian_filter(mask.astype(float),1.5) return mask mask = (VideoClip( make_mask_frame, ismask=True, duration= pigsPolka.duration) ### LAST EFFECTS AND GIF GENERATION final = (pigsPolka.set_mask(mask) .subclip(12.95,15.9) .fx(vfx.blackwhite) # black & white effect ! final.write_gif('pigs_polka.gif', fps=10, fuzz=10)

Read More