Recs.
Updated
One of the oldest and most well known languages. It features a syntax very similar to JavaScript, owing in part to the fact that it is a precursor to JavaScript.
SpecsUpdate
Pros
Pro Incredibly large reservoir of code
C features what may be the largest quantity of libraries and code snippets, from 3D games to web-browsers, from image processing to sound synthesis, file format parsers, data structures, compilers and interpreters. It can even compile and interpret JavaScript code.
Practically any algorithm or technology are first implemented in C before being ported to other languages. In some cases, the C library is used directly via FFI, rather than re-implementing the code. Most of the JS standard library in the most commonly used VMs is backed by C implementations. It is rare to find an algorithm that is implemented in some language, and doesn't also have a C implementation.
Pro Tried and true
With over 40 years under its belt, C has passed the test of time in a way few other languages have. While other languages as old as C had to go through entire paradigm changes to stay alive, C has only needed a few extra primitive types and operators over the years, to keep up with the capabilities of modern processors.
It has actually received less additions than the machine code it usually compiles into, and far less than JavaScript has. Despite this, it is more commonly used, even today.
Pro Extremely high performance
When it comes to performance, there's no competing with native code. Any interpreted language incurs some overhead due to its data model and access patterns. This overhead can be mostly eliminated by using asm.js, which allows the VM to translate all but system calls to efficient undecorated native code.
Pro Portable between CPU architectures
C was designed to be independent of any particular machine architecture, and so with a little care, it is easy to write "portable" programs (see here). By design, C provides constructs that map efficiently to typical machine instructions, and therefore it has found lasting use in applications that had formerly been coded in assembly language like operating systems or small embedded systems.
Pro Low level of abstraction
While higher level languages languages like Java and Python provide possibilities to be "more expressive" per line of code, it's much more convenient to start with "less efficient" (get me right) language, in order to get initial concepts of how things behave at lower level.
Actually C is a good starting point moving to both higher and lower levels of abstraction, the good example here would be learning C before Assembler, as for general use the Assembler quite hard to understand due to low level of its abstraction (like getting the understanding on how loops work in C before trying to implement them on Assembler).
Pro Portable
C is portable between most hardware. Generally a C compiler is made for any new architecture, and already exists for existing architectures.
C is portable between all operating systems (Windows, UNIX, Mac, etc.) and only needs a program to be recompiled to work. This allows anyone on any operating system to learn about the language and not be held back by intricacies of their operating system.
With this said, C's portability these days is not quite what it used to be. Much of said portability relies on the POSIX standard in particular, and as time passes, the compliance of a given system with that standard is becoming less certain; especially in the case of Linux. Most things will still be portable (or at least emulatable) between Windows, Linux, and FreeBSD for example; but you will at times need to make use of platform-specific support libraries and APIs as well.
Pro Understanding of computers
Learning C forces you to grapple with the low-level workings of your computer (memory management, pointers, etc.) in ways that the other languages abstract away. Without an understanding of these low-level aspects of computer programming you will be limited if you try to develop an application that needs to run in a memory or performance constrained environment.
Other languages like Python can obscure a lot of details, so your foundation may be weaker.
Cons
Con Undefined behaviors and weak limited type safety
Subtle errors can render the entire program "undefined" by the complicated C standard. The standard imposes no requirements in such cases. Thus C compiler is free to ignore the existence of such cases and Bad Things are prone to happen instead. Even experts can't reliably avoid undefined cases in C, so how can beginners be expected to do so? C allows for non-type safe operations such as logic errors, wild pointers, buffer overflow, etc. UB and type safety issues create a large number of bugs and security vulnerabilities.
Con Language is full of corner cases and undefined behaviors
Undefined behavior in a program can cause unexpected results, making it hard to debug. With UB, program behavior may vary wildly depending on optimization settings. There are many cases that invoke UB, such as signed overflow, invalid dereferences, large integer shifts, uninitialized variables, etc. These serve to frustrate novice programmers when they could be learning other concepts.
Con Hard to maintain in large projects due to the lack of unit testing
All modern languages worth their salt implements unit testing built into the language so that programmers can implement testing coverage for their entire software project to prevent bugs. However, C does not support unit testing built into the language, which makes the already error-prone language even more error prone.