27 languages
· Procedural programming languages: C, Rust, Cython
· object-oriented data modeling language: Java, C#, Eiffel
· Object-oriented derivative language of C: C++, D
· Array-oriented data processing: MATLAB/Octave, Julia
· Statistical data analysis: R
· computational pipeline modeling: Haskell, Scala, Clojure, F#
· Event-driven programming: JavaScript, Go, Erlang, Elixir
· Gradient type: TypeScript
· Dynamic metaprogramming: Hy, Ruby
· Practical problem solving: Lua, PHP, Perl
· Computational thinking: Scratch, Logo
As a co-designer of one of the most popular programming languages in the world, I often come across a very frustrating behavior (both in the Python community and elsewhere) where influential people in the community try to instill fear of “missing” in other open source communities, (I occasionally do this myself, and it’s easier to spot when others fall into this trap).
While using the experience of other programming languages community is a good thing, but with the method based on fear to drive action there is a big problem, and community members in order to attract the attention of the contributors, easy to other members of the community as a competitor, rather than as a potential ally jointly meet the challenge, to promote the progress of software development technology. It also causes the community to reject people who like other programming languages as enemies.
In fact, we want to have a richer choice of cross-platform open source programming languages, which are the most important thinking tools for translating our ideas into explicit terms that computers can understand. It would be great if people found a language that suited their brains and addressed their problems directly, regardless of which language they chose.
So I would like to make three specific requests and a broader recommendation to the Python community, starting with these requirements:
1. When we want to motivate tribal members and make the community more engaging, we should not use the method of fear, we should use the method of pride instead. When we use fear incentives, such as “If we don’t solve problem X, there will be fewer Python developers and they will use language Y instead,” we are deliberately transmitting negative energy to people all over the world who freely contribute code. But if we were to use the pride method, it would say something like this: “Problem X in Python was really hard to solve, and looking at the community in language Y, they solved the problem in a nifty way, and we can try this solution in Python to solve the problem in Python in the same elegant way.” A positive emphasis on “taking pride in our own efforts” promotes a culture of continuous learning within the Python community, as well as relationships with other communities.
2. Refrain from being dismissive of other programming language communities, especially those that are big enough to solve their own problems without waiting for commercial software vendors to deign to solve them. Most of the world’s important problems are not profit-driven (people who want to solve problems, not make money, and have no institutions to fund them), so we should encourage and praise those who step up their efforts to solve them. It doesn’t matter what technology they use.
3. If someone we know is just learning to program, even if they choose a programming language we don’t like. We need to support them, too, because they know better than we do what works for their brains. So what works for us may not work for them. If they start to get so frustrated with their choice that it completely discouragement them from learning to program, then it makes more sense to recommend a programming language. This advice to us even did improve the work of network security of useful, for language, which was not safe our solution is, by improving the operating system has the function of the sandbox, gradually break the language barriers, choose in native system security properties, improves the programming language default behavior, Beginners should not be confused by evaluating programming languages in terms of application security. (If someone asks a programmer to write an unaudited piece of software that is deployed to deal with security-sensitive issues, that is not the programmer’s fault, but the deployable’s fault for not doing due diligence on the software’s origins and security attributes.)
My more advice is for people to start encountering Python’s core assemblies, and thus start exploring more of Python’s own “tools of mind.”
Part of what we do in Python’s core development process is to understand whether we can make Python code easy to read and write in a way that is appropriate because of the characteristics that we have an advantage in other languages. This means that learning other programming languages can clarify specific styles, and programming in Python improves one’s understanding of software development.
To aid such efforts, I have listed the areas to explore below, along with some language that may provide additional insights into these areas. I do my best to link to Wikipedia rather than go straight to the relevant front page, because Wikipedia often provides some interesting historical background that is worth exploring when choosing a new programming language as an academic exercise rather than for immediate practical use.
Personally, however, I am familiar with many programming languages (and have used some of them to develop production systems). All of the recommendations include languages I know indirectly (either through reading materials and design documents, or through conversations with trusted friends about the pros and cons of a language).
There should be many and edges on the list, but the specific languages listed are just a random subset, chosen in some way based on my own interests (e.g. : My primary interest is in the dominant Linux, Android, and Windows ecosystems, so I’m ignoring the closed but more lucrative Apple-centric Objective-C and Swift programming languages here, And I don’t know much about programming languages that focus on art environments, such as Processing, and I even have to guess what I can learn from them to guide a Python developer). There are many factors to consider for a more comprehensive list of programming languages. In addition to considering how a programming language can guide you as a developer, IEEE Spectrum’s annual ranking of the popularity and growth of programming languages is also worth checking out.
Procedural programming languages C, Rust, Cython
Python’s default execution model is procedural: we start at the top of the main module and execute sentence by sentence. All of Phthon’s method support for other data and computation models is based on its procedural nature.
C is unquestionably still the king of the underlying programming languages. It is the core language for implementing the Python interpreter, as well as the Linux operating system kernel. As a software developer, learning C is the best place to start learning more about the underlying hardware on which the software runs -C is often described as a “portable assembly language”, often using a C compiler as a cross-compiler to compile the first application for a new CPU architecture.
Rust, by contrast, is a relatively new language created by Mozilla. It is able to enter the list, is the cause of Rust learned industry known about not doing lessons in the C language, and is designed with the language of the C library interoperability, which reached and low-level control of the hardware system programming languages of the same precision, but it USES different ways to compile time for data modeling and memory management, Structure eliminates many of the common bugs that plague C programs (such as cache overruns, duplicate free memory errors, null pointer access, and thread synchronization issues). As an embedded systems engineer with my initial professional experience by training, I can already see that areas currently dominated by C and custom assembly code are likely to be replaced by Rust.
Cython is also a lower-level language by default, but unlike the general-purpose target language C, Rust, Cython is primarily used to write CPython extension modules. Cython is designed as a superset of Python, allowing programmers to choose when to support the flexibility of pure Python syntax, when the extensions supported by Cython syntax allow it to generate code equal to the speed and memory efficiency of native C code.
Learning one of these languages is to enhance their deep understanding of memory management, algorithmic efficiency, binary interface compatibility, software portability, and converting source code into a running system from a practical perspective.
Object-oriented data modeling: Java, C#, Eiffel
Modeling real-world state is one of the primary tasks in programming, and the most common approach is the native syntactic support of object-oriented languages: grouping data structures and the methods that manipulate them into composite classes.
Python’s native design allows you to use object-oriented features directly, without having to learn how to write your own classes first. Not every language has this approach – for the languages listed in this section, learning object-oriented design ideas is a prerequisite for using them.
Thanks to Sun Microsystems’ marketing of the language in the mid to late 1990s, Java became the default language for many college and university introductory computer science courses. Although it is now being phased out by Python in many educational fields, it remains the most popular language for business application development. There are a number of other languages that implement the common JVM(Java Virtual Machine) runtime, including the Jython implementation of Python. Dalvik and ART environment of Android system are implemented based on Java programming API.
C# is similar to Java in many ways, having emerged as an alternative to J++ after Sun and Microsoft failed to resolve inconsistencies between J++(the Java language implemented by Microsoft) and standard Java. Like Java, it is a popular business application development language, with a range of other languages implementing the shared.NET CLR(common Language runtime), Including the IronPython implementation of Python (the core components in the original IronPython 1.0 were extracted to create the middle layer of the.NET dynamic language runtime). For a long time.net was a proprietary technology available only in Windows systems, with a cross-platform open source reimplementation of Mono. NET, but in early 2015, Microsoft announced its.net open source plans.
Unlike most of the languages on this list, I don’t recommend using Eiffel on a daily basis. It is on the recommended list because the language has a number of good object-oriented design ideas, including the goal of “true trustworthiness” as a program design goal. Eiffel also told me that for most software development, the goal is not to be “right trusted,” because right trusted software really can’t handle uncertainty well. This is not a good idea when many of the constraints are unclear and need to be refined in the iterative process.)
Learning such languages requires familiarity with inheritance models, contract design, class invariants, preconditions, postconditions, covariance, contravariance, method lookup paths, generic programming, and a variety of other features that are also supported on Python’s type system. There are also many standard library modules and third-party frameworks that use the “display-oriented” design style, such as UnitTest and LoggingModules, as well as the class-based Views in the Django framework.
Object-oriented C: C++, D
One way to use CPython is to think of its kernel as a kind of “C with objects in it” programming environment — CPython does object-oriented programming in the style of C, which describes data in C constructs, We then pass an instance pointer to the structure as the first argument to those data handlers (that is, the omnipresentPyObject* pointer in CPython C). This design pattern is intentionally copied into Python, specifying self or CLS arguments to display in instance methods and class methods.
C++ aims to be fully compatible with THE C language at the source level, adding advanced features such as native object-oriented programming support and template-based metaprogram development. C++ is notorious for its obscurity and complexity (even though a 2011 update to the language standards addressed many of the worst problems), but even so, C++ remains the choice for many scenarios, including 3D modeling graphics engines and cross-platform application development frameworks such as Qt.
The D programming language is also interesting because it has a similar relationship to C++ as Rust has to C: D was designed to retain most of the benefits of C++ while avoiding many of the drawbacks of C++ (such as a lack of storage security). Unlike Rust, D is not a completely new programming language designed from scratch. Instead, it is a language derived directly from C++, and while it is not a strict superset of C like C++, it follows a design principle that any code that falls into a common subset of C and D, The behavior must be the same in both languages.
Learning these languages helps to gain a deep understanding of the complexity of combining high-level language features with the underlying C runtime model. Learning C++ will also help you use Python to manipulate existing libraries and toolkits written in C++.
Array-oriented data processing: MATLAB/Octave, Julia
Array-oriented programming for numerical programming models: Based on matrix algebra and related numerical methods.
Although not directly supported by the Python standard library, the language has been designed with a number of syntactic and semantic features in mind that help with third-party libraries such as NumPy and similar array-oriented tools.
In many cases, the Python scientific computing software family is used as an alternative to the dedicated MATLAB programming environment for scientific and engineering modeling, simulation, and numerical analysis. The open source project GNU Octave aims to be syntactically compatible with MATLAB code, making it possible to compare these two approaches to object-oriented programming.
Julia is another relatively new language whose main features are support for array-oriented programming and type-based function overloading.
Learning one of these languages will help you gain insight into the power of the Python Scientific computing toolkit and how to implement hardware-level concurrent execution using technologies like OpenCL and Nvidia’s CUDA. It also helps to explore how to implement distributed data processing using data processing frameworks such as Apache Spark and Blaze.
Statistical data analysis language: R
As there are more and more large data sets to process. There is a need for a free analysis tool that can handle such data sets, and the programming language R is one such tool, with a special focus on statistical analysis and visualization.
Learning R will help you gain insight into the statistical capabilities of the Python Scientific Computing toolkit, especially its data analysis library pandas and statistical visualization library Seaborn.
Computational pipeline modeling languages: Haskell, Scala, Clojure, F#
Object-oriented data modeling and array oriented data modeling are mainly used for static modeling of data. There are two modeling methods: one is to store data in various attributes of the object, and the other is to store structured data as arrays.
In contrast, functional programming languages place more emphasis on dynamic modeling of data in the form of computational flows. Learning the basics of functional programming will significantly improve your ability to model data using data transformation operations, which is also helpful when developing applications using other paradigms such as procedural, object-oriented, and array-oriented programming languages.
Haskell is a functional programming language that has had a major influence on the design of Python, most notably with the introduction of list parsing in Python 2.0.
Scala is unquestionably a functional programming language based on the JVM and is one of the four main programming languages on the Apache Spark data analysis platform, along with Java, Python, and R. While Scala is designed to support functional programming, its syntax, data model, and execution model are designed to avoid too much of a hurdle for existing Java programmers. (In this regard, Scala is better classified as an object-oriented programming language with strong functional language support.)
Clojure is another JVM-based functional programming language that is considered a variant of Lisp. It deserves a place on our list because it inspired the implementation of Python’s functional programming toolkit Toolz.
I’m not personally familiar with F#, but since it’s a recommended language for the.net CLR, it’s worth keeping an eye on.
Learning these programming languages helps you learn about Python’s own computational pipeline modeling tools, including container-derived expressions, generators, generator expressions, funcTools and Itertools standard library modules, and third-party functional Python tools such as Toolz.
Event-driven programming languages: JavaScript, Go, Erlang, Elixir
Computation pipes are a good way to handle data conversion and analysis problems, but many problems require programs to run in a persistent manner, waiting for events to occur, and then processing those events. For such services, it is often possible to process multiple events concurrently to serve multiple users (or at least multiple behaviors) simultaneously.
JavaScript was originally developed as an event-handling programming language for browsers, allowing Web developers to handle client-side local user behavior (such as mouse movements and keystrokes) and events (such as the end of a page rendering). All modern browsers support JavaScript, and along with HTML5’s DOM, it has become the de facto standard for the look and behavior of user interfaces.
Designed by Google to create highly extensible Web services, Go is ideal for command-line applications. From the point of view of a design programming language, what is most striking is that Go uses the concept of “Sequential Processes” in its core concurrency model.
Erlang was designed by Ericsson to build highly reliable telephone switches and similar devices, and is used to implement the messaging server for RabbitMQ, the famous open source framework. Erlang implements the core concurrency primitive using the Actor model, which does not allow different threads to share data directly and communicates with each other only by passing messages. Although I have never used Erlang myself, my first work involved a concurrency framework based on the Actor model developed by a former Ericsson engineer in C++, and I myself developed such frameworks based on TSK(tasks) and MBX(mailboxes) primitions. Was implemented in Texas Instruments’ lightweight DSP/BIOS runtime (now called TI-TROs).
The reason Elixir is on this list is that while it runs in the Erlang virtual machine and has the same concurrency semantics as the programming language Erlang, it also contains a number of additional language-level features that provide a more comprehensive development environment, It is easier to attract developers who have made the switch from other programming languages, such as Python, Java, or Ruby.
Learning one of these languages will help you gain insight into how Python itself supports concurrency and parallelism, These include native coroutines, generator-based coroutines, concurrent.futures and Asyncio standard library modules, third-party web service development frameworks such as Twisted and Tornado, Django’s new channels concept, and event processing loops in the GUI framework.
Hybrid type: TypeScript
One of the most controversial features introduced in Python 3.5 is the new type module, which adds mixed type support to the Python architecture.
This is a terrifying thought for developers exposed to statically typed programming languages, mainly C, C++, and Java.
Microsoft TypeScript provides static-static typing support for JavaScript applications, which gives you a better perspective on the concept. TypeScript code is compiled to JavaScript code (without any runtime type checking). Annotations for TypeScript typed from mainstream JavaScript libraries can be found in the DefinitelyTyped code library.
As Chris Neugebauer pointed out in his presentation at PyCon in Australia, this is a lot like Python’s relationship with typeshed, the type hint library, and type derivation and analysis tools like Mypy.
In essence, TypeScript and Python type prompts are ways to implement specific test programs, whether they’re standalone files (regular test programs) or embedded in main code (type declarations similar to those in static programming languages). In either case, you can run separate commands to check whether the rest of the code conforms to known type constraints (implicit at compile time for JavaScript and TypeScript, optional static analysis for Python type hints).
Dynamic metaprogramming: Hy, Ruby
A somewhat disturbing feature that programming languages like C, C++, C#, and Java have brought to Python is “code as data” : similar functions and classes are runtime objects that can be manipulated by other objects.
Hy is a Lisp variant that runs on both CPython virtual machines and PyPy virtual machines. Lisp takes “code as data” to its extreme, and Lisp code itself consists of nested lists that describe the operations to be implemented (the language’s name comes from “LISt Processor”). One of the most powerful things about Lisp-style languages is that they can easily implement their own Domain-specific languages (DSLS), but this sometimes makes it difficult to read other people’s code.
Ruby is similar to Python in many ways, but as a more open community, Ruby is more open to dynamic metaprogramming, which is “supported, but not encouraged” for Python. This includes redefining classes to include methods and using closures to implement core language constructs such as iterators.
Learning these languages provides insight into Python’s own support for dynamic metaprogramming, This includes function and class decorators, monkeypatching, unitTest. mock library modules, and third-party object proxy modules such as WRapt. (I haven’t found a programming language that helps you understand Python’s metaclass, and if anyone has a good idea, Let me know in the comments. The advanced features of metaclasses include core types, abstract base classes, enumerated types, and run-time execution of mixed (dynamic and static) expressions.
Pragmatists: Lua, PHP, Perl
Popular programming languages are not usually isolated — they are part of a large ecosystem (both commercial and community), along with end users, framework developers, tool developers, educators, and so on.
Lua is a popular programming language that serves primarily as a scripting engine built into large programs. Examples include plug-ins written for the Warcraft game client, and the RPM tools that exist in many Linux distributions with Ruby built in. The Lua runtime is one-tenth the size of CPython, and its weaker introspection capabilities make it easier to separate itself from the rest of the application and the host operating system. One notable contribution to the Python ecosystem from the Lua community is that CPython and PyPy adopt LuaJit FFI(Foreign Function Interface) as the basis for their JIT-friendly CFFI Interface library.
PHP is another popular programming language, widely used by early virtual server hosting providers as part of the LAMP Stack (Linux-Apache-mysql-PHP) due to its expertise in generating HTML pages. Despite many distressing conceptual flaws in its design, PHP has become the basis for many well-known open source Web services, including the Drupal content management system, the WordPress blog engine, and the MediaWiki engine that powers Wikipedia. PHP also supports many important services, such as Ushahidi, a distributed event reporting platform used by the crowdsourcing community.
Like PHP, Perl is a popular language on Linux systems. Unlike PHP, Perl is not known as a web development platform, but is more commonly used as a tool for system administrators to manage systems. It can process both strings using regular expressions and the output of text-based Linux operating system commands. All tasks can be handled using Perl alone, eliminating the need for tools like Whensh, AWk, and SED.
Learning one of these languages does not provide any good insights into aesthetically beautiful or ideologically simple programming language design. The likely outcome is to provide some knowledge in practice about the structure and adoption of a programming language, and the role of understanding happenstance, historical accumulation, and lowering the threshold to entry (by reallocating default to be possible), all of which are stronger than the inherent capabilities of the language itself.
In particular, it can provide some insight into the project implications of CKAN, OpenStack NFV, Blender, SciPy, OpenMDAO, PyGMO, PyCUDA, Raspberry Pi Foundation, and Python through a wide range of commercial organizations, Ensure that institutional investment in the Python ecosystem continues.
Ideas for numerical calculations: Scratch, Logo
Finally, I often get caught up in the debate between structured programming and object-oriented advocates. The latter claim that object-oriented programming languages are as easy to learn as structured programming languages.
When we are talking about teaching through concrete numerical experiments (robotics), the models of the research objects in the simulation software have direct real-world references, such as sensors, engines, relays, etc. I think there’s a point in supporting the object-oriented folks.
For others, however, the typical challenge IS to pick up a cookbook, convert one recipe into an object-oriented programming language that you think is easy to learn, and then find a student who understands the language and continues to translate the recipe along my lines. (I look forward to seeing academic researchers actually practice this learning process — and I’m genuinely glad that happens.) In most cases, students don’t have to follow this process — just doing a mental experiment is enough to give them a sense of how much preparation they need to learn this “easy to learn” programming language.
Another way to solve this problem, however, is to learn the programming languages used to teach numerical computation to young children.
One of the most popular is Scrach, which is a programming interface that allows students to manipulate a closed graphical environment by dragging, so that they can see the corresponding movements and reactions in the graphical interface. A graphic environment like Scrach is a programming approach that uses comic books to help children learn how to read.
However, the idea of using a special-education programming language to manipulate a graphical interface is not new, with the creation of one of the most classic early environments, the Logo environment, in the 1960s (similar to Python’s own Turtle module), where the main thing you were dealing with was a “turtle,” You can change the graphics environment by ordering it to move to draw lines. In this way, things like command lines, iterations, states (e.g., swipe up, swipe down) all work in a way that is based on natural intuition (imagine if you were a turtle, what would happen if you rotated 90 degrees to the right?) On the basis of.
Return to the origin, as an experienced programmer, to learn more than any a programming language is the most effective way to forget what they have learned (discard some wheels) : the concepts covered in the language tools help us recall the concept of those we had taken for granted, but need to relearn beginner’s eyes. When we do this, we work more effectively with students and other novices because we are more willing to recall the entire logical chain, including the mental steps we previously took for granted and left out.