Vale a pena estudar C só para conhecimento?

Depende.

Que tipo de profissional você quer ser? Quer entender todo o processo de programação? Ou quer só seguir receitas de bolo?

C é a linguagem de alto nível que permite você aprender como tudo funciona do jeito mais básico. Faz você entender melhor qualquer outra linguagem.

É isso que quer?

Claro que só aprender de qualquer jeito não serve para muita coisa. Lembre-se do objetivo. Você não quer dominar C, quer apenas saber como uma linguagem mais concreta funciona. Não vai fazer aplicações com a linguagem, vai entender melhor todo o processo.

De fato, vagas não aparecerão muitas (mas tem) e elas exigem uma proficiência bem grande. Em C não dá para enganar como dá em linguagens mais abstratas.

Tem gente que não gosta da expressão, mas eu considero que programador de verdade sabe um pouco de C.

Assembly é bom dar uma olhada, não para programar, mas para ver como é, só para entender.

Eu estou para começar (finalmente) uma plataforma onde vou mostrar um pouco nessa pegada que poucos fazem, porque sinto falta disso. Esta semana começarei a comprar equipamentos e já registrei o domínio. Para quem está esperando, agora vai... :) Vou contar com ajuda das pessoas para saber o que elas querem ver por lá, desde que seja um pouco mais BE A BÁ, em um nível um pouco mais baixo. Sei que muitos não vão gostar. Uma pena.

Faz sentido para você?

Espero ter ajudado.

Farei algo que muitos pedem para aprender a programar corretamente, gratuitamente. Para saber quando, me segue nas suas plataformas preferidas. Quase não as uso, não terá infindas notificações (links aqui).

Sim estudar C e assembly vale muito a pena.
Mesmo que você jamais 'utilize' esses conhecimentos de forma direta, entender a fundo como um "programa de computador" funciona vai te tornar um "programador de computadores" mais competente e capaz, muito simples.

Eu acho que vale sim.
Me lembro que na faculdade, a primeira linguagem que vimos foi C.
O professor nos fazia implementar filas, listas encadeadas, árvores balanceadas em C puro, sem usar nenhuma lib auxiliar, com alocações de memória manual, etc.
Era bem difícil pra alunos do segundo período mas a gente aprendeu demais.
O professor dizia uma frase que guardei pra vida: "Não vou lhes ensinar a programar em C ou qualquer outra linguagem, vou ensinara programar. Ponto. Linguagem é ferramenta, se você aprendeu a programar direito, vai conseguir programar em qualquer linguagem."
E realmente o que ele disse fez muito sentido pra mim.
Teve uma outra disciplina na faculdade que a gente tinha que reimplementar algumas funções da libc em Assembly. Também fui bem difícil mas deu um conhecimento de como as coisas funcionam em outro nível.
Pulando pra hoje, atualmente trabalho em uma empresa que usa python + django + vue.
Tinha um processo que executava nos servidores em uma base de dados bem grande, que demorava por volta de 6 horas pra ser concluído. Eu consegui refazer esse mesmo processo, usando a mesma linguagem (python) pra ser executado em 2 ou 3 MINUTOS.
Então sim, aprenda mas tenha em mente o ensinamento do professor: "Linguagem é ferramenta", não se prenda a uma.

A pergunta de se "vale a pena" é muito, mas muito relativa e pessoal.

O que é "valer a pena" pra você?
Tu já falou que não vai ter essa matéria na faculdade, e também não vai utilizá-la para procurar emprego, então, olhando assim, não parece valer a pena.

Mas mesmo assim você se pergunta isso. O que mostra que você tem interesse em aprender sobre, logo, pra você, vale a pena.

Tu tá querendo estudar Assembly.. Depois aposto que vai arriscar fazer um "hello world" em binário. Então, vale a pena.

Você já disse que vai fazer isso por puro objetivo de aprendizado, e todo aprendizado é válido. Honestamente parece que esse tópico só foi criado para você ter um aval de pessoas que você não conhece para fazer algo que você já queria fazer desde o principio.

No fim, tanto faz se vale a pena ou não, se é oq tu quer fazer, pega e faz...

Sou bem suspeito pra falar porque trabalho diariamente com programação de sistemas embarcados, e embarcados só se programa em C/C++.
Sei programar em outras linguagens como Python e Javascript, e sempre escolho a que melhor me atende pra desenvolver algo. Raramente eu escolho C fora do contexto de embarcados, porque exige bastante nuanças e isso pode só dificultar um desenvolvimento que seria mais fácil se fosse em linguagens de mais alto nível.

Acredito que sim, vale a pena estudar C porque pra algo funcionar de forma correta e coerente, você precisa entender alguns fundamentos de computação. Coisa que linguagens de mais alto nível já faz pra você.

Vi que a galera está comentando sobre Assembly e concordo que vale a pena entender como funciona, mas desenvolver algo útil em Assembly é impraticável caso você esteja fora do contexto de embarcados.

