Palestras e publicações

Conferências e palestras

Nobody Can Program Correctly. A Practical and Interactive Guide to Debugging C++ Code (Ninguém consegue programar corretamente. Um guia prático e interativo para depuração do código em C++
Sebastian Theophil

Gostaríamos de escrever o código, mas, apesar de nossos melhores esforços, cometemos erros. Nosso programa conterá bugs. Algumas vezes, não escrevemos o que queremos escrever, algumas vezes não entendemos um aspecto de nossa linguagem de programação e outras vezes não consideramos algumas informações críticas sobre nosso ambiente do sistema de programação. Como resultado, nosso programa não terá o comportamento esperado. O que fazemos agora? Nesta palestra, gostaria de falar sobre todo o processo de depuração, começando com um programa que trava. O que fazemos depois? Quais perguntas temos de fazer? Quais informações precisamos? O que podemos fazer para descobrir a causa do problema? Quais ferramentas nos ajudam nesta busca e, finalmente, o que podemos fazer para garantir que este bug nunca mais volte a acontecer? Graças a exemplos do mundo real que encontramos e depuramos na think-cell ao longo dos anos, você aprenderá como reproduzir, localizar, entender e corrigir, mesmo os erros mais difíceis.


Typescripten — Generating type-safe JavaScript bindings for emscripten (Typescripten - Gerar vinculações ao JavaScript seguras em relação ao tipo para emscripten)
Sebastian Theophil

O WebAssembly se tornou uma plataforma alvo muito popular para os desenvolvedores de C++. Graças a emscripten, portar aplicativos nativos para o WebAssembly é fácil, desde que o aplicativo use apenas o navegador como dispositivo de exibição e de entrada. No entanto, a emscripten não fornece invólucros de segurança em relação ao tipo para as APIs JavaScript padrão, como a API de manipulação de DOM, muito menos qualquer outra API JavaScript fornecida por aplicativos Web existentes. Nossa ferramenta de código aberto “typescripten” foi construída com base em três tecnologias poderosas para fechar essa lacuna. Ela usa arquivos de definição de interface TypeScript e a API do compilador de TypeScript para criar invólucros C++ seguros em relação ao tipo, com base em emscripten. O TypeScript já tem arquivos de definição de interface para mais de 7.000 bibliotecas JavaScript que você agora pode usar com segurança do C++. Lutamos para desenhar nossos invólucros de C++ para que o código de C++ que os usa pareça semelhante ao TypeScript ou ao código JavaScript equivalente. No entanto, a semântica peculiar do Javascript e do Typescript baseados em protótipo é geralmente difícil de converter em uma linguagem baseada em tipo, como o C++. Eu discutirei os desafios que enfrentamos e as escolhas que fizemos ao criar essa estrutura.


Windows, macOS e a Web: Lessons from cross-platform development at think-cell (Windows, macOS e a Web: Lições de desenvolvimento de multiplataformas na think-cell)
Sebastian Theophil

Durante doze anos, a think-cell tinha sido uma empresa de software que usava apenas Windows e nossa base de código de aproximadamente 700.000 linhas de código tinha acumulado muitas dependências de plataforma não intencionais. Seis anos atrás, decidimos portar nosso aplicativo para Mac. Essa mudança afetou todas as partes de nosso processo de desenvolvimento: a organização do projeto, o sistema de builds e a forma como programamos em C++ hoje. As bibliotecas em várias plataformas comumente usadas, como Qt e Boost eram boas ferramentas a serem usadas, mas, sozinhas, não eram o suficiente. Para muitos conceitos, como mutexes, semáforos ou memória compartilhada, eles oferecem apenas uma interface comum para objetos específicos de plataforma, com semântica e duração muito diferentes. Queríamos abstrações de C++ leves e independentes de plataforma, com semântica idêntica para renderização, internacionalização, E/S de arquivo, tratamento de evento do mouse, chamadas de RPC e relatórios de erros. Desenvolver isso foi desafiador em um primeiro momento, pois tínhamos que definir qual semântica nosso aplicativo precisava e, em segundo lugar, tivemos que implementá-la em cada plataforma. Esse processo não foi fácil, mas eu diria que melhorou muito a qualidade de nosso código. Agora, fomos para o próximo desafio e começamos a mover algumas funcionalidades para aplicativos Web. Queríamos reutilizar nossa base de código existente, claro, e isso significava escrever aplicativos Web em C++ expressivo e seguro em relação ao tipo. Definitivamente, uma vantagem em nosso catálogo! Criamos nossos aplicativos Web usando emscripten, mas geramos vinculações C++ seguras em relação ao tipo de qualquer definição de interface TypeScript. Na minha palestra, apresentarei uma visão geral das abstrações C++ que implementamos, concentrando-me nas áreas problemáticas das várias plataformas em que a semântica comum era difícil definir devido a limitações dos sistemas operacionais. Além disso, obviamente, mostrarei nossas ferramentas que permitem escrever um aplicativo da Web em C++.


O desastre da duração do rvalue do C++
Arno Schödl

As referências a rvalue estão conosco desde o C++11. Elas foram introduzidas, originalmente, para maior eficiência ao mover objetos: espera-se que o objeto, uma referência, referências a rvalue, saia fora do escopo logo e, portanto, pode ter seus recursos eliminados sem prejuízo nenhum. A biblioteca padrão do C++, por exemplo, std::cref ou std::ranges, usa, ainda, um outro aspecto de referências a rvalue: como elas vão ficar fora do escopo em breve, espera-se que não seja seguro mantê-las além do escopo da função atual, embora referências a lvalue sejam consideradas seguras. Nós, também, achamos isso muito útil para gerenciamento de memória inteligente, especificamente em código genérico.
Infelizmente, a linguagem C++ em si, viola isso. Rvalues se vinculam a const&. Isso significa que funções de aparência inocente convertem, silenciosamente, referências a rvalues para referências a lvalue, ocultando qualquer limitação de duração dos rvalues. A extensão de duração temporária deve tornar uma ligação temporária a uma referência segura, ampliando a duração do temporário. Mas isso funciona apenas enquanto o temporário for um prvalue e já quebra com as referências a rvalue, sem falar nas referências a lvalue falsamente geradas. Esses problemas não são meramente teóricos. Tivemos corrupção de memória difícil de encontrar em nosso código, devido a esses problemas. Na palestra, descreverei os problemas em detalhes, apresentarei uma abordagem única à biblioteca para mitigar os problemas e, finalmente, farei uma proposta sobre como consertar as coisas.


Melhores intervalos de C++
Arno Schödl

Os intervalos estão no C++ padrão há um tempo agora e continuaram nas bases de código modernas. Na think-cell, estamos desenvolvendo e usando nossa própria biblioteca de intervalos há 20 anos, construída em cima do padrão e é compatível com ele, mas vai além, em muitos aspectos. Os adaptadores de intervalos são geralmente empilhados, um filtro em cima de um transformador, em cima de etc. Para tornar esse tipo de pilha eficiente, os iteradores não são bons o suficiente. Usamos um novo conceito que é mais eficiente e ao mesmo tempo compatível com iteradores, para que os usuários da biblioteca possam continuar usando os iteradores, como faziam antes. A biblioteca padrão é muito rígida sobre a distinção entre recipientes e visualizações e os adaptadores de intervalos são exibições que devem manter uma referência em relação aos dados sendo adaptados. Em vez disso, permitimos os adaptadores de intervalos manterem os dados eles mesmos, para torná-los autocontidos e avaliados de forma ociosa ao mesmo tempo. O modelo de iterador padrão só permite interação externa. No entanto, a iteração externa é geralmente muito mais fácil de implementar do que a iteração externa. Para muitas aplicações, a iteração interna é completamente adequada e mais eficiente do que a iteração externa. Portanto, levamos a iteração interna para a família de intervalos, até o ponto em que o usuário da biblioteca pode não saber, ou não se importar, com o tipo de iteração sendo usada. Algoritmos padrão retornam iterações e usam o iterador final para sinalizar algum estado único. Ao personalizar os valores de retorno, podemos tornar nosso código mais conciso e expressivo, por exemplo, eliminando essas temíveis verificações de extremidade de iterador. Esses recursos combinados fazem dos intervalos uma ferramenta excelente para formatação de texto. Nós podemos usar esses intervalos para representar os valores a serem formatados, conceitualmente transformando-os em sequências avaliadas ociosamente. Eles podem ser usados assim como as sequências regulares são usadas hoje: em retorno de funções; como entrada de algoritmo padrão; incorporados em outras sequências igualmente avaliadas de forma ociosa; e assim por diante, antes que eles finalmente se expandam para exibição. Ao escolher as interfaces certas, podemos otimizar essa expansão em tempo de compilação, permitindo uma sintaxe agradável e um desempenho muito próximo ao código otimizado manualmente.


Range-Based Text Formatting - Text Formatting For a Future Range-Based Standard Library (Formatação de texto baseada em intervalos - Formatação de texto para uma futura biblioteca padrão com base em intervalos)
Arno Schödl

Há muito tempo, a formatação de texto tem sido um dos problemas favoritos dos autores de biblioteca C++. Nesta palestra, eu quero convencer você de que a combinação de intervalos com um pouco de metaprogramação é uma solução muito elegante para o problema de formatação de texto. Nós introduzimos uma forma de intervalos com iteração interna, a qual está gerando seus elementos um por um, em vez de expor iteradores externos. Nós podemos usar esses intervalos de geradores para representar os valores a serem formatados, conceitualmente transformando-os em sequências avaliadas ociosamente. Eles podem ser usados assim como as sequências regulares são usadas hoje: em retorno de funções; como entrada de algoritmo padrão; incorporados em outras sequências igualmente avaliadas de forma ociosa; e assim por diante, antes que eles finalmente se expandam em um contêiner. Ao escolher as interfaces corretas, nós podemos otimizar esta expansão a ponto de que seja apenas 15% mais lenta do que criando a sequência equivalente usando o código de caso especial otimizado manualmente.


Why Iterators Got It All Wrong — and what we should use instead (Por que os iteradores fizeram tudo errado e o que deveríamos usar em vez disso)
Arno Schödl

Você entende de iteradores, certo? Gostaria de descrevê-los? "Iteradtores são usados para indicar sequências de elementos." Parece bom? Mais recentemente, o conceito de intervalos foi introduzido para significar qualquer coisa que exponha iteradores. Em particular, os intervalos incluem adaptadores para transformação ociosa ou sequências de elementos de filtro, e eles também possuem iteradores.
Tudo certo? Infelizmente, não. O conceito de iterador que temos usado desde o advento da C++ é fundamentalmente falho. Em particular, alguns iteradores devem se comportar diferentemente, dependendo de se eles querem indicar um elemento ou uma fronteira entre os elementos. Portanto, os elementos e fronteiras são realmente dois conceitos distintos. Nesta palestra, eu o convencerei de que o problema é real e possui implicações práticas, apresentarei uma proposta sobre como consertar isso e mostrarei como a solução não apenas conserta o problema, mas contribui para um código mais claro e previne erros.


From Iterators To Ranges — The Upcoming Evolution Of the Standard Library (De iteradores a intervalos, a próxima evolução da biblioteca padrão)
Arno Schödl

Pares de iteradores são ubíquos em toda a biblioteca C++. Geralmente aceita-se que uma combinação de tal par em uma única entidade geralmente denominada Intervalo ofereça um código mais conciso e legível. Entretanto, definir semânticas precisas de tal conceito de Intervalo se prova surpreendentemente difícil. As considerações teóricas entram em conflito com as práticas. Alguns objetivos de design são geralmente incompatíveis juntos.


Uma abordagem prática para o tratamento de erros

Cada programa poderá se deparar com erros, alguns originários de erros internos no programa, outros vindos do ambiente no qual o programa está operando. Ignorar todos os erros tornará o programa completamente não confiável, enquanto tratar cada um dos erros concebíveis introduzirá muita complexidade extra com pouco benefício. Na think-cell, estamos usando e refinando o nosso próprio enfoque baseado em princípios para o manuseio de erros, que não vimos em nenhum outro lugar. Esse workshop descreve nosso método, de modo que você, em seu próximo projeto, também possa escrever um software mais confiável com menos esforço.


Episódio semanal C++ - Entrevista no CppCast
Arno Schödl

CppCast de Rob Irving e Jason Turner em 24 de janeiro de 2018 entrevistando Arno sobre a biblioteca de intervalos da think-cell e desenvolvimento de C++ na think-cell em geral.


Desenvolver um suplemento simples para o PowerPoint, não deve ser difícil
Valentin Ziegler

O desenvolvimento do Office está amplamente associado a macros VBA entediantes ou a JavaScript simples e deselegante. Muitos desenvolvedores com quem Valentin conversou ficaram surpresos de saber que a base de código da think-cell tem um milhão de linhas de código em C++ e que tivemos que criar algumas bibliotecas genéricas ao longo do caminho para que ele ficasse curto. Lutamos para implementar a interface de usuário mais simples com o PowerPoint, o que permite aos usuários criar slides de ótima aparência em pouco tempo e para isso, precisamos usar ferramentas muito poderosas. Vamos mostrar como aplicamos algoritmos de última geração para resolver problemas de layout e de posicionamento e quais desafios tivemos que superar para integração completa com o aplicativo host.


Industrial Strength Software Hacking (Simplificando o software para uso industrial)
Simon McPartlin

Patching de software é um método poderoso, mas potencialmente arriscado para corrigir erros, adicionar funcionalidade e melhorar a utilização ou o desempenho do software. Esta palestra analisará o patching de software onde o código fonte está indisponível, uma atividade comumente chamada de hacking. Discutimos por que e quando tal atividade pode ser necessária antes de analisar em detalhes o design e a implementação de patches robustos. Concluiremos descrevendo as diversas ferramentas e técnicas que podem ser usadas para encontrar locais de patching adequados.


std::cout is out — Why iostreams must go (está fora — Por que iostreams devem acabar)
Sebastian Theophil

Recentemente começamos a portabilizar nosso software para outras plataformas. Neste processo, descobrimos um mundo de problemas que são os iostreams e a entrada/saída na linguagem C. Nesta palestra, damos uma breve visão geral sobre o motivo pelo qual banimos os iostreams de nossa base de códigos e o que os substituíram.


C++ Memory Model (Modelo de memória de C++)
Valentin Ziegler e Fabio Fracassi

O modelo de memória C++ define como múltiplos segmentos interagem com a memória e os dados compartilhados, possibilitando que desenvolvedores racionalizem o código atual de modo independente da plataforma. A palestra inclui explicações sobre execuções de segmentos múltiplos e corrida de dados em C++, como o código atual é afetado por otimizações de compilador e hardware e como evitar comportamento indefinido pelo uso de locks e operações atômicas. Depois, ela foca em diferentes ordens de memória para operações atômicas, suas garantias e implicações no desempenho.


C++ vs. Java
Valentin Ziegler e Fabio Fracassi

Nós amamos C++ e a usamos diariamente. Nesta palestra, nós explicamos por que, apesar da reputação de complexa, a C++ é conceitualmente uma linguagem muito melhor que Java. Por quê? Porque a C++ conhece os valores semânticos. Porque a C++ possui um comportamento indefinido. Porque a C++ não impõe coleta de lixo (garbage collection). Porque, com a C++, podemos escrever códigos que sejam, ao mesmo tempo, abstratos e eficientes.


Publicações científicas

Um algoritmo eficiente para rotulagem de gráfico de dispersão
Sebastian Theophil e Arno Schödl
Procedimentos de AAAI 2006

Esse trabalho apresenta um algoritmo eficiente para uma nova variação do problema de rotulação do recurso de ponto. O objetivo é posicionar o maior número de rótulos de ponto de forma que eles não se interceptem entre si ou entre seus pontos. Primeiramente nós apresentamos um algoritmo utilizando um algoritmo guloso com lookahead limitado. Nós então apresentamos um algoritmo que iterativamente reagrupa os rótulos, chamando o primeiro algoritmo em cada grupo, identificando assim um encerramento para a ordem ideal de rotulação. O algoritmo apresentado está sendo utilizado em um produto comercial para rotular gráficos, e nossa avaliação mostra que ele produz resultados muito superiores àqueles de outros algoritmos de rotulação.


Um algoritmo inteligente para rotulagem de gráfico de colunas
Sebastian Müller e Arno Schödl
Procedimentos de SMART GRAPHICS 2005

Esse trabalho apresenta um algoritmo inteligente para a rotulação de gráficos de coluna e seus derivados. Para resolver eficientemente o problema, nós o separamos em dois subproblemas. Nós primeiramente apresentamos um algoritmo geométrico para resolver o problema de se encontrar uma boa rotulação para os rótulos de uma única coluna, dado que outras colunas já foram rotuladas. Nós então apresentamos uma estratégia para encontrar um bom ordenamento no qual as colunas devem ser rotuladas, que utilize o primeiro algoritmo repetidamente para um lookahead limitado. O algoritmo apresentado está sendo utilizado em um produto comercial para rotular gráficos e já provou na prática que pode produzir resultados satisfatórios.


Texturas Graphcut: Síntese de imagem e de vídeo usando cortes gráficos
Vivek Kwatra, Arno Schödl, Irfan Essa, Greg Turk e Aaron Bobick
Procedimentos de SIGGRAPH 2003

Nesse trabalho, introduzimos um novo algoritmo para a síntese de imagens e vídeos. Em nossa abordagem, regiões selecionadas de uma imagem ou vídeo de exemplo são transformadas e copiadas para o formato de saída e então são unidas com junções otimizadas para criar uma nova (e geralmente maior) versão final. Em contraste com outras técnicas, o tamanho da seleção não é selecionado de antemão, mas uma técnica de corte de gráfico é usada para determinar a região de seleção ideal para deslocamento entre a textura de entrada e a de saída. Diferentemente da programação dinâmica, nossa técnica de corte gráfico para a otimização da junção é aplicável em qualquer dimensão. Nós a exploramos especificamente em 2D e 3D para efetuar a síntese de textura de vídeo, além da síntese regular de imagem.


Animação controlada de sprites de vídeo
Arno Schödl e Irfan Essa
Procedimentos de SCA 2002

Nesse trabalho nós apresentamos uma nova abordagem para a geração de animações controladas de sprites de vídeo. Os sprites de vídeo são animações criadas pela reformulação de quadros de vídeos gravados de um objeto em movimento. Com nossa técnica, o usuário poderá especificar as animações utilizando uma função de custo flexível, que é automaticamente otimizada pela repetição da substituição das sequências dos sprites de vídeo.


Texturas de vídeo
Arno Schödl, Richard Szeliski, David H. Salesin e Irfan Essa
Procedimentos de SIGGRAPH 2000

Esse trabalho introduz um novo tipo de meio, chamado textura de vídeo, que possui qualidades intermediárias entre as de uma fotografia e as de um vídeo. Uma textura de vídeo oferece um fluxo contínuo e de variação infinita de imagens. Enquanto os quadros individuais de uma textura de vídeo podem ser repetidos de tempos em tempos, a sequência de vídeo completa nunca é repetida exatamente. As texturas de vídeo podem ser utilizadas no lugar de fotos digitais para inserir as qualidades do dinamismo e da ação explícita a uma imagem estática.

Quer saber mais?

Em caso de dúvidas sobre trabalhar na think-cell, nossas vagas de emprego ou nossos eventos, entre em contato com nossa colega Julia Zhachuk.

hr@think-cell.com
+49 30 6664731-81

Representante de RH da think-cell.


Compartilhar