Em sua forma mais simples, os programas apenas executam comandos de terminal?

Digamos, por exemplo, em um programa que me permite selecionar uma pasta e copiá-la para outro local, em um nível muito básico: o aplicativo executando comandos que eu poderia executar no terminal ou está usando alguma API interna do SO para fazer essa mudança?

Por favor, me poupe de quaisquer respostas cruéis; Só estou curioso e totalmente ciente de que isso pode ser percebido como uma pergunta que uma criança de 13 anos faria.

Conceitualmente, ele sempre usa a API do sistema operacional - a questão é apenas de que maneira. Existem essencialmente três opções.

1. usando a API do sistema operacional de baixo nível (chamadas do sistema) diretamente. No seu exemplo, a tarefa está bastante envolvida: obtenha a lista de itens da pasta, verifique o tipo (pasta, arquivo ...), pois cada um deles cria o item correspondente na pasta de destino, pois os arquivos leem o conteúdo do fonte, escreva no arquivo de destino etc. Como a tarefa é muito complexa, é fácil entender algo errado, de modo que a maioria dos aplicativos evita isso.

2. use uma biblioteca (API) que simplifica a tarefa. Por exemplo, a estrutura Apple Cocoa fornece à NSFileManagerclasse o copyItemAtPath:toPath:errormétodo que faz todo o trabalho sujo usando a API do sistema operacional de baixo nível; portanto, o aplicativo não precisa usar a API de baixo nível, mas pode confiar em algo que exige menos trabalho e é sempre presente no sistema. Também é provável que a Apple tenha certeza de que funciona bem.

3. use um processo externo para executar a tarefa. Nesse caso, o processo externo usará um dos dois métodos acima para fazer o trabalho. O aplicativo precisa iniciar esse processo, monitorá-lo e aguardar até que esteja pronto. É provável que esse processo possa ser executado como uma ferramenta de linha de comando; portanto, esse seria um comando que você pode executar no Terminal. Não é garantido, mas muito possível.

A maioria dos aplicativos usa a opção 2. porque é mais simples que 1. e mais segura e eficiente que 3. Para executar um processo externo, é necessário configurá-lo adequadamente e não ter controle sobre o que ele faz. Por exemplo, é muito mais difícil descobrir o que exatamente deu errado em caso de falha e é difícil saber o que está fazendo (por exemplo, mostrar o progresso). É por isso que, na maioria dos casos, os desenvolvedores provavelmente escolherão a opção 2, mas não há garantia. Um exemplo notável são aplicativos que usam scripts de shell para personalização - como instaladores.

Nota do usuário avançado: você pode usar o dtracerecurso do OS X para descobrir o que um aplicativo específico está fazendo. Por exemplo, você pode verificar qualquer processo que esteja gerando para ver as ferramentas que está usando (consulte execsnoop).

Receio que a resposta seja "depende, mas geralmente o segundo". Na verdade, mesmo que um programa GUI esteja executando comandos de terminal, ele será executado chamando uma API.

Um programa que é simplesmente uma lista de comandos do terminal é chamado de script de shell. Esses programas podem ser executados no Mac OS X, mas precisam ser executados em uma janela do Terminal ou iniciar um programa que usa a GUI, se você quiser ver a saída deles. Outros programas podem chamar programas de linha de comando por meio de APIs internas.

Embora a maioria das perguntas de desenvolvimento não seja atual para este site, um exemplo realmente atual envolve a execução do Automator.

Uma opção na lista de comandos internos que um programa criado no Automator pode chamar é a capacidade de chamar um shell script ou uma lista de comandos do Terminal. Mas essa é apenas uma das muitas opções disponíveis em sua API interna.

Uma das grandes idéias por trás do Unix é que (se) você tivesse uma idéia para um programa, primeiro a escreveria como um shell script - essencialmente chamando uma série de comandos.

Então, se o programa provou ser útil, você poderia melhorar sua interface, fazer com que os usuários o testassem e, finalmente, quando estava convencido de que valia a pena, escrever um programa "real".

Isso, é claro, ocorreu antes das interfaces gráficas do usuário assumirem, então um "programa" aqui é um comando da CLI em si.

Você ainda vê essa abordagem em alguns programas modernos, especialmente se eles mostram informações do sistema. Deseja criar um aplicativo simples para listar todos os arquivos em uma pasta? Basta executar ls -al, analisar o resultado e mostrar uma tabela. Divirta-se com os vários parâmetros e você tem seu material para a versão 2.0

Uma classe de programas que executam comandos de terminal (mesmo que tudo comece com uma chamada de API) são os ambientes integrados de desenvolvimento de programas, como eclipse ou Xcode. A coleção de ferramentas necessárias para o desenvolvimento do programa é proibitivamente grande para ser contida e mantida para um IDE. Em vez disso, ele cria um makefile (um tipo de script) e o executa com o 'make' do unix (ou equivalente) para percorrer o processo de compilação, vinculação, carregamento e depuração. Por sua vez, o Make executa o compilador, vinculador etc. usando suas interfaces de linha de comando. Isso permite que o IDE seja relativamente independente do conjunto de ferramentas escolhido pelo programador e insensível a atualizações nas ferramentas.

Os aplicativos podem executar comandos da CLI para executar uma determinada tarefa, e alguns realmente o fazem; mas devido a problemas de eficiência, os desenvolvedores de aplicativos profissionais evitam executar o comando e, em vez disso, usam as APIs que o comando usa para executar a tarefa necessária.