Entenda o seguinte, o aprendizado em C que você procura é muito além de só codificar e aprender sintaxes. É entender o que significa ponteiros, como funciona alocação e leitura de memória, o que são endereços, o que são funções. Se você quiser ir pra coisas mais profundas ainda pode tentar fazer um driver de algum sensor com algum Arduino, mas daí já são coisas além.

Eu tive essa mesma duvida, só que no meu caso eu realmente quero poder trabalhar com essas linguagens de mais baixo nível e procurando na internet eu achei dois sites que parecem interessante.

O primeiro deles é este https://www.learn-c.org/ lá tem outras linguagens além de C acho que vale a pena dar uma olhada.

O segundo não é de C mas é de C++ https://www.learncpp.com/ diferente do primeiro esse eu já dei uma olhada no conteudo e é bem explicado e de fácil entendimento.

Seja qual for seu objetivo, aprender como funciona de baixo dos panos ou a realmente programar acho que vale a pena dar uma olhada nos dois sites.

Vale a pena estudar sim. O C é como o Latim das linguagens de programação moderna. Inclusive muitas reproduzem ou reproduziram em alguma versão sua sintaxe. Por exemplo, o if, for, while, do...while, switch, tudo se escreve da mesma forma em C, Java, C++, JavaScript, etc. Lógico q as versões mais modernas dessas linguagens já implementam outros estilos dessas estruturas. Por isso eu acho que quem começa a aprender por C já sabe bastante a sintaxe de outras linguagens. Ja Python é bem diferente. Se o C é o Latim, Python veio do Germânico kkk. Sintaxe totalmente única dela.

LikedAndrew, veja se esse material é de seu interesse:
https://www.ime.usp.br/~pf/algoritmos-livro

Concordo com as palavras do maniero

C é a linguagem de alto nível que permite você aprender como tudo funciona do jeito mais básico. Faz você entender melhor qualquer outra linguagem.

Aprender C à medida que também se aprende conceitos sobre algoritmos é um ganho extra. No site indicado é possível baixar o PDF do livro voltado para o ensino de algoritmos. Adota a linguagem C como ferramenta para por em prática o conteúdo.

Outros materiais podem ser encontrados na página deste Prof. da Universidade de São Paulo.

PS: Aproveito para deixar um pequeno programa escrito em C. Mostra três algoritmos que podem ser utilizados para exemplificar o cálculo da raiz quadrada de um número real positivo. Tratam-se meramente de exemplos didáticos, mas algoritmos semelhantes foram muito empregados quando os microprocessadores não contavam com uma FPU (Floating Point Unit) interna ou dispositivo opcional externo. Tudo quanto era função matemática (radiciações, logaritmos, funções trigonométricas, etc.) era realmente implementada em software. No caso do GW-BASIC, por exemplo, eram escritas em Assembly, se não me engano. Ah, em produção nos dias de hoje, adote o sqrt() ou sqrtl() da lib math.h que ela "dá conta" do processo! 8-)

/********************************************************** [ Keep coding! ] */
/*                                                                           */
/* Compile with: gcc -Wall -Wextra -Wpedantic -O2 -o sqrt.e sqrt.c           */
/*****************************************************************************/
#include <stdio.h>

#define TEST_VALUE      2.0
#define EXPECTED_ANSWER 1.41421356237309504880168872420969  /* Powered by BC */


/*****************************************************************************/
/* Purpose   : Function to obtain the absolute value of x                    */
/* Parameters:                                                               */
/*          x: Value of x                                                    */
/* Return    : Absolute value of the input value 'x'                         */
/* ------------------------------------------------------------------------- */
/* LastUpdate: 2024Apr16 - v.0.0.1                                           */
/*****************************************************************************/
double fabs(double x) {
  return (x<0.0)?-x:x;
}

/*****************************************************************************/
/* Purpose   : Function to compute square root using Newton's method         */
/* Parameters:                                                               */
/*          x: input value for which square root needs to be computed        */
/* Return    : Square root of the input value 'x'                            */
/* ------------------------------------------------------------------------- */
/* LastUpdate: 2024Apr16 - v.0.0.1                                           */
/*****************************************************************************/
double newton_square_root(double x) {
    double epsilon = 0.00001;
    double guess = x;
    while (fabs(guess * guess - x) >= epsilon) {
        guess = (guess + x / guess) / 2.0;
    }
    return guess;
}

/*****************************************************************************/
/* Purpose   : Function to compute square root using Binary Search method    */
/* Parameters:                                                               */
/*          x: input value for which square root needs to be computed        */
/* Return    : Square root of the input value 'x'                            */
/* ------------------------------------------------------------------------- */
/* LastUpdate: 2024Apr16 - v.0.0.1                                           */
/*****************************************************************************/
double binary_search_square_root(double x) {
    double low = 0.0;
    double high = x;
    double mid;
    double epsilon = 0.00001;
    while (high - low > epsilon) {
        mid = (low + high) / 2.0;
        if (mid * mid > x) {
            high = mid;
        } else {
            low = mid;
        }
    }
    return low;
}

