{"id":132,"date":"2017-05-05T13:09:03","date_gmt":"2017-05-05T16:09:03","guid":{"rendered":"https:\/\/www.linuxpro.com.br\/2017\/05\/linguagens-de-programacao\/"},"modified":"2026-09-08T10:43:18","modified_gmt":"2026-09-08T13:43:18","slug":"linguagens-de-programacao","status":"publish","type":"post","link":"https:\/\/www.linuxpro.com.br\/en\/2017\/05\/linguagens-de-programacao\/","title":{"rendered":"The 7 main programming languages!"},"content":{"rendered":"

\"Mascote<\/p>\n

Note (2026):<\/strong> A 2017 list (Java, C, Python, Perl, PHP, Go, Swift). The ranking changed: Python leads TIOBE; Perl left the top 20; Rust entered the top 10. We keep the original seven, updated, and a snapshot of September 2026.<\/div>\n

Open any Linux server and you'll find five different languages running at once, unaware of each other. The kernel is C<\/strong>. docker<\/code> and kubectl<\/code> are Go<\/strong>. The ticketing panel is PHP<\/strong> \u2014 or Perl<\/strong>, if it's old. The script that runs the backup at three in the morning is Python<\/strong>. And since 2026, even Ubuntu's ls<\/code> and sudo<\/code> have been written in Rust<\/strong>.<\/p>\n

A programming language is the contract between the writer and the machine: syntax, semantics, a compiler or an interpreter. This post maps who speaks what \u2014 the seven from the original 2017 list, updated, plus those that came later.<\/p>\n

<\/p>\n

What changed on the map<\/h2>\n

September 2026 TIOBE (search, not jobs): 1 Python, 2 C, 3 C++, 4 Java, 5 C#, 6 JavaScript, 7 Visual Basic, 8 SQL, 9 R, 10 Rust. Go in 12\u00ba, PHP in 14\u00ba, Swift in 18\u00ba. Perl doesn't appear in the top 20. PYPL (tutorials on Google) and GitHub usage tell another story: JavaScript\/TypeScript dominate the web; Python, AI.<\/p>\n

An index isn't destiny. This blog runs WordPress (PHP). The kernel is C. What you install on a server in 2026 still goes through these seven \u2014 plus Rust and JS, which the 2017 list didn't cover.<\/p>\n

Paradigms, on one screen<\/h2>\n

Imperative:<\/strong> a sequence of orders. Object-oriented:<\/strong> state encapsulated in types. Almost every language on the list is multiparadigm. High level moves closer to humans; low level, to registers. C walks both paths. Python at the high end. Assembly at the bottom.<\/p>\n

Python<\/h2>\n

\"As<\/p>\n

Guido van Rossum \u00b7 1991 \u00b7 interpreted \u00b7 where it lives on Linux: automation, AI, apt<\/code> and half the distro's utilities.<\/em><\/p>\n

Readable, batteries included<\/em>, community-driven. In 2017 people were already talking about machine learning; in 2026 it's the lingua franca of AI, automation and sysadmin scripts. The stable series is 3.14, and there's no more \u201cPython 2\u201d on a serious server.<\/p>\n

It's also the language you most often encounter without looking: much of Debian's and Ubuntu's system tooling is written in it, and the entire AI ecosystem \u2014 from vLLM<\/a> to the client for Ollama<\/a> \u2014 speaks Python first.<\/p>\n

Start with the howto Python from Beginner to Professional<\/a> and with python.org<\/a>.<\/p>\n

C<\/h2>\n

\"Rob\u00f4<\/p>\n

Dennis Ritchie \u00b7 1972 \u00b7 compiled \u00b7 where it lives on Linux: the kernel, glibc, OpenSSL, PostgreSQL \u2014 the foundation of everything.<\/em><\/p>\n

The year after its creation, UNIX was rewritten in it \u2014 which is why half a century later it still rules. C23 is the current ISO standard. It isn't \u201ceasy\u201d: it's what the hardware obeys, at the cost of managing memory yourself. K&R remains the book; your distro's compiler is GCC or Clang.<\/p>\n

For almost all of the kernel's history, C was the only<\/em> option \u2014 until 2022, when Rust entered as an experiment, and 2026, when it stopped being experimental. That story is in The history of Linus Torvalds<\/a> and in Linux turns 35<\/a>; the lineage that came before, in The history of UNIX<\/a>.<\/p>\n

Java<\/h2>\n

\"Duke,<\/p>\n

Green Project, Sun \u00b7 early years of the decade beginning in '90 \u00b7 runs on the JVM \u00b7 where it lives on Linux: enterprise applications, Elasticsearch, Spark, Tomcat.<\/em><\/p>\n

The promise was write once, run anywhere<\/em>, and the JVM delivered \u2014 at the cost of carrying a virtual machine along. Today it belongs to Oracle; Android still speaks Java, increasingly sharing with Kotlin. The current LTS versions are 21 and 25. The syntax resembles C; the model doesn't.<\/p>\n

It's the language supporting much of what you install on a server without realizing it \u2014 from Elasticsearch to Tomcat<\/a>. Duke and the cup remain the imagery. Docs: docs.oracle.com\/en\/java<\/a>.<\/p>\n

Go<\/h2>\n

\"O<\/p>\n

Rob Pike, Ken Thompson and Robert Griesemer, at Google \u00b7 2009 \u00b7 compiled \u00b7 where it lives on Linux: practically every infrastructure tool of the last decade.<\/em><\/p>\n

Compiles in seconds, handles concurrency with go func()<\/code> and delivers a single static binary \u2014 no VM, no interpreter, no dependency to install on the server. That's what won over the cloud.<\/p>\n

The list of what's written in Go speaks for itself: Docker<\/a>, Kubernetes<\/a>, Terraform, Prometheus<\/a>, Gogs<\/a> and go-postfixadmin<\/a>. In 2017 this post said the language was still weak in Brazil; in 2026 it is<\/em> the language of infrastructure.<\/p>\n

The full history is in The history of the Go language<\/a>; to install, Installing Golang on Linux<\/a>. Website: go.dev<\/a>.<\/p>\n

PHP<\/h2>\n

\"O<\/p>\n

Rasmus Lerdorf \u00b7 the decade beginning in 1990 \u00b7 interpreted \u00b7 where it lives on Linux: roughly half the world's websites.<\/em><\/p>\n

Zeev Suraski and Andi Gutmans rewrote the engine in 1998 and PHP became the de facto standard for the dynamic web. Series 8 has typing, JIT and Fibers \u2014 it's nowhere near the PHP 5 the 2017 list knew.<\/p>\n

It's the language running this blog (WordPress) and much of what gets installed on a hosting server: GLPI<\/a>, ISPConfig<\/a>, PostfixAdmin<\/a>. In practice, a real host needs multiple<\/em> versions at the same time \u2014 the walkthrough is in Nginx with multiple PHP versions<\/a>. php.net<\/a>.<\/p>\n

Swift<\/h2>\n

\"A<\/p>\n

Apple \u00b7 2014, opened in 2015 \u00b7 compiled \u00b7 where it lives on Linux: less than it could, but it genuinely works.<\/em><\/p>\n

Born to replace Objective-C on the iPhone, it became what the 2017 post barely foresaw: a server language running on Linux with its own toolchain and package manager. The series is 6.3 in 2026. Objective-C hasn't died in the ABI, but new Apple code is Swift.<\/p>\n

If you came here from the hardware side, also see Linux on Apple Silicon<\/a>. To install the toolchain: Installing Swift on Linux<\/a>. swift.org<\/a>.<\/p>\n

Perl<\/h2>\n

\"O<\/p>\n

Larry Wall \u00b7 1987 \u00b7 interpreted \u00b7 where it lives on Linux: in the \/usr\/bin\/perl<\/code> that no distro dares remove.<\/em><\/p>\n

\u201cThere\u2019s more than one way to do it\u201d \u2014 the motto that made it equally beloved and unreadable. In 2017 it still appeared in rankings; in 2026 it left TIOBE's top 20. Perl 5 lives on; Raku (formerly Perl 6) took another path and became another language.<\/p>\n

It isn't the first language someone learns in 2026 \u2014 but it's the one holding up systems nobody can turn off. OTRS<\/a>, a helpdesk running in thousands of companies for twenty-five years, is Perl from floor to ceiling. Bioinformatics, sysadmin glue<\/em> and CPAN are still there. perl.org<\/a>.<\/p>\n

Rust<\/h2>\n

\"Ferris,<\/p>\n

Graydon Hoare, at Mozilla \u00b7 2006, 1.0 in 2015 \u00b7 compiled \u00b7 where it lives on Linux: in the kernel, in sudo<\/code> and, since 2026, in ls<\/code>.<\/em><\/p>\n

It's the most relevant newcomer since the original list, for a specific technical reason: memory safety without a garbage collector<\/strong>. The compiler collects its dues before the program runs \u2014 irritating in the first week, eliminating an entire class of bugs later.<\/p>\n

It has left the niche for good: the Linux kernel removed its experimental label in version 7.0 (April 2026), Ubuntu 25.10 began shipping sudo<\/code> through sudo-rs and 26.04 LTS brought coreutils rewritten in Rust. TIOBE top 10.<\/p>\n

The full history, with the borrow checker explained: The history of the Rust language<\/a>. rust-lang.org<\/a>.<\/p>\n

Who else joined later<\/h2>\n

TypeScript<\/strong>: JavaScript with types, it became the default for serious frontends and already dominates Node on servers. C++<\/strong>: never left; TIOBE ranks it 3\u00ba, and it supports game engines, browsers and much of what needs performance without Rust's discipline. Kotlin<\/strong>: today's preferred Android path, running on the same JVM as Java. The 2017 list didn't feature any of these three with this weight.<\/p>\n

Who speaks what on your server<\/h2>\n

The quickest way to understand the map is to look at what you already have installed:<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n
You use<\/th>\nIt's running<\/th>\n<\/tr>\n<\/thead>\n
The kernel, systemd<\/code>, bash<\/code>, PostgreSQL, nginx<\/td>\nC<\/td>\n<\/tr>\n
Docker<\/a>, Kubernetes<\/a>, Terraform, Prometheus<\/a><\/td>\nGo<\/td>\n<\/tr>\n
WordPress, GLPI<\/a>, ISPConfig<\/a><\/td>\nPHP<\/td>\n<\/tr>\n
Ansible<\/a>, apt<\/code>, almost every AI tool<\/td>\nPython<\/td>\n<\/tr>\n
OTRS<\/a>\/Znuny, many old sysadmin scripts<\/td>\nPerl<\/td>\n<\/tr>\n
Redmine<\/a>, GitLab<\/td>\nRuby<\/td>\n<\/tr>\n
Elasticsearch, Tomcat<\/a>, Spark<\/td>\nJava<\/td>\n<\/tr>\n
The sudo<\/code> and the ls<\/code> from Ubuntu 26.04, new kernel drivers<\/td>\nRust<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

None of these choices was arbitrary. Each solves a problem the others handled poorly \u2014 which is why the seven remain alive.<\/p>\n

Which to choose for what<\/h2>\n

Rankings decide nothing. The problem decides:<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n
If the goal is\u2026<\/th>\nStart with<\/th>\nWhy<\/th>\n<\/tr>\n<\/thead>\n
Server automation, sysadmin scripts<\/td>\nPython (or shell)<\/td>\nIn every distro, quick to read, libraries for everything<\/td>\n<\/tr>\n
AI, data, science<\/td>\nPython<\/td>\nWhere the whole ecosystem lives<\/td>\n<\/tr>\n
Command-line tool, agent, network service<\/td>\nGo<\/td>\nSingle static binary, compiles in seconds, inexpensive concurrency<\/td>\n<\/tr>\n
Kernel, driver, embedded system<\/td>\nC \u2014 or Rust, if the project accepts it<\/td>\nDirect hardware access; Rust adds memory guarantees<\/td>\n<\/tr>\n
Website, CMS, e-commerce<\/td>\nPHP<\/td>\nWordPress, Laravel and the cheapest hosting on the planet<\/td>\n<\/tr>\n
Large enterprise system, Android<\/td>\nJava or Kotlin<\/td>\nJVM, mature tooling, job market<\/td>\n<\/tr>\n
Frontend<\/td>\nTypeScript<\/td>\nNo real alternative in the browser<\/td>\n<\/tr>\n
iPhone app that also runs on Linux<\/td>\nSwift<\/td>\nOpen source since 2015, with SPM working outside the Mac<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

And the most honest answer to \u201cwhich should I learn first\u201d: the one solving the problem you have now. The second language takes a fraction of the effort of the first.<\/p>\n

Links<\/h2>\n