Papéis e palestras.
Caracteristicas do idioma.
Linguagem central.
Andrew K. Wright e Matthias Felleisen. Uma abordagem sintática para digitar a solidez. Em Informações & amp; Computation, 115 (1): 38'94, 1994. [PostScript de Gzip]
Este artigo descreve a semântica e o sistema de tipos do Core ML e usa uma técnica sintática simples para provar que programas bem tipados não podem dar errado.
François Pottier e Didier Ré © my. A essência da inferência de tipo ML. Em Benjamin C. Pierce, editor, Tópicos Avançados em Tipos e Linguagens de Programação, MIT Press, 2005.
Este capítulo do livro fornece uma descrição detalhada do sistema de tipo Core ML, com ênfase na inferência de tipos. O algoritmo de inferência de tipos é descrito como a composição de um gerador de restrição, que produz um sistema de equações de tipo e um solucionador de restrições, que é apresentado como um conjunto de regras de reescrita. [PostScript de Gzip]
Jacques Garrigue. Relaxando a restrição de valor. No Simpósio Internacional sobre Programação Funcional e Lógica, 2004. [PDF | PostScript Gzipado]
Este artigo explica por que é bom generalizar certas variáveis de tipo em uma associação let, mesmo quando a expressão que está sendo permitida não é um valor. Esta versão relaxada da clássica restrição de valor de Wright foi introduzida no OCaml 3.07.
Xavier Leroy. Tipos de manifesto, módulos e compilação separada. Em Princípios de Linguagens de Programação, 1994. [PDF | PostScript Gzipado | DVI gzipado]
Este artigo apresenta uma variante do sistema modular padrão ML que introduz uma distinção estrita entre os tipos abstrato e manifesto. Os últimos são tipos cujas definições aparecem explicitamente como parte de uma interface de módulo. Esta proposta destina-se a reter a maior parte do poder expressivo do sistema de módulos Standard ML, ao mesmo tempo que fornece um suporte muito melhor para compilação separada. Este trabalho define as bases formais para o sistema de módulos do OCaml.
Xavier Leroy. Functores de aplicação e módulos de alta ordem totalmente transparentes. Em Principies of Programming Languages, 1995. [PDF | PostScript Gzipado | DVI gzipado]
Este trabalho estende o artigo acima introduzindo os chamados functores aplicativos, isto é, functores que produzem tipos abstratos compatíveis quando aplicados a argumentos prováveis iguais. Functores de aplicação também são uma característica do OCaml.
Xavier Leroy. Um sistema de módulo modular. Em Journal of Functional Programming, 10 (3): 269-303, 2000. [PDF | PostScript Gzipado | DVI gzipado]
Este artigo acessível descreve uma implementação simplificada do sistema de módulos OCaml, enfatizando o fato de que o sistema de módulos é amplamente independente da linguagem principal subjacente. Este é um bom tutorial para aprender tanto como os módulos podem ser usados e como eles são typechecked.
Xavier Leroy. Uma proposta de módulos recursivos em Objective Caml. Não publicado [PDF | PostScript Gzipado]
Esta nota descreve os módulos recursivos experimentais introduzidos no OCaml 3.07.
Didier Rémy e Jérème Vouillon. Objetivo ML: Uma extensão efetiva orientada a objetos para ML. Em Teoria e Prática de Sistemas de Objetos, 4 (1): 27'50, 1998. [PDF | PostScript Gzipado | DVI gzipado]
Este artigo fornece fundamentos teóricos para a camada orientada a objeto do OCaml, incluindo semântica dinâmica e estática.
Jacques Garrigue e Didier Ré © my. Estendendo ML com polimorfismo de ordem superior semi-explícito. Em Informações & amp; Computation, 155 (1/2): 134 - 169, 1999. [PDF | PostScript Gzipado | DVI gzipado]
Este trabalho propõe um dispositivo para reintroduzir valores polimórficos de primeira classe em ML, preservando seu mecanismo de inferência de tipos. Esta tecnologia sustenta os métodos polimórficos do OCaml.
Variantes polimórficas.
Jacques Garrigue. Programação com variantes polimórficas. No ML Workshop, 1998. [PDF | PostScript Gzipado]
Este artigo explica brevemente o que são variantes polimórficas e como elas são compiladas.
Jacques Garrigue. Reutilização de código através de variantes polimórficas. No Workshop sobre Fundamentos de Engenharia de Software, 2000. [PostScript Gzipped]
Este breve artigo explica como projetar um intérprete modular e extensível usando variantes polimórficas.
Jacques Garrigue. Inferência de Tipo Simples para Polimorfismo Estrutural. No Workshop sobre fundamentos de linguagens orientadas a objetos, 2002. [PDF | PostScript Gzipado]
Este artigo explica a maioria das máquinas de typechecking por trás de variantes polimórficas. Em sua essência, há uma extensão da disciplina do tipo do Núcleo ML com as chamadas restrições locais.
Jacques Garrigue. Digitando correspondência profunda de padrões na presença de variantes polimórficas. No Workshop JSSST sobre Linguagens de Programação e Programação, 2004. [PDF | PostScript Gzipado]
Este artigo fornece mais detalhes sobre a maquinaria técnica por trás das variantes polimórficas, concentrando-se nas regras para digitar as construções de correspondência de padrões profundos.
Parâmetros rotulados e opcionais.
Jacques Garrigue. Argumentos rotulados e opcionais para o Objective Caml. No Workshop JSSST sobre Linguagens de Programação e Programação, 2001. [PDF | PostScript Gzipado | DVI gzipado]
Este artigo oferece uma semântica dinâmica, uma semântica estática e um esquema de compilação para os parâmetros de função rotulados e opcionais do OCaml.
Meta-Programação.
Jake Donham. Tutorial de programação Meta com CamlP4. Usuários comerciais de programação funcional, 2010.
Compiladores e Sistema de Runtime.
Bytecode Compiler e Bytecode Interpreter.
Xavier Leroy. O experimento ZINC, uma implementação econômica da linguagem ML. Relatório técnico 117, INRIA, 1990. [Gzipped PostScript | PDF]
Este relatório contém uma descrição do compilador ZINC, que posteriormente evoluiu para o Caml Light e depois para o OCaml. Grandes partes deste relatório estão desatualizadas, mas ainda são valiosas como uma descrição da máquina abstrata usada no Caml Light e (com algumas simplificações e melhorias de velocidade adicionais) no OCaml.
Compilador de código nativo.
Xavier Leroy. A eficácia do unboxing baseado em tipo. No Workshop sobre Tipos em Compilação, 1997. [PostScript | PDF]
Este artigo analisa e compara várias estratégias de representação de dados, incluindo a usada no compilador de códigos nativos OCaml.
Coletor de lixo.
Damien Doligez e Xavier Leroy. Um coletor de lixo geracional simultâneo para uma implementação multithread do ML. Em Princípios de Linguagens de Programação, 1993. [PostScript | PDF]
Substituído pelo próximo artigo.
Damien Doligez e Georges Gonthier. Coleta de lixo portátil e não obstrutiva para sistemas multiprocessadores. Em princípios de linguagens de programação, 1994. [PostScript | PDF]
Este artigo descreve uma versão concorrente do coletor de lixo encontrado no sistema de tempo de execução do Caml Light e do OCaml.
Damien Doligez. Concepção, distribuição e certificação de glaneur de cellules concorrente. Ph. D. tese, Université Paris 7, 1995. [PostScript | PDF]
Tudo o que você sempre quis saber sobre o coletor de lixo encontrado no sistema de tempo de execução do Caml Light e do OCaml.
Correspondência de padrões.
Fabrice Le Fessant e Luc Maranget. Otimizando a correspondência de padrões. Em Proceedings of the Sixth ACM SIGPLAN Conferência Internacional sobre Programação Funcional (ICFP), pp 26-37.
Usos industriais.
Yaron Minsky. OCAML para as missas. Fila ACM, 27 de setembro de 2011.
Anil Madhavapeddy. Xen e a arte do OCaml. Usuários comerciais de programação funcional (CUFP), 2008.
David Scott, Richard Mortier e Anil Madhavapeddy. Programando a nuvem Xen usando o OCaml. Workshop de Usuários e Desenvolvedores OCaml, 2012.
Pascal Cuoq, Julien Signoles, Patrick Baudin, Richard Bonichon, Géraud Canet, Loëc Correnson, Benjamin Monate, Virgile Prevosto, Armand Puccetti. Relatório de experiência: OCaml para uma estrutura de análise estática de força industrial. Anais da 14ª Conferência Internacional da ACM SIGPLAN sobre Programação Funcional, 2009.
Yaron Minsky, Stephen Weeks. Caml trading - experiências com programação funcional em Wall Street. Jornal de programação funcional.
Xavier Leroy. Usos industriais de Caml: exemplos e lições aprendidas da indústria de cartões inteligentes. Anais do 4º Workshop ACM SIGPLAN sobre Usuários Comerciais da Programação Funcional, 2007.
Jake Donham. De OCaml para Javascript no Skydeck.
Tom Wilkie. Acunu & amp; OCaml: Relatório de Experiência.
Xavier Leroy. Alguns usos de Caml na indústria. Usuários comerciais de programação funcional, 2007.
Warren Harris. Programação Funcional no Freebase. Usuários comerciais de programação funcional, 2010.
Sistema de negociação Ocaml
Obter via App Store Leia este post em nosso aplicativo!
Ocaml e Algorithmic Trading [fechado]
Sou completamente novo no domínio Algorithmic Trading. Acabei de concluir um curso baseado em Ocaml e li sobre Jane Street. Obviamente, eles são uma grande empresa com uma grande quantidade de recursos, mas é possível usar o Ocaml para pequenas negociações algorítmicas?
Eu sei que provavelmente parece ser uma pergunta estúpida, mas (pelo que descobri) não existem APIs de negociação para o Ocaml. Isso significaria que um teria que ser escrito do zero correto?
Qualquer insight seria muito apreciado caras, como eu disse que eu sou um noob completo para este domínio.
fechado como off topic por chrisaycock, Martin Clayton, Luc M, Dan Esparza, Peter O. 19 de abril de 2013 às 17:54.
Espera-se que as perguntas no Stack Overflow estejam relacionadas à programação dentro do escopo definido pela comunidade. Considere editar a pergunta ou deixar comentários para melhoria, se você acredita que a pergunta pode ser reformulada para se encaixar no escopo. Leia mais sobre a reabertura de perguntas aqui. Se essa questão puder ser reformulada para se ajustar às regras da Central de Ajuda, edite a pergunta.
Recentemente notei este pacote no Opam que poderia fornecer um ponto de partida para uma API de negociação: "O IBX é uma implementação OCaml pura da API do Interactive Brokers Trader Workstation (API do TWS) construída sobre as bibliotecas Core e Async da Jane Street."
Quanto aos algoritmos de negociação de código aberto em geral, este projeto começou recentemente: scarcecapital / hft /
Eu acho que esta questão é provavelmente muito aberta para o ambiente Stack Overflow para ser útil para você. O Stack Overflow é para quando você tem um problema específico que está tentando resolver.
Mas sendo opinativo, não posso deixar de dizer que OCaml pode ser muito bom para negociação algorítmica. O sistema de digitação forte e os dados imutáveis tendem a evitar erros e permitem que você codifique rapidamente. Isso, pelo menos, é o que eu encontrei. Mas você precisa conectar o OCaml às suas fontes de dados e ao seu canal de execução comercial, o que seria um trabalho extra. Não sabendo nada sobre essa área, não sei se existem bibliotecas para outros idiomas.
O mais provável é que as pessoas que estão realmente fazendo isso tenham um incentivo para manter seus segredos para si mesmas. Mas isso seria verdade, independentemente do idioma.
OCaml.
Programação orientada por tipo.
Um dos maiores pontos fortes do OCaml é seu poderoso sistema de tipo estático. O compilador OCaml é capaz de detectar automaticamente uma grande classe de erros, permitindo que o desenvolvedor corrija os problemas antes de liberar um software utilizável. Programas podem ser confiáveis, sem perder eficiência. Além disso, o compilador executa muitas análises em tempo de compilação, poupando verificações dispendiosas pelo tempo de execução da linguagem quando o programa é executado. É por isso que os programas OCaml são altamente otimizados e podem até ser mais rápidos que programas equivalentes em C, sendo, ao mesmo tempo, muito mais seguros!
Usuários Industriais.
Os usuários industriais do OCaml incluem grandes empresas de software como Microsoft ou Citrix, empresas financeiras como Jane Street Capital ou SimCorp e empresas de software críticas como CEA ou Dassault System.
Usuários industriais do OCaml documentaram as razões pelas quais eles usam o OCaml e como eles o usam. Esses recursos podem ser úteis para empresas que consideram o uso do OCaml em seu ambiente de produção.
Sistema de negociação Ocaml
Eu sempre noto que os da Jane Street retiram os aspectos OO do OCaml. O lugar que eu encontrei classes / objetos para vir a calhar é quando você escreve estruturas de software extensíveis. embora eu concorde, geralmente você pode fazer sem. No entanto, vale a pena observar como o OCaml aborda os objetos. bem diferente do que você encontraria em sua linguagem típica de estilo C ++ / Java / C #.
A falta de coletor de lixo simultâneo está realmente se tornando uma limitação com a tendência de maior número de núcleos em um único dado. No entanto, como o GC e o compilador são tão simples, o OCaml é uma dessas linguagens em que é possível observar o código do objeto e entender o que o compilador está fazendo. O que é ainda mais interessante é que, embora o compilador seja realmente simples, ele faz um trabalho fantástico na otimização. O criador da linguagem, Xavier Leroy, é frequentemente citado dizendo que "pior desempenho de 50% do código C".
Oh uma outra coisa. para aqueles que não tentaram uma linguagem funcional, acho que o OCaml oferece a melhor introdução. Você pode codificar imperativamente com isso, se quiser, mas vai se livrar disso a tempo em troca de técnicas funcionais mais declarativas. Ah e você não vai olhar para trás! ;)
O artigo também se refere ao compilador e otimizador simples do OCaml. Isso é surpreendente, considerando as apresentações de benchmark rápido do OCaml e a reputação das linguagens funcionais para o código lento e intensivo de memória. A equipe do OCaml está pesquisando otimizações mais avançadas ou "o pior desempenho de 50% do código C" é considerada boa o suficiente (em comparação com a troca de uma implementação mais complexa)?
Na minha experiência com o OCaml, você pode escrever código eficiente que se aproxima de velocidades de C / C ++ se você souber como funcionam os compiladores de linguagens funcionais. O maior matador de desempenho em linguagens funcionais é a implementação eficiente de fechamentos em uma máquina baseada em pilha (ou seja, problema de fun - cionamento). OCaml é inteligente na medida em que implementa registros de ativação na pilha se puder dizer que uma função não retornará um fechamento. Se você estiver escrevendo em um estilo altamente funcional, criará inerentemente muitos fechamentos e muitos registros de ativação baseados em heap (ou seja, menos eficientes). Ao mesmo tempo, o compilador pode fazer muitas otimizações interessantes que seriam difíceis em uma linguagem imperativa. Praticamente todos os livros do OCaml, incluindo o manual oficial, descrevem todos os vários lugares onde você pode ter penalidades de desempenho e o que o OCaml está fazendo sob o capô. Também como qualquer outro compilador funcional decente, o OCaml realiza muitos inlining, o que resulta em enormes ganhos de desempenho.
Uma coisa a notar, uma grande parte da razão pela qual o OCaml, assim como outras linguagens ML e o Haskell, têm um desempenho tão bom comparado a outras linguagens funcionais é devido à tipagem muito rígida e estática. Por exemplo, uma das restrições interessantes do sistema de tipos OCaml ao lidar com objetos é que você não pode fazer downcast de um objeto depois de ter sido upcast (por exemplo, um C ++ dynamic_cast). Embora essa restrição seja irritante, o código gerado nunca precisa fazer nenhuma verificação de tipo de tempo de execução - tudo é verificado estaticamente!
Tsuru Capital do FP e já anunciaram trabalhos na lista de discussão do haskell-cafe.
Eu corro tecnologia lá.
Sinta-se à vontade para me mandar um e-mail se você quiser saber mais.
Há vários bancos mencionados, como o Bank of America, o Barclays Capital e o Cedit Suisse. Uma empresa chamada Allston Trading aparentemente está usando Haskell para fazer alguns HFT também.
OCAML para as missas.
Por que a próxima língua que você aprende deve ser funcional.
Yaron Minsky, Jane Street.
Às vezes, a implementação elegante é uma função. Não é um método. Não é uma aula. Não é um quadro. Apenas uma função. John Carmack.
A programação funcional é uma ideia antiga com uma história distinta. Lisp, uma linguagem funcional inspirada no lambda calculus da Alonzo Church, foi uma das primeiras linguagens de programação desenvolvidas no alvorecer da era da computação. Linguagens funcionais tipificadas estaticamente como OCaml e Haskell são mais recentes, mas suas raízes são profundas - o ML, do qual elas descendem, remonta ao trabalho de Robin Milner no início dos anos 70, relacionado ao pioneiro provador de teoremas LCF (Logic for Computable Functions). .
A programação funcional também foi enormemente influente. Muitos avanços fundamentais no design da linguagem de programação, da coleta de lixo aos genéricos até a inferência de tipos, surgiram do mundo funcional e foram comuns décadas antes de chegarem a outras linguagens.
No entanto, as linguagens funcionais nunca chegaram ao mainstream. Eles chegaram mais perto, talvez, nos dias das máquinas Symbolics e Lisp, mas esses dias parecem bastante remotos agora. Apesar do ressurgimento da programação funcional nos últimos anos, continua sendo uma tecnologia mais comentada do que usada.
É tentador concluir, a partir desse registro, que as linguagens funcionais não têm o que é preciso. Eles podem fazer sentido para certos aplicativos limitados e conter conceitos úteis para serem importados para outros idiomas; mas as linguagens imperativas e orientadas a objetos são simplesmente mais adequadas para a grande maioria das tarefas de engenharia de software.
Por mais tentador que seja, essa conclusão está errada. Eu uso o OCaml em um ambiente de produção há quase uma década, e ao longo desse tempo me convenci de que as linguagens funcionais e, em particular, as tipificadas como OCaml e Haskell, são excelentes ferramentas de programação de propósito geral - melhor que qualquer linguagem mainstream existente. Eles também têm um alcance enorme, sendo adequados para pequenas tarefas de script, bem como aplicativos de alto desempenho em larga escala. Eles não são a ferramenta certa para todo trabalho, mas chegam surpreendentemente próximos.
O movimento para OCaml.
A maior parte da minha experiência em programação no OCaml veio através do meu trabalho na Jane Street, uma empresa financeira fundada em 2000. Nove anos atrás, ninguém na Jane Street tinha ouvido falar do OCaml. Hoje, a Jane Street é a maior usuária industrial do idioma, com quase dois milhões de linhas de código OCaml e 65 funcionários (que contam por último) que usam o idioma diariamente. Provavelmente, a melhor maneira de explicar o que faz do OCaml uma ferramenta tão eficaz é começar explicando como e por que essa transformação ocorreu. Para entender isso, primeiro você precisa entender algo sobre o que Jane Street faz.
O principal negócio da Jane Street é fornecer liquidez nos mercados eletrônicos do mundo. É essencialmente um intermediário. Ele coloca continuamente ordens para muitos títulos diferentes em várias bolsas diferentes. Cada pedido expressa a vontade de comprar ou vender determinado título a um determinado preço e, coletivamente, é uma propaganda para os mercados dos serviços da Jane Street. Por meio desses pedidos, a empresa compra de pessoas que precisam vender e vender para pessoas que precisam comprar, ganhando dinheiro com a diferença entre os preços de compra e venda. O tempo todo ele está competindo no preço com outros jogadores tentando fazer a mesma coisa.
A provisão de liquidez eletrônica é tecnologicamente intensa, não apenas por causa dos recursos computacionais que precisam ser implantados (uma enorme quantidade de dados precisa ser consumida, analisada e respondida em tempo real), mas também em termos da complexidade do processo. enterprise & mdash; a negociação pode cruzar várias trocas, regimes reguladores, classes de segurança e fusos horários. Gerenciar a complexidade resultante é uma tarefa difícil que requer um investimento significativo em software.
Toda essa tecnologia traz riscos. Não há maneira mais rápida de uma empresa comercial destruir a si mesma do que implantar um software de negociação que toma uma decisão incorreta repetidas vezes. Parte da reação da Jane Street a esses riscos tecnológicos era colocar um foco muito forte na criação de software que fosse facilmente compreendido - software legível.
O código de leitura fazia parte da abordagem da empresa ao risco antes de termos escrito nossa primeira linha de OCaml. No início, alguns dos operadores mais experientes (incluindo um dos fundadores) comprometeram-se a ler cada linha de código que entrava nos principais sistemas de negociação, antes de esses sistemas entrarem em produção. Este foi um enorme investimento contínuo em tempo e refletiu o alto nível de preocupação com o risco tecnológico.
Comecei na Jane Street um ano depois de terminar meu Ph. D., trabalhando lá em meio período enquanto fazia pós-doutorado. Meu trabalho na Jane Street estava focado na análise estatística e na otimização de estratégias de negociação, e o OCaml foi a principal ferramenta que usei para fazer a análise. Por que OCaml? Eu aprendi na pós-graduação e me apaixonei pela língua. E o OCaml foi uma ótima combinação para esse tipo de trabalho de prototipagem rápida: altamente eficiente, mas mais rápido e menos propenso a erros do que a codificação em C, C ++ ou Java.
Eu estava convencido de que minha passagem pela Jane Street seria curta e que o código que eu estava escrevendo era descartável, então fiz uma escolha para maximizar minha própria produtividade sem me preocupar se outras pessoas poderiam usar o código mais tarde. Seis meses e 80.000 linhas de código mais tarde, percebi que estava errado: ocupei uma posição de tempo integral na Jane Street e logo comecei a contratar para criar um grupo de pesquisa lá.
Neste momento, a empresa estava buscando uma nova abordagem para a construção de software. Os sistemas que impulsionaram a empresa em seus primeiros anos foram escritos principalmente em VBA e C #. De fato, os principais sistemas de negociação eram as planilhas do Excel com uma grande quantidade de código VBA personalizado. Essa foi uma ótima maneira de começar a trabalhar rapidamente, mas ficou claro desde o início que essa não era uma abordagem sustentável.
Em 2003, Jane Street começou a reescrever seus principais sistemas de negociação em Java. A reescrita acabou sendo abandonada, em parte porque o código resultante era muito difícil de ler e raciocinar sobre o assunto - muito mais difícil, na verdade, do que o VBA que estava sendo substituído. Uma grande parte disso foi a verbosidade de Java, mas foi mais do que isso. O código do VBA foi escrito em um estilo simples, direto e fácil de seguir. Mas, de alguma forma, ao codificar em Java, construímos um ninho de classes que deixava as pessoas coçando as cabeças quando queriam entender apenas qual parte do código estava realmente sendo invocada quando um determinado método era chamado. Código que fazia uso pesado de herança era particularmente difícil de se pensar, em parte por causa da maneira como a herança se desviava sob limites de abstração.
Em 2005, encorajada pelo sucesso do grupo de pesquisa, a Jane Street iniciou outra reescrita de seus principais sistemas de negociação, desta vez no OCaml. O primeiro protótipo foi feito em três meses e foi negociado três meses depois. O uso do OCaml na empresa só se expandiu desde então. Hoje ele é usado para resolver problemas em todas as partes da empresa, da contabilidade à administração de sistemas, e esse esforço continua a crescer. Nos últimos anos, o lado comercial da empresa aumentou o uso do idioma, e o treinamento do OCaml é agora uma parte padrão do currículo para novas contratações comerciais. No geral, a transição para o OCaml foi um enorme sucesso, resultando em uma tecnologia muito mais forte do que poderíamos ter conseguido de outra forma.
O que é sobre a linguagem que faz funcionar tão bem? Aqui está um breve resumo do que eu percebo como os principais pontos fortes do OCaml.
* Concisão. Nossa experiência com o OCaml no lado da pesquisa nos convenceu de que poderíamos construir sistemas menores, mais simples e mais fáceis de entender no OCaml do que em linguagens como Java ou C #. Para uma organização que valorizava a legibilidade, essa foi uma grande vitória.
* Detecção de bugs Os programadores que são novos no OCaml são frequentemente surpreendidos pelo grau em que o sistema de tipos detecta erros. A impressão que você tem é que, uma vez que você consiga que o typechecker aprove o seu código, não há mais bugs. Isso não é verdade, claro; O sistema de tipos do OCaml é indefeso contra muitos bugs. Há, no entanto, uma faixa surpreendentemente ampla de bugs contra os quais o sistema de tipos é eficaz, incluindo muitos bugs que são muito difíceis de se obter através do teste.
* Atuação. Descobrimos que o desempenho do OCaml estava no mesmo nível ou melhor do que o do Java, e a pouca distância de linguagens como C ou C ++. Além de ter um gerador de código de alta qualidade, o OCaml possui um GC incremental (coletor de lixo). Isso significa que o GC pode ser ajustado para fazer pequenos trechos de cada vez, tornando-o mais adequado para aplicativos em tempo real, como o comércio eletrônico.
* Pura, principalmente. Apesar de como os programadores funcionais costumam falar sobre isso, o estado mutável é uma parte fundamental da programação, e uma que não pode e não deve ser eliminada. Enviar um pacote de rede ou gravar no disco são exemplos de mutabilidade. Um compromisso completo com a imutabilidade é o compromisso de nunca construir nada real.
Estado mutável tem seus custos, no entanto. Geralmente, é mais fácil raciocinar sobre o código livre de mutações, tornando as interações e dependências entre diferentes partes da base de código explícitas e fáceis de gerenciar. O OCaml consegue um bom equilíbrio aqui, facilitando a mutação, mas fazendo com que os dados imutáveis estruturem o padrão. Um sistema OCaml bem escrito quase sempre tem estado mutável, mas esse estado é cuidadosamente limitado.
Talvez a mais fácil dessas vantagens para demonstrar concretamente é a da concisão. A importância da concisão é clara: outras coisas sendo iguais, o código mais curto é mais fácil de ler, mais fácil de escrever e mais fácil de manter. Existem, é claro, limites: nada de bom é feito reduzindo todos os nomes das funções a caracteres simples, mas a brevidade é importante, e o OCaml faz muito para ajudar a manter a base de código pequena.
Uma vantagem que o OCaml traz para a tabela é a inferência de tipos, o que elimina a necessidade de muitas declarações de tipo. Isso deixa você com um código que é aproximadamente tão compacto quanto o código escrito em linguagens dinâmicas, como Python e Ruby. Ao mesmo tempo, você obtém os benefícios de desempenho e correção dos tipos estáticos.
Considere o seguinte mapa de função OCaml para transformar os elementos de uma tupla.
Aqui, map é definido como uma função com dois argumentos: uma função f e uma tripla (x, y, z). Note que f x é a sintaxe para aplicar a função f a x.
Agora, considere como isso seria no C # 4.0. O código C #, embora funcionalmente equivalente, parece confuso, com a estrutura real obscurecida pelo ruído sintático.
Outra fonte de concisão é a notação de OCaml para descrever tipos. No coração dessa notação está a noção de um tipo de dados algébrico. Os tipos de dados algébricos são o que você obtém quando há um sistema que inclui duas maneiras de criar novos tipos: produtos e somas.
Um tipo de produto é o mais familiar dos dois. Tuplas, registros, estruturas e objetos são todos exemplos de tipos de produtos. Um tipo de produto combina vários valores de diferentes tipos em um único valor. Estes são chamados de tipos de produto porque correspondem matematicamente a produtos cartesianos dos tipos constituintes.
Um tipo de soma corresponde a uma união disjunta dos tipos constituintes, e é usado para expressar múltiplas possibilidades. Quando os tipos de produto são usados quando você tem várias coisas ao mesmo tempo (a e bec), os tipos de soma são usados quando você deseja enumerar diferentes possibilidades (a ou b ou c). Os tipos de soma podem ser simulados (embora um tanto desajeitados) em linguagens orientadas a objeto, como Java usando subclasses, e aparecem como tipos de união em C. Mas o suporte nos sistemas de tipos da maioria das linguagens para interagir com tipos de soma de maneira segura é surpreendentemente fraco.
A Figura 1 fornece um exemplo de tipos de dados algébricos no trabalho. O código define um tipo para representar expressões booleanas sobre um conjunto de predicados base e uma função para avaliar essas expressões. O código é genérico sobre o conjunto de predicados base, portanto, o assunto dessas expressões poderia ser qualquer coisa, desde desigualdades inteiras até as configurações dos sinalizadores do compilador.
O tipo de soma expr é indicado pelos tubos que separam os diferentes braços da declaração. Alguns desses braços, como True e False, são tags simples, não materialmente diferentes dos elementos de uma enumeração em Java ou C. Outros, como And e Not, possuem dados associados e os dados variam entre os casos. Esse tipo realmente contém somas e produtos, com as ramificações And e Or contendo tuplas. Tipos que consistem em combinações em camadas de produtos e somas são um idioma comum e poderoso no OCaml.
Um bit notável de sintaxe é a variável de tipo 'a. Uma variável de tipo pode ser instanciada com qualquer tipo e é isso que permite que o código seja genérico sobre o conjunto de predicados base. Isso é semelhante a como tipos genéricos são manipulados em Java ou C #. Assim, a lista de & lt; A & gt; de Java seria processada como 'uma lista no OCaml.
A função eval aceita dois argumentos: expr, a expressão a ser avaliada; e eval_base, uma função para avaliar predicados de base. O código é genérico no sentido de que eval pode ser usado para expressões sobre qualquer tipo de predicado base, mas eval_base deve ser fornecido para avaliar a verdade ou falsidade desses predicados base. A função eval 'é definida como uma abreviação para invocar chamadas recursivas para eval com eval_base como um argumento. Finalmente, a instrução de correspondência é usada para fazer uma análise de caso das estruturas possíveis da expressão, chamando eval_base ao avaliar um predicado de base e agindo como uma recursão direta sobre a estrutura dos tipos de dados.
A Figura 2 mostra como o mesmo código pode ser renderizado em Java. A verbosidade é imediatamente impressionante. Adicionar um único caso como E leva duas linhas (curtas) no OCaml e oito no Java - e o código Java é na verdade bastante minimalista conforme essas coisas acontecem. Se você quiser permitir a criação de outros algoritmos em torno desse tipo de expressão que não estejam integrados na definição de classe, provavelmente desejará usar o padrão de visitante, o que aumentará consideravelmente a contagem de linhas.
Outra faceta da linguagem que exige alguma explicação adicional é a capacidade do sistema de tipos de capturar erros. As pessoas que não estão familiarizadas com o OCaml e os idiomas relacionados (e alguns que são) muitas vezes cometem o erro de subestimar o poder do sistema de tipos. É fácil concluir que tudo o que o sistema de tipos faz para você é garantir que você forneceu os parâmetros corretamente (por exemplo, se você forneceu um ponto flutuante onde deveria fornecer um ponto flutuante).
Mas há mais do que isso. Até mesmo o uso ingênuo do sistema de tipos é estranhamente bom em pegar bugs. Considere o seguinte código Python para destruir uma lista (ou seja, removendo duplicatas sequenciais).
Este código parece bastante simples, mas tem um erro: ele não manipula adequadamente o final da lista. Aqui está uma maneira de consertar isso:
Agora vamos ver o que acontece quando se escreve mais ou menos a mesma função no OCaml, com mais ou menos o mesmo erro:
Isso usa a sintaxe de correspondência de padrões do OCaml para obter acesso aos elementos da lista. Aqui :: é o construtor da lista e [] indica uma lista vazia. Assim, o caso [] corresponde à lista vazia, e o caso x :: y :: rest corresponde a listas que possuem pelo menos dois elementos, x e y. A variável restante refere-se ao restante (potencialmente vazio) da lista.
Como o exemplo do Python, esse código falha em contemplar o que acontece quando você chega ao final da lista e tem apenas um elemento à esquerda. Nesse caso, no entanto, você descobre o problema não em tempo de execução, mas em tempo de compilação. O compilador fornece o seguinte erro:
O caso ausente, _ :: [], é uma lista com um único elemento.
Você pode corrigir o código (e satisfazer o compilador) adicionando um manipulador para o caso ausente:
O erro aqui é um erro trivial que seria facilmente encontrado testando. Mas o sistema de tipos funciona tão bem na exposição de erros que são difíceis de testar, seja porque eles aparecem apenas em casos de esquinas estranhos que são fáceis de perder nos testes, ou porque aparecem em sistemas complexos que são difíceis de falsificar e exercitar-se exaustivamente.
Straight out of the box, OCaml is pretty good at catching bugs, but it can do even more if you design your types carefully. Consider as an example the following types for representing the state of a network connection:
The connection_state type is a simple enumeration of three named states that the connection can be in; connection_info is a record type containing a number of fields describing different aspects of a connection. Note that the fields that have option at the end of the type are essentially nullable fields. (By default, values in OCaml are guaranteed to be non-null). Other than that, there's nothing about this code that's all that different from what you might write in Java or C#.
Here is some information on the individual record fields and how they relate to each other:
* server indicates the identity of the server on the other side of the connection.
* last_ping_time and last_ping_id are intended to be used as part of a keep-alive protocol. Note that either both of those fields should be present, or neither of them should. Also, they should be present only when state is Connected .
* The session_id is a unique identifier that is chosen afresh every time the connection is reestablished. It also should be present only when state is Connected .
* when_initiated is for keeping track of when the attempt to start the connection began, which can be used to determine when the attempt to connect should be abandoned. This should be present only when state is Connecting .
* when_disconnected keeps track of when the connection entered the Disconnected state, and should be present only in that state.
As you can see, a number of invariants tie the different record fields together. Maintaining such invariants takes real work. You need to document them carefully so you don't trip over them later; you need to write tests to verify the invariants; and you must exercise continuing caution not to break the invariants as the code evolves.
But we can do better. Consider the following rewrite:
We now have a combination of product and sum types that more precisely represents the set of allowable states of a connection. In particular, there is a different record type for each of the three states, each containing the information that is relevant just to that state. Information that is always relevant (in this case, just the server ) is pushed to the top-level record. Also, we've made it explicit that last_ping_time and last_ping_id are either both present or both absent by representing them as last_ping , which is an optional pair.
By doing all of this, we've embedded into the type many of the required invariants. Now that the invariants are part of the types, the compiler can detect and reject code that would violate these invariants. This is both less work and more reliable than maintaining such invariants by hand.
The example uses algebraic datatypes to encode invariants, but OCaml has other tools for doing the same. OCaml's module system is one example, allowing you to specify invariants in the interface of a module. Unlike most object-oriented languages, OCaml makes it possible to express complex joint invariants over multiple different types. More generally, OCaml's modules are a powerful tool for breaking down a codebase into small, understandable pieces, where the interactions between those pieces is under the programmer's explicit control.
The type system's ability to catch bugs is valuable even for small solitary projects, but it truly shines in a collaborative environment where multiple developers work together on a long-lived codebase. In addition to finding bugs, type signatures play a surprisingly valuable role as a kind of guaranteed-to-be-correct documentation. In the context of an evolving codebase, invariants enforced by the type system have the benefit of being more durable than those enforced by convention, in that they are less likely to be broken accidentally by another developer.
Limitações
None of this is to say that OCaml is without its flaws. There are, of course, all of the problems associated with being a minority language. OCaml has a great community that has generated a rich set of libraries, but that collection of libraries pales in comparison with what's available for Python, C, or Java. Similarly, development tools such as IDEs, profilers, and debuggers are there, but are considerably less mature and featureful than their cousins in more mainstream languages.
Another limitation of OCaml has to do with parallelism. The OCaml runtime has a single runtime lock, which means that one must use multiple processes to take advantage of multiple cores on a single machine. For the most part, this fits our development model well: we prefer message passing to shared-memory threads as a programming model for parallelism, since it leads to code that is easier to reason about and it scales better to systems that cross multiple physical machines. The tools available in the wider OCaml world for doing this kind of multiprocess programming, however, are still maturing.
But OCaml's limitations are not fundamental in nature. They have more to do with the details of the implementation or the popularity of the language and not with the language itself. In the end, that's what I find most puzzling. I am now quite convinced that the core ideas behind OCaml are enormously valuable, as evidenced by the fact that OCaml itself, whatever its limitations, is a profoundly effective and powerful tool. Yet, those ideas remain stubbornly outside of the mainstream.
Perhaps this is finally on the verge of changing. Languages such as F# and Scala are bringing some of the ideas behind OCaml and Haskell to a wider audience by integrating themselves within the Dotnet and Java ecosystems, respectively. Maybe 10 years from now, we'll no longer need to ask why these ideas have failed to catch on in the wider world. But there's no reason to wait. You can add OCaml to your toolbox now.
LOVE IT, HATE IT? LET US KNOW.
Yaron Minsky obtained his Ph. D. in computer science from Cornell University in 2002, focusing on distributed systems. In 2003, he joined Jane Street where he founded the quantitative research group, and since 2007 he has managed the technology group there.
&cópia de; 2011 ACM 1542-7730/11/0900 $10.00.
Understanding the proposed revisions to the C language.
Sometimes all you need is the right language.
A set of extensions to the Dart programming language, designed to support asynchrony and generator functions.
Revisiting Schorre's 1962 compiler-compiler.
Bilyan Borisov | Fri, 24 Jan 2014 15:01:30 UTC.
Ótimo artigo! In my opinion, most of the critics of OCaml in the comments have overlooked the fact that the language can be compiled down not only to byte code but also to native code. In the long run, a compiled application will always be faster than a Python-Ruby-Perl script.
Conciseness aside (even though I totally agree that functional languages, with OCaml as an example, are much more succinct than Java/C++), static typing and type inference are enormously good even for moderate and small sized projects. Again, this is all a personal preference, but logically speaking a dynamically typed language will 'let you do nasty things' like :
which evaluate to False in Python, which will give rise to a TON of bugs that only semantic testing can catch since this is syntactically OK.
Therefore, even if we assume that Python is as succinct as OCaml (or any other statically typed and compiled functional language) it will always be slower and will leave a larger margin for introducing bugs in huge codebases. However, again as the author suggests, Python does have a very serious advantage, namely, its extensive set of libraries but I personally think that they give the inexperienced programmer a false sense of awesomeness since you get the illusion of being able to do a lot without much effort.
At the end of the day languages are still tools and we still love them and defend them dearly so I guess everything goes in the 'which programming language is the best' discussion.
Kevin Kinnell | Thu, 11 Oct 2012 19:59:40 UTC.
"First class" is a CS definition, and according to that definition CL has first class functions. I got it wrong, because I didn't really say what I meant.
I should have said "easily usable first class functions."
Me desculpe por isso.
Jesse Talbutt | Sun, 19 Aug 2012 16:10:16 UTC.
Unless the robot in question is the one in the first scene of Robocop. Then I'd probably use a more strongly typed language.
Jesse Talbutt | Sun, 19 Aug 2012 15:59:42 UTC.
Common LISP does, in fact, have first-class functions. It's one of the sine qua nons of the language - i'm not sure how anyone could get that wrong.
The main difference between LISP and Scheme is that LISP uses separate namespaces for its functions and its variables, which is an abstract that's both incredibly powerful and incredibly dangerous: all it takes is one "clever" code-writer using that feature to crack open a closure and you get unpredictable side-effects. I read this article wondering "if they're going to use OCaml, why not just go whole hog and use LISP" but I see the issue now - OCaml is like a LISP where you sacrifice power that you'll probably never use in exchange for safety: likely a premium when you're dealing with large financial transactions in real-time instead of, say, creating a natural language DSL for robots.
Kevin Kinnell | Mon, 11 Jun 2012 23:17:33 UTC.
Drat. I meant "last few paragraphs." C'est l'ecriture.
Kevin Kinnell | Mon, 11 Jun 2012 23:03:35 UTC.
The readability of any code is related to knowledge of 1) the purpose of the code, 2) the language the code is written in, and 3) -- and please pardon the pun -- the knowledge of the coder.
One can argue that literate programming obviates (1) but what it actually seems to do in practice is to add a highly-technical natural-language narrative that wrecks the flow of the program. It becomes something like reading a legal brief. Fine -- if you're a lawyer, with extensive knowledge of the arcane (meta) language of law. My apologies, Dr. Knuth, but there it is. The actual cure for (1) is a combination of a good description of the purpose of the code, and good comments.
(3) is more or less a combination of innate ability and experience, whether we're talking about the writer or the reader of the code. I'd bet NO CODE reads like a natural language, but certainly there isn't any that reads like English. If you think it does, it's because you have ability and experience. Arguably, the process of "speaking" in a programming language seems to mirror the process of learning a natural language. In particular, the whole gamut of "native speakers" is there -- you can have babies talking to babies, babies talking to adults, well educated adults talking to less educated adults, etc. It's quite a bit of fun to observe. The knowledge of the coders, both the reader and the writer, is a big part of readability. Anybody who can make a language that somehow skirts this is, in my opinion, some sort of supernatural being.
That leaves (2), the language the code is written in. The closest-to-objective view of that is, I think, how quickly a reader can grasp the overall purpose of a coding sequence, and integrate that into the flow of a program. In other words, can the code be "grokked" easily?
You can create a language which makes this almost impossible to achieve -- APL comes to mind. No one could argue that APL isn't concise. Gaining the experience necessary to be able to read APL like a natural language is probably denied most ordinary mortals by their finite lifespan. I doubt that anyone can grok APL, even if they wrote the code.
At the other extreme there're COBOL and Java (one programmer's opinion, of course.) If you can actually grok code written in either of these you can make a pile of money, but you have sold your soul.
Lisps tend to be interrupted by their closing parentheses, but you can learn not to see them. Lisps also use a REPL, giving them the benefit of incremental coding. Unfortunately, except for Scheme dialects, functions aren't first-class in Lisps. Lisp can be grokked, but it's missing some expressive power, especially built-programmable types and type checking, making computation with types a huge burden on the programmer.
Perl goes beyond Lisp in concision, and its scope-control is as good as it gets. But Perl has a steep learning curve for fluency, and functions aren't really first-class, Perl lacks a usable REPL, and Perl is missing automated type checking.
OCaml manages to be concise, allows computation with types, makes functions first-class objects, has a visually clean syntax, has a REPL, does not require "purity" (thus allowing coder-readable access to the real world) and seems to be quite easy to learn--can you imagine a trading company requiring its traders to learn any of the languages in the last paragraph?
Well expressed OCaml code is easy to grok.
I think Dr. Minsky makes his case.
Fredrik Skeel Løkke | Tue, 13 Mar 2012 18:25:46 UTC.
It would be wonderfull to hear how the language plays out in the context of tests. Especially regarding tests involving stubbing of external resources.
Rowan | Fri, 09 Mar 2012 05:41:37 UTC.
@name on "more practical": Actually, monadic effects and the like are quite common in OCaml. In fact about 1 month before you posted your comment, Yaron (the author) also announced a new monadic concurrency library called Async: ocaml. janestreet/?q=node/100.
For unintended side-effects, it's more a library issue than a language issue: it's pretty easy in OCaml to encapsulate effects in a monadic library, and then only use the monadic versions, banning other uses or considering them unsafe in a similar sense to Haskell's "unsafePerformIO".
To me the main reason I tend not to use Haskell except for small projects is that I've hit the unintended side-effect of "allocating massive amounts of memory and thrashing or crashing" and sometimes been unable to resolve it without digging deep into the source code of multiple libraries written by different authors. This is improving in Haskell, but I'd still trust OCaml much more for critical systems like the one described.
gkannan | Thu, 12 Jan 2012 15:57:31 UTC.
name | Thu, 22 Dec 2011 22:27:19 UTC.
"more practical". Wow, those are weasel words if ever I heard them.
Haskell is way "more practical" (you see what I did there?) for me than O'Caml. O'Caml is great, but it doesn't even try to prevent unintended side-effects. (The whole Applicative/Semiring/Monoid/Monad/MonadT is insanely useful and rewarding if you just try it "fo' realz".)
Caml trading – experiences with functional programming on Wall Street.
Jane Street Capital is a successful proprietary trading company that uses OCaml as its primary development language. We have over twenty OCaml programmers and hundreds of thousands of lines of OCaml code. We use OCaml for a wide range of tasks: critical trading systems, quantitative research, systems software, and system administration. We value OCaml because it allows us to rapidly produce readable, correct, efficient code to solve complex problems, and to change that code quickly to adapt to a changing world. We believe that using OCaml gives us a significant advantage over competitors that use languages like VB, Perl, C++, C#, or Java. It also makes finding and hiring high-quality software developers easier than with mainstream languages. We have invested deeply in OCaml and intend to use OCaml and grow our team of functional programmers for the foreseeable future.
Email your librarian or administrator to recommend adding this journal to your organisation's collection.
ISSN: 0956-7968 EISSN: 1469-7653 URL: /core/journals/journal-of-functional-programming.
Altmetric attention score.
Visualizações de texto completo.
Full text views reflects the number of PDF downloads, PDFs sent to Google Drive, Dropbox and Kindle and HTML full text views.
Abstract views.
Abstract views reflect the number of visits to the article landing page.
* Views captured on Cambridge Core between September 2016 - 16th February 2018. This data will be updated every 24 hours.
Eu sempre noto que os da Jane Street retiram os aspectos OO do OCaml. O lugar que eu encontrei classes / objetos para vir a calhar é quando você escreve estruturas de software extensíveis. embora eu concorde, geralmente você pode fazer sem. No entanto, vale a pena observar como o OCaml aborda os objetos. bem diferente do que você encontraria em sua linguagem típica de estilo C ++ / Java / C #.
A falta de coletor de lixo simultâneo está realmente se tornando uma limitação com a tendência de maior número de núcleos em um único dado. No entanto, como o GC e o compilador são tão simples, o OCaml é uma dessas linguagens em que é possível observar o código do objeto e entender o que o compilador está fazendo. O que é ainda mais interessante é que, embora o compilador seja realmente simples, ele faz um trabalho fantástico na otimização. O criador da linguagem, Xavier Leroy, é frequentemente citado dizendo que "pior desempenho de 50% do código C".
Oh uma outra coisa. para aqueles que não tentaram uma linguagem funcional, acho que o OCaml oferece a melhor introdução. Você pode codificar imperativamente com isso, se quiser, mas vai se livrar disso a tempo em troca de técnicas funcionais mais declarativas. Ah e você não vai olhar para trás! ;)
O artigo também se refere ao compilador e otimizador simples do OCaml. Isso é surpreendente, considerando as apresentações de benchmark rápido do OCaml e a reputação das linguagens funcionais para o código lento e intensivo de memória. A equipe do OCaml está pesquisando otimizações mais avançadas ou "o pior desempenho de 50% do código C" é considerada boa o suficiente (em comparação com a troca de uma implementação mais complexa)?
Na minha experiência com o OCaml, você pode escrever código eficiente que se aproxima de velocidades de C / C ++ se você souber como funcionam os compiladores de linguagens funcionais. O maior matador de desempenho em linguagens funcionais é a implementação eficiente de fechamentos em uma máquina baseada em pilha (ou seja, problema de fun - cionamento). OCaml é inteligente na medida em que implementa registros de ativação na pilha se puder dizer que uma função não retornará um fechamento. Se você estiver escrevendo em um estilo altamente funcional, criará inerentemente muitos fechamentos e muitos registros de ativação baseados em heap (ou seja, menos eficientes). Ao mesmo tempo, o compilador pode fazer muitas otimizações interessantes que seriam difíceis em uma linguagem imperativa. Praticamente todos os livros do OCaml, incluindo o manual oficial, descrevem todos os vários lugares onde você pode ter penalidades de desempenho e o que o OCaml está fazendo sob o capô. Também como qualquer outro compilador funcional decente, o OCaml realiza muitos inlining, o que resulta em enormes ganhos de desempenho.
Uma coisa a notar, uma grande parte da razão pela qual o OCaml, assim como outras linguagens ML e o Haskell, têm um desempenho tão bom comparado a outras linguagens funcionais é devido à tipagem muito rígida e estática. Por exemplo, uma das restrições interessantes do sistema de tipos OCaml ao lidar com objetos é que você não pode fazer downcast de um objeto depois de ter sido upcast (por exemplo, um C ++ dynamic_cast). Embora essa restrição seja irritante, o código gerado nunca precisa fazer nenhuma verificação de tipo de tempo de execução - tudo é verificado estaticamente!
Tsuru Capital do FP e já anunciaram trabalhos na lista de discussão do haskell-cafe.
Eu corro tecnologia lá.
Sinta-se à vontade para me mandar um e-mail se você quiser saber mais.
Há vários bancos mencionados, como o Bank of America, o Barclays Capital e o Cedit Suisse. Uma empresa chamada Allston Trading aparentemente está usando Haskell para fazer alguns HFT também.
OCAML para as missas.
Por que a próxima língua que você aprende deve ser funcional.
Yaron Minsky, Jane Street.
Às vezes, a implementação elegante é uma função. Não é um método. Não é uma aula. Não é um quadro. Apenas uma função. John Carmack.
A programação funcional é uma ideia antiga com uma história distinta. Lisp, uma linguagem funcional inspirada no lambda calculus da Alonzo Church, foi uma das primeiras linguagens de programação desenvolvidas no alvorecer da era da computação. Linguagens funcionais tipificadas estaticamente como OCaml e Haskell são mais recentes, mas suas raízes são profundas - o ML, do qual elas descendem, remonta ao trabalho de Robin Milner no início dos anos 70, relacionado ao pioneiro provador de teoremas LCF (Logic for Computable Functions). .
A programação funcional também foi enormemente influente. Muitos avanços fundamentais no design da linguagem de programação, da coleta de lixo aos genéricos até a inferência de tipos, surgiram do mundo funcional e foram comuns décadas antes de chegarem a outras linguagens.
No entanto, as linguagens funcionais nunca chegaram ao mainstream. Eles chegaram mais perto, talvez, nos dias das máquinas Symbolics e Lisp, mas esses dias parecem bastante remotos agora. Apesar do ressurgimento da programação funcional nos últimos anos, continua sendo uma tecnologia mais comentada do que usada.
É tentador concluir, a partir desse registro, que as linguagens funcionais não têm o que é preciso. Eles podem fazer sentido para certos aplicativos limitados e conter conceitos úteis para serem importados para outros idiomas; mas as linguagens imperativas e orientadas a objetos são simplesmente mais adequadas para a grande maioria das tarefas de engenharia de software.
Por mais tentador que seja, essa conclusão está errada. Eu uso o OCaml em um ambiente de produção há quase uma década, e ao longo desse tempo me convenci de que as linguagens funcionais e, em particular, as tipificadas como OCaml e Haskell, são excelentes ferramentas de programação de propósito geral - melhor que qualquer linguagem mainstream existente. Eles também têm um alcance enorme, sendo adequados para pequenas tarefas de script, bem como aplicativos de alto desempenho em larga escala. Eles não são a ferramenta certa para todo trabalho, mas chegam surpreendentemente próximos.
O movimento para OCaml.
A maior parte da minha experiência em programação no OCaml veio através do meu trabalho na Jane Street, uma empresa financeira fundada em 2000. Nove anos atrás, ninguém na Jane Street tinha ouvido falar do OCaml. Hoje, a Jane Street é a maior usuária industrial do idioma, com quase dois milhões de linhas de código OCaml e 65 funcionários (que contam por último) que usam o idioma diariamente. Provavelmente, a melhor maneira de explicar o que faz do OCaml uma ferramenta tão eficaz é começar explicando como e por que essa transformação ocorreu. Para entender isso, primeiro você precisa entender algo sobre o que Jane Street faz.
O principal negócio da Jane Street é fornecer liquidez nos mercados eletrônicos do mundo. É essencialmente um intermediário. Ele coloca continuamente ordens para muitos títulos diferentes em várias bolsas diferentes. Cada pedido expressa a vontade de comprar ou vender determinado título a um determinado preço e, coletivamente, é uma propaganda para os mercados dos serviços da Jane Street. Por meio desses pedidos, a empresa compra de pessoas que precisam vender e vender para pessoas que precisam comprar, ganhando dinheiro com a diferença entre os preços de compra e venda. O tempo todo ele está competindo no preço com outros jogadores tentando fazer a mesma coisa.
A provisão de liquidez eletrônica é tecnologicamente intensa, não apenas por causa dos recursos computacionais que precisam ser implantados (uma enorme quantidade de dados precisa ser consumida, analisada e respondida em tempo real), mas também em termos da complexidade do processo. enterprise & mdash; a negociação pode cruzar várias trocas, regimes reguladores, classes de segurança e fusos horários. Gerenciar a complexidade resultante é uma tarefa difícil que requer um investimento significativo em software.
Toda essa tecnologia traz riscos. Não há maneira mais rápida de uma empresa comercial destruir a si mesma do que implantar um software de negociação que toma uma decisão incorreta repetidas vezes. Parte da reação da Jane Street a esses riscos tecnológicos era colocar um foco muito forte na criação de software que fosse facilmente compreendido - software legível.
O código de leitura fazia parte da abordagem da empresa ao risco antes de termos escrito nossa primeira linha de OCaml. No início, alguns dos operadores mais experientes (incluindo um dos fundadores) comprometeram-se a ler cada linha de código que entrava nos principais sistemas de negociação, antes de esses sistemas entrarem em produção. Este foi um enorme investimento contínuo em tempo e refletiu o alto nível de preocupação com o risco tecnológico.
Comecei na Jane Street um ano depois de terminar meu Ph. D., trabalhando lá em meio período enquanto fazia pós-doutorado. Meu trabalho na Jane Street estava focado na análise estatística e na otimização de estratégias de negociação, e o OCaml foi a principal ferramenta que usei para fazer a análise. Por que OCaml? Eu aprendi na pós-graduação e me apaixonei pela língua. E o OCaml foi uma ótima combinação para esse tipo de trabalho de prototipagem rápida: altamente eficiente, mas mais rápido e menos propenso a erros do que a codificação em C, C ++ ou Java.
Eu estava convencido de que minha passagem pela Jane Street seria curta e que o código que eu estava escrevendo era descartável, então fiz uma escolha para maximizar minha própria produtividade sem me preocupar se outras pessoas poderiam usar o código mais tarde. Seis meses e 80.000 linhas de código mais tarde, percebi que estava errado: ocupei uma posição de tempo integral na Jane Street e logo comecei a contratar para criar um grupo de pesquisa lá.
Neste momento, a empresa estava buscando uma nova abordagem para a construção de software. Os sistemas que impulsionaram a empresa em seus primeiros anos foram escritos principalmente em VBA e C #. De fato, os principais sistemas de negociação eram as planilhas do Excel com uma grande quantidade de código VBA personalizado. Essa foi uma ótima maneira de começar a trabalhar rapidamente, mas ficou claro desde o início que essa não era uma abordagem sustentável.
Em 2003, Jane Street começou a reescrever seus principais sistemas de negociação em Java. A reescrita acabou sendo abandonada, em parte porque o código resultante era muito difícil de ler e raciocinar sobre o assunto - muito mais difícil, na verdade, do que o VBA que estava sendo substituído. Uma grande parte disso foi a verbosidade de Java, mas foi mais do que isso. O código do VBA foi escrito em um estilo simples, direto e fácil de seguir. Mas, de alguma forma, ao codificar em Java, construímos um ninho de classes que deixava as pessoas coçando as cabeças quando queriam entender apenas qual parte do código estava realmente sendo invocada quando um determinado método era chamado. Código que fazia uso pesado de herança era particularmente difícil de se pensar, em parte por causa da maneira como a herança se desviava sob limites de abstração.
Em 2005, encorajada pelo sucesso do grupo de pesquisa, a Jane Street iniciou outra reescrita de seus principais sistemas de negociação, desta vez no OCaml. O primeiro protótipo foi feito em três meses e foi negociado três meses depois. O uso do OCaml na empresa só se expandiu desde então. Hoje ele é usado para resolver problemas em todas as partes da empresa, da contabilidade à administração de sistemas, e esse esforço continua a crescer. Nos últimos anos, o lado comercial da empresa aumentou o uso do idioma, e o treinamento do OCaml é agora uma parte padrão do currículo para novas contratações comerciais. No geral, a transição para o OCaml foi um enorme sucesso, resultando em uma tecnologia muito mais forte do que poderíamos ter conseguido de outra forma.
O que é sobre a linguagem que faz funcionar tão bem? Aqui está um breve resumo do que eu percebo como os principais pontos fortes do OCaml.
* Concisão. Nossa experiência com o OCaml no lado da pesquisa nos convenceu de que poderíamos construir sistemas menores, mais simples e mais fáceis de entender no OCaml do que em linguagens como Java ou C #. Para uma organização que valorizava a legibilidade, essa foi uma grande vitória.
* Detecção de bugs Os programadores que são novos no OCaml são frequentemente surpreendidos pelo grau em que o sistema de tipos detecta erros. A impressão que você tem é que, uma vez que você consiga que o typechecker aprove o seu código, não há mais bugs. Isso não é verdade, claro; O sistema de tipos do OCaml é indefeso contra muitos bugs. Há, no entanto, uma faixa surpreendentemente ampla de bugs contra os quais o sistema de tipos é eficaz, incluindo muitos bugs que são muito difíceis de se obter através do teste.
* Atuação. Descobrimos que o desempenho do OCaml estava no mesmo nível ou melhor do que o do Java, e a pouca distância de linguagens como C ou C ++. Além de ter um gerador de código de alta qualidade, o OCaml possui um GC incremental (coletor de lixo). Isso significa que o GC pode ser ajustado para fazer pequenos trechos de cada vez, tornando-o mais adequado para aplicativos em tempo real, como o comércio eletrônico.
* Pura, principalmente. Apesar de como os programadores funcionais costumam falar sobre isso, o estado mutável é uma parte fundamental da programação, e uma que não pode e não deve ser eliminada. Enviar um pacote de rede ou gravar no disco são exemplos de mutabilidade. Um compromisso completo com a imutabilidade é o compromisso de nunca construir nada real.
Estado mutável tem seus custos, no entanto. Geralmente, é mais fácil raciocinar sobre o código livre de mutações, tornando as interações e dependências entre diferentes partes da base de código explícitas e fáceis de gerenciar. O OCaml consegue um bom equilíbrio aqui, facilitando a mutação, mas fazendo com que os dados imutáveis estruturem o padrão. Um sistema OCaml bem escrito quase sempre tem estado mutável, mas esse estado é cuidadosamente limitado.
Talvez a mais fácil dessas vantagens para demonstrar concretamente é a da concisão. A importância da concisão é clara: outras coisas sendo iguais, o código mais curto é mais fácil de ler, mais fácil de escrever e mais fácil de manter. Existem, é claro, limites: nada de bom é feito reduzindo todos os nomes das funções a caracteres simples, mas a brevidade é importante, e o OCaml faz muito para ajudar a manter a base de código pequena.
Uma vantagem que o OCaml traz para a tabela é a inferência de tipos, o que elimina a necessidade de muitas declarações de tipo. Isso deixa você com um código que é aproximadamente tão compacto quanto o código escrito em linguagens dinâmicas, como Python e Ruby. Ao mesmo tempo, você obtém os benefícios de desempenho e correção dos tipos estáticos.
Considere o seguinte mapa de função OCaml para transformar os elementos de uma tupla.
Aqui, map é definido como uma função com dois argumentos: uma função f e uma tripla (x, y, z). Note que f x é a sintaxe para aplicar a função f a x.
Agora, considere como isso seria no C # 4.0. O código C #, embora funcionalmente equivalente, parece confuso, com a estrutura real obscurecida pelo ruído sintático.
Outra fonte de concisão é a notação de OCaml para descrever tipos. No coração dessa notação está a noção de um tipo de dados algébrico. Os tipos de dados algébricos são o que você obtém quando há um sistema que inclui duas maneiras de criar novos tipos: produtos e somas.
Um tipo de produto é o mais familiar dos dois. Tuplas, registros, estruturas e objetos são todos exemplos de tipos de produtos. Um tipo de produto combina vários valores de diferentes tipos em um único valor. Estes são chamados de tipos de produto porque correspondem matematicamente a produtos cartesianos dos tipos constituintes.
Um tipo de soma corresponde a uma união disjunta dos tipos constituintes, e é usado para expressar múltiplas possibilidades. Quando os tipos de produto são usados quando você tem várias coisas ao mesmo tempo (a e bec), os tipos de soma são usados quando você deseja enumerar diferentes possibilidades (a ou b ou c). Os tipos de soma podem ser simulados (embora um tanto desajeitados) em linguagens orientadas a objeto, como Java usando subclasses, e aparecem como tipos de união em C. Mas o suporte nos sistemas de tipos da maioria das linguagens para interagir com tipos de soma de maneira segura é surpreendentemente fraco.
A Figura 1 fornece um exemplo de tipos de dados algébricos no trabalho. O código define um tipo para representar expressões booleanas sobre um conjunto de predicados base e uma função para avaliar essas expressões. O código é genérico sobre o conjunto de predicados base, portanto, o assunto dessas expressões poderia ser qualquer coisa, desde desigualdades inteiras até as configurações dos sinalizadores do compilador.
O tipo de soma expr é indicado pelos tubos que separam os diferentes braços da declaração. Alguns desses braços, como True e False, são tags simples, não materialmente diferentes dos elementos de uma enumeração em Java ou C. Outros, como And e Not, possuem dados associados e os dados variam entre os casos. Esse tipo realmente contém somas e produtos, com as ramificações And e Or contendo tuplas. Tipos que consistem em combinações em camadas de produtos e somas são um idioma comum e poderoso no OCaml.
Um bit notável de sintaxe é a variável de tipo 'a. Uma variável de tipo pode ser instanciada com qualquer tipo e é isso que permite que o código seja genérico sobre o conjunto de predicados base. Isso é semelhante a como tipos genéricos são manipulados em Java ou C #. Assim, a lista de & lt; A & gt; de Java seria processada como 'uma lista no OCaml.
A função eval aceita dois argumentos: expr, a expressão a ser avaliada; e eval_base, uma função para avaliar predicados de base. O código é genérico no sentido de que eval pode ser usado para expressões sobre qualquer tipo de predicado base, mas eval_base deve ser fornecido para avaliar a verdade ou falsidade desses predicados base. A função eval 'é definida como uma abreviação para invocar chamadas recursivas para eval com eval_base como um argumento. Finalmente, a instrução de correspondência é usada para fazer uma análise de caso das estruturas possíveis da expressão, chamando eval_base ao avaliar um predicado de base e agindo como uma recursão direta sobre a estrutura dos tipos de dados.
A Figura 2 mostra como o mesmo código pode ser renderizado em Java. A verbosidade é imediatamente impressionante. Adicionar um único caso como E leva duas linhas (curtas) no OCaml e oito no Java - e o código Java é na verdade bastante minimalista conforme essas coisas acontecem. Se você quiser permitir a criação de outros algoritmos em torno desse tipo de expressão que não estejam integrados na definição de classe, provavelmente desejará usar o padrão de visitante, o que aumentará consideravelmente a contagem de linhas.
Outra faceta da linguagem que exige alguma explicação adicional é a capacidade do sistema de tipos de capturar erros. As pessoas que não estão familiarizadas com o OCaml e os idiomas relacionados (e alguns que são) muitas vezes cometem o erro de subestimar o poder do sistema de tipos. É fácil concluir que tudo o que o sistema de tipos faz para você é garantir que você forneceu os parâmetros corretamente (por exemplo, se você forneceu um ponto flutuante onde deveria fornecer um ponto flutuante).
Mas há mais do que isso. Até mesmo o uso ingênuo do sistema de tipos é estranhamente bom em pegar bugs. Considere o seguinte código Python para destruir uma lista (ou seja, removendo duplicatas sequenciais).
Este código parece bastante simples, mas tem um erro: ele não manipula adequadamente o final da lista. Aqui está uma maneira de consertar isso:
Agora vamos ver o que acontece quando se escreve mais ou menos a mesma função no OCaml, com mais ou menos o mesmo erro:
Isso usa a sintaxe de correspondência de padrões do OCaml para obter acesso aos elementos da lista. Aqui :: é o construtor da lista e [] indica uma lista vazia. Assim, o caso [] corresponde à lista vazia, e o caso x :: y :: rest corresponde a listas que possuem pelo menos dois elementos, x e y. A variável restante refere-se ao restante (potencialmente vazio) da lista.
Como o exemplo do Python, esse código falha em contemplar o que acontece quando você chega ao final da lista e tem apenas um elemento à esquerda. Nesse caso, no entanto, você descobre o problema não em tempo de execução, mas em tempo de compilação. O compilador fornece o seguinte erro:
O caso ausente, _ :: [], é uma lista com um único elemento.
Você pode corrigir o código (e satisfazer o compilador) adicionando um manipulador para o caso ausente:
O erro aqui é um erro trivial que seria facilmente encontrado testando. Mas o sistema de tipos funciona tão bem na exposição de erros que são difíceis de testar, seja porque eles aparecem apenas em casos de esquinas estranhos que são fáceis de perder nos testes, ou porque aparecem em sistemas complexos que são difíceis de falsificar e exercitar-se exaustivamente.
Straight out of the box, OCaml is pretty good at catching bugs, but it can do even more if you design your types carefully. Consider as an example the following types for representing the state of a network connection:
The connection_state type is a simple enumeration of three named states that the connection can be in; connection_info is a record type containing a number of fields describing different aspects of a connection. Note that the fields that have option at the end of the type are essentially nullable fields. (By default, values in OCaml are guaranteed to be non-null). Other than that, there's nothing about this code that's all that different from what you might write in Java or C#.
Here is some information on the individual record fields and how they relate to each other:
* server indicates the identity of the server on the other side of the connection.
* last_ping_time and last_ping_id are intended to be used as part of a keep-alive protocol. Note that either both of those fields should be present, or neither of them should. Also, they should be present only when state is Connected .
* The session_id is a unique identifier that is chosen afresh every time the connection is reestablished. It also should be present only when state is Connected .
* when_initiated is for keeping track of when the attempt to start the connection began, which can be used to determine when the attempt to connect should be abandoned. This should be present only when state is Connecting .
* when_disconnected keeps track of when the connection entered the Disconnected state, and should be present only in that state.
As you can see, a number of invariants tie the different record fields together. Maintaining such invariants takes real work. You need to document them carefully so you don't trip over them later; you need to write tests to verify the invariants; and you must exercise continuing caution not to break the invariants as the code evolves.
But we can do better. Consider the following rewrite:
We now have a combination of product and sum types that more precisely represents the set of allowable states of a connection. In particular, there is a different record type for each of the three states, each containing the information that is relevant just to that state. Information that is always relevant (in this case, just the server ) is pushed to the top-level record. Also, we've made it explicit that last_ping_time and last_ping_id are either both present or both absent by representing them as last_ping , which is an optional pair.
By doing all of this, we've embedded into the type many of the required invariants. Now that the invariants are part of the types, the compiler can detect and reject code that would violate these invariants. This is both less work and more reliable than maintaining such invariants by hand.
The example uses algebraic datatypes to encode invariants, but OCaml has other tools for doing the same. OCaml's module system is one example, allowing you to specify invariants in the interface of a module. Unlike most object-oriented languages, OCaml makes it possible to express complex joint invariants over multiple different types. More generally, OCaml's modules are a powerful tool for breaking down a codebase into small, understandable pieces, where the interactions between those pieces is under the programmer's explicit control.
The type system's ability to catch bugs is valuable even for small solitary projects, but it truly shines in a collaborative environment where multiple developers work together on a long-lived codebase. In addition to finding bugs, type signatures play a surprisingly valuable role as a kind of guaranteed-to-be-correct documentation. In the context of an evolving codebase, invariants enforced by the type system have the benefit of being more durable than those enforced by convention, in that they are less likely to be broken accidentally by another developer.
Limitações
None of this is to say that OCaml is without its flaws. There are, of course, all of the problems associated with being a minority language. OCaml has a great community that has generated a rich set of libraries, but that collection of libraries pales in comparison with what's available for Python, C, or Java. Similarly, development tools such as IDEs, profilers, and debuggers are there, but are considerably less mature and featureful than their cousins in more mainstream languages.
Another limitation of OCaml has to do with parallelism. The OCaml runtime has a single runtime lock, which means that one must use multiple processes to take advantage of multiple cores on a single machine. For the most part, this fits our development model well: we prefer message passing to shared-memory threads as a programming model for parallelism, since it leads to code that is easier to reason about and it scales better to systems that cross multiple physical machines. The tools available in the wider OCaml world for doing this kind of multiprocess programming, however, are still maturing.
But OCaml's limitations are not fundamental in nature. They have more to do with the details of the implementation or the popularity of the language and not with the language itself. In the end, that's what I find most puzzling. I am now quite convinced that the core ideas behind OCaml are enormously valuable, as evidenced by the fact that OCaml itself, whatever its limitations, is a profoundly effective and powerful tool. Yet, those ideas remain stubbornly outside of the mainstream.
Perhaps this is finally on the verge of changing. Languages such as F# and Scala are bringing some of the ideas behind OCaml and Haskell to a wider audience by integrating themselves within the Dotnet and Java ecosystems, respectively. Maybe 10 years from now, we'll no longer need to ask why these ideas have failed to catch on in the wider world. But there's no reason to wait. You can add OCaml to your toolbox now.
LOVE IT, HATE IT? LET US KNOW.
Yaron Minsky obtained his Ph. D. in computer science from Cornell University in 2002, focusing on distributed systems. In 2003, he joined Jane Street where he founded the quantitative research group, and since 2007 he has managed the technology group there.
&cópia de; 2011 ACM 1542-7730/11/0900 $10.00.
Understanding the proposed revisions to the C language.
Sometimes all you need is the right language.
A set of extensions to the Dart programming language, designed to support asynchrony and generator functions.
Revisiting Schorre's 1962 compiler-compiler.
Bilyan Borisov | Fri, 24 Jan 2014 15:01:30 UTC.
Ótimo artigo! In my opinion, most of the critics of OCaml in the comments have overlooked the fact that the language can be compiled down not only to byte code but also to native code. In the long run, a compiled application will always be faster than a Python-Ruby-Perl script.
Conciseness aside (even though I totally agree that functional languages, with OCaml as an example, are much more succinct than Java/C++), static typing and type inference are enormously good even for moderate and small sized projects. Again, this is all a personal preference, but logically speaking a dynamically typed language will 'let you do nasty things' like :
which evaluate to False in Python, which will give rise to a TON of bugs that only semantic testing can catch since this is syntactically OK.
Therefore, even if we assume that Python is as succinct as OCaml (or any other statically typed and compiled functional language) it will always be slower and will leave a larger margin for introducing bugs in huge codebases. However, again as the author suggests, Python does have a very serious advantage, namely, its extensive set of libraries but I personally think that they give the inexperienced programmer a false sense of awesomeness since you get the illusion of being able to do a lot without much effort.
At the end of the day languages are still tools and we still love them and defend them dearly so I guess everything goes in the 'which programming language is the best' discussion.
Kevin Kinnell | Thu, 11 Oct 2012 19:59:40 UTC.
"First class" is a CS definition, and according to that definition CL has first class functions. I got it wrong, because I didn't really say what I meant.
I should have said "easily usable first class functions."
Me desculpe por isso.
Jesse Talbutt | Sun, 19 Aug 2012 16:10:16 UTC.
Unless the robot in question is the one in the first scene of Robocop. Then I'd probably use a more strongly typed language.
Jesse Talbutt | Sun, 19 Aug 2012 15:59:42 UTC.
Common LISP does, in fact, have first-class functions. It's one of the sine qua nons of the language - i'm not sure how anyone could get that wrong.
The main difference between LISP and Scheme is that LISP uses separate namespaces for its functions and its variables, which is an abstract that's both incredibly powerful and incredibly dangerous: all it takes is one "clever" code-writer using that feature to crack open a closure and you get unpredictable side-effects. I read this article wondering "if they're going to use OCaml, why not just go whole hog and use LISP" but I see the issue now - OCaml is like a LISP where you sacrifice power that you'll probably never use in exchange for safety: likely a premium when you're dealing with large financial transactions in real-time instead of, say, creating a natural language DSL for robots.
Kevin Kinnell | Mon, 11 Jun 2012 23:17:33 UTC.
Drat. I meant "last few paragraphs." C'est l'ecriture.
Kevin Kinnell | Mon, 11 Jun 2012 23:03:35 UTC.
The readability of any code is related to knowledge of 1) the purpose of the code, 2) the language the code is written in, and 3) -- and please pardon the pun -- the knowledge of the coder.
One can argue that literate programming obviates (1) but what it actually seems to do in practice is to add a highly-technical natural-language narrative that wrecks the flow of the program. It becomes something like reading a legal brief. Fine -- if you're a lawyer, with extensive knowledge of the arcane (meta) language of law. My apologies, Dr. Knuth, but there it is. The actual cure for (1) is a combination of a good description of the purpose of the code, and good comments.
(3) is more or less a combination of innate ability and experience, whether we're talking about the writer or the reader of the code. I'd bet NO CODE reads like a natural language, but certainly there isn't any that reads like English. If you think it does, it's because you have ability and experience. Arguably, the process of "speaking" in a programming language seems to mirror the process of learning a natural language. In particular, the whole gamut of "native speakers" is there -- you can have babies talking to babies, babies talking to adults, well educated adults talking to less educated adults, etc. It's quite a bit of fun to observe. The knowledge of the coders, both the reader and the writer, is a big part of readability. Anybody who can make a language that somehow skirts this is, in my opinion, some sort of supernatural being.
That leaves (2), the language the code is written in. The closest-to-objective view of that is, I think, how quickly a reader can grasp the overall purpose of a coding sequence, and integrate that into the flow of a program. In other words, can the code be "grokked" easily?
You can create a language which makes this almost impossible to achieve -- APL comes to mind. No one could argue that APL isn't concise. Gaining the experience necessary to be able to read APL like a natural language is probably denied most ordinary mortals by their finite lifespan. I doubt that anyone can grok APL, even if they wrote the code.
At the other extreme there're COBOL and Java (one programmer's opinion, of course.) If you can actually grok code written in either of these you can make a pile of money, but you have sold your soul.
Lisps tend to be interrupted by their closing parentheses, but you can learn not to see them. Lisps also use a REPL, giving them the benefit of incremental coding. Unfortunately, except for Scheme dialects, functions aren't first-class in Lisps. Lisp can be grokked, but it's missing some expressive power, especially built-programmable types and type checking, making computation with types a huge burden on the programmer.
Perl goes beyond Lisp in concision, and its scope-control is as good as it gets. But Perl has a steep learning curve for fluency, and functions aren't really first-class, Perl lacks a usable REPL, and Perl is missing automated type checking.
OCaml manages to be concise, allows computation with types, makes functions first-class objects, has a visually clean syntax, has a REPL, does not require "purity" (thus allowing coder-readable access to the real world) and seems to be quite easy to learn--can you imagine a trading company requiring its traders to learn any of the languages in the last paragraph?
Well expressed OCaml code is easy to grok.
I think Dr. Minsky makes his case.
Fredrik Skeel Løkke | Tue, 13 Mar 2012 18:25:46 UTC.
It would be wonderfull to hear how the language plays out in the context of tests. Especially regarding tests involving stubbing of external resources.
Rowan | Fri, 09 Mar 2012 05:41:37 UTC.
@name on "more practical": Actually, monadic effects and the like are quite common in OCaml. In fact about 1 month before you posted your comment, Yaron (the author) also announced a new monadic concurrency library called Async: ocaml. janestreet/?q=node/100.
For unintended side-effects, it's more a library issue than a language issue: it's pretty easy in OCaml to encapsulate effects in a monadic library, and then only use the monadic versions, banning other uses or considering them unsafe in a similar sense to Haskell's "unsafePerformIO".
To me the main reason I tend not to use Haskell except for small projects is that I've hit the unintended side-effect of "allocating massive amounts of memory and thrashing or crashing" and sometimes been unable to resolve it without digging deep into the source code of multiple libraries written by different authors. This is improving in Haskell, but I'd still trust OCaml much more for critical systems like the one described.
gkannan | Thu, 12 Jan 2012 15:57:31 UTC.
name | Thu, 22 Dec 2011 22:27:19 UTC.
"more practical". Wow, those are weasel words if ever I heard them.
Haskell is way "more practical" (you see what I did there?) for me than O'Caml. O'Caml is great, but it doesn't even try to prevent unintended side-effects. (The whole Applicative/Semiring/Monoid/Monad/MonadT is insanely useful and rewarding if you just try it "fo' realz".)
Caml trading – experiences with functional programming on Wall Street.
Jane Street Capital is a successful proprietary trading company that uses OCaml as its primary development language. We have over twenty OCaml programmers and hundreds of thousands of lines of OCaml code. We use OCaml for a wide range of tasks: critical trading systems, quantitative research, systems software, and system administration. We value OCaml because it allows us to rapidly produce readable, correct, efficient code to solve complex problems, and to change that code quickly to adapt to a changing world. We believe that using OCaml gives us a significant advantage over competitors that use languages like VB, Perl, C++, C#, or Java. It also makes finding and hiring high-quality software developers easier than with mainstream languages. We have invested deeply in OCaml and intend to use OCaml and grow our team of functional programmers for the foreseeable future.
Email your librarian or administrator to recommend adding this journal to your organisation's collection.
ISSN: 0956-7968 EISSN: 1469-7653 URL: /core/journals/journal-of-functional-programming.
Altmetric attention score.
Visualizações de texto completo.
Full text views reflects the number of PDF downloads, PDFs sent to Google Drive, Dropbox and Kindle and HTML full text views.
Abstract views.
Abstract views reflect the number of visits to the article landing page.
* Views captured on Cambridge Core between September 2016 - 16th February 2018. This data will be updated every 24 hours.
No comments:
Post a Comment