Programming languages evolves with the need to the developers, but not all of them evolves at the same speed and sometimes some languages stays almost the same for decades. Is this a sign of stagnation? Is it possible to evolve a language without breaking retrocompatibility? This talk will cover how Python and Javascript approached the problem in a radically different way, with their pro and cons and with the consequences on the community. The main points of this talk are: * comparation of the new features in both languages * strategies used to port or run the code on different versions of the language * impact of the new features and tool on the respective developer’s communities The intent is to start a constructive discussion about the retrocompatility in Python. For this talk you don’t need to have a deep knowledge of Python or Javascript.

1. Evolution
or
Stagnation
of
Programming
languages
Daniele Esposti

2. Data Platform Lead
Daily playing with:
Python, JavaScript & Java
@expobrain
github.com/expobrain
Daniele Esposti

3. I’ll not talking about the history of
programming languages...

4. I’ll talk about
modern programming languages

5. What’s a language?

6. “The method of communication,
either spoken or written,
consisting of the use of words
in a structured and conventional way”
https://en.oxforddictionaries.com/definition/language

7. Does it apply
to programming languages as well?

8. Yes!

9. Languages evolves
by the requirements
of whom spoke them

10. If a language is not useful anymore
or become stagnant
fewer and fewer people will use it

11. Let consider two very popular
programming languages

12. Python
JavaScript
&

13. Python 3.x

14. Python
● print() as a function
● All strings are unicode
● Renaming of standard libs
(six.moves on the rescue)

15. Python
● async / await
● f-strings
● Delegating to a Subgenerator ( yield from
)

16. Python
● very few additions in the 2.x series
● core language is still the same
● changes in the 3.x series
are backward incompatible

17. Python
Some features are backward compatible,
must be activated with:
from __future__ import <feature>

18. Python
However a huge amount of improvements:
new packages, better performance
and lower memory usage

19. JavaScript ES5 &
ES6

20. JavaScript
● Setter / getters
● New methods on Object and Array
● const / let
● Block scoped variables and functions

21. JavaScript
● Arrow functions
● Lexical this
● Default parameters in functions
● Spread / rest operator

22. JavaScript
● Template literals
● Property shorthand
● Computed property names
● Method properties in objects

23. JavaScript
Destructuring:
● Array matching
● Object matching
● ...with default values and deep traversal

24. JavaScript
● import and export
● Classes
● Iterators and generators
● Map / Set and WeakMap / WeakSet

25. JavaScript
● Typed and shared arrays
● Promise and async / await
● Proxying and reflection
● Collation

26. JavaScript
A lot of new addition to the language
No backward incompatible changes*
Code can be run on any browser*
*more on this later

27. Compared to Python JavaScript’s
evolution in the same timescale
has been more successful

28. What happened?

29. From Guido van Rossum: BDFL Python 3 retrospective:
● We didn't build any runtime compatibility features
● We didn't know how to create fully-automated
conversion tools
● We didn't make enough compatibility allowances
● We did a few things half-heartedly (i.e. the stdlib
cleanup)
Python

30. JavaScript
● The TC39 committee is careful to not break the Web
● ES5 code is still valid in ES6, ES7, etc.
● Features are provided by polyfills
● Babel transpile any version of JavaScript down to ES5

31. Which means:
● Old code is still working
● New code works on older interpreters via transpiling
● Can mix new and old code
● Can write code in ES.next via transpiling
JavaScript

32. Lessons learned:

33. Developers are more productive when
upgrading the programming language
is painless and seamless

34. Tooling is important:
2to3 failed
where
Babel succeeded

35. Old and new language
must coexist

36. Explore how other languages
approached the same problem

37. The language should be ergonomic
end evolve fast to be close
to the developer’s needs

38. Python
is one of the most successful language
but it’s evolution is restrained

39. We don’t want to see it stagnant
We want so see it thrive!

40. github.com/expobrain@expobrain
Thank you !