/*****************************************************************************/
/* Purpose   : Function to compute square root using Babylonian method       */
/* Parameters:                                                               */
/*          x: input value for which square root needs to be computed        */
/* Return    : Square root of the input value 'x'                            */
/* ------------------------------------------------------------------------- */
/* LastUpdate: 2024Apr16 - v.0.0.1                                           */
/*****************************************************************************/
double babylonian_square_root(double x) {
    double guess = x;
    double epsilon = 0.00001;
    while (fabs(guess * guess - x) >= epsilon) {
        guess = 0.5 * (guess + x / guess);
    }
    return guess;
}

/*****************************************************************************/
/* Purpose   : This is the main function                                     */
/* Parameters:                                                               */
/*       none:                                                               */
/* Return    : 0                                                             */
/* ------------------------------------------------------------------------- */
/* Bugs      : unknown                                                       */
/* ToDo      : Improve the first guess value                                 */
/* LastUpdate: 2024Apr16 - v.0.0.1                                           */
/*****************************************************************************/
int main() {
    double x = TEST_VALUE;  /* An input value. */
                            /* Expected answer: 1.41421356237309504 */

    printf("Square root using Newton's method  : %12.8lf\n", \
                                                        newton_square_root(x));
    printf("Square root using binary search    : %12.8lf\n", \
                                                 binary_search_square_root(x));
    printf("Square root using Babylonian method: %12.8lf\n", \
                                                    babylonian_square_root(x));
    printf("Expected value                     : %12.8lf\n", EXPECTED_ANSWER);

    return 0;
}
/***************************************************** [ That's all folks! ] */

Após compilar o programa com o gcc gcc -Wall -Wextra -Wpedantic -O2 -o sqrt.e sqrt.c, basta executá-lo:

$ ./sqrt.e 
Square root using Newton's method  :   1.41421569
Square root using binary search    :   1.41420746
Square root using Babylonian method:   1.41421569
Expected value                     :   1.41421356

NOTA
As funções apresentadas carecem de otimização. Por exemplo, a escolha do chute inicial deve ser melhor explorada para acelerar a convergência da solução, principalmente quando o valor de x tem magnitude elevada. Uma proposta seria atuar diretamente sobre os bits do expoente do número que se encontra armazenado na representação IEEE 754.

Com base na minha experiencia pessoal, digo que vale muito, aprender C.
C é uma linguagem maravilhosa, mas que vai te dar logo um tapa na cara...

Esqueça seus "import tudopronto.py", esqueça sua programação dinamica, esqueça suas funções rápidas... C exige mais do cerebro, exige mais escrita, mais pensamento, mais conteudo. Um bom programador C leva anos para dominar a linguagem, e até os que chegam lá, ainda cometem deslizes vez ou outra(os erros de memoria provam isso).

C é o canivete suiço da computação, e você não vê um kernel em ruby, por exemplo. C tem tanta importancia que C++, Rust, Java, e mais trocentas linguagens compilada, interpretadas, transpiladas, etc, não conseguiram tirá-la de circulação. Isso porquê na mão certa, C ainda é a ferramenta mais eficaz.

Obviamente, as linguagens modernas como Java, JS, Python trazem uma grande vantagem aos programadores modernos, precisamos criar rapido, testar rapido, colocar em produção rapido... nosso ambiente é rapido, e nossas linguagens são muito eficientes nisso. Mas se você quer ter todo o poder da programação, ainda vale a pena escrever seu main.c, compilar, reescrever e compila-lo mais 200 vezes.

Quando um aprendiz Sith mata seu mestre, ele se torna Sith, quando um programador domina C, ele se torna programador haha

Opa!
No meu ver, vale sim a pena. Até te recomendo a assistir a um vídeo do Fábio Akita, em que discute a utilização de linguagens. Nele é possível ver a importância de C/C++. Talvez, ao final do vídeo fique ainda mais motivado em aprender C. Bons estudos!
Link: https://www.youtube.com/watch?v=MI9cdxETA4c

Meu ponto de vista é, se você está começando, sim vale muito. Mas se você já programa, acho que você consegue absorver o mesmo conhecimento, se você quer algo muito específico você pode primeiro conferir se a linguagem que você conhece tem algum recurso que te atenda, caso não, ai sim vale a pena estudar C para implementar esse recurso.

como está sendo o curso de ads?
qual a grade do primeiro semestre?

como pretende aprender?, por sinal? utilizando a documentação ou através de cursos?

vale a pena

Parei de ler quando vi a pessoa dizer que é programador/desenvolvedor falar que linguagem C é baixo nível.