Chaos Computer Club - archive feed

Internetsuche ist für uns ein alltägliches Werkzeug. Von einfachen Aufgaben wie dem Nachschlagen der Öffnungszeiten der Pizzeria nebenan, über den Preisvergleich für eine neue Webcam, bis hin zu aufwändigen Recherchen zu komplexen Themen bildet die Internetsuche oftmals den Ausgangspunkt. In diesem Petit Foo gebe ich Tipps wie man diese Aufgaben vereinfachen und beschleunigen kann.

about this event: https://www.chaospott.de

about this event: https://c3voc.de

The Enigma machine was an encryption device that was

used by German forces during WW2 to send secret messages. In

this talk, we will explain exactly how the encryption process

works and go through an implementation of it in Elm. We will

demonstrate how to encrypt and decrypt a message. Then we will

go over the weaknesses that made it exploitable by Alan Turing

and the other fine folks in Bletchley Park. By the end of the

talk, you’ll be able to point out all the inaccuracies in “The

Imitation Game”.

about this event: https://bobkonf.de/2022/liu.html

Local-first software is a new term for interactive

end-user applications, which provide data ownership and privacy while

still enabling data to be shared, and which allow working offline

while ensuring data consistency. Developing such applications is often

perceived as hard, because of the use of unsuited general purpose

programming models. REScala is a mature research project that

addresses these issues and provides a specialized programming model

designed to be understandable by developers while still providing the

flexibility for efficient implementations that automatically ensure

all desired properties.

In this talk, we will show how a combination of functional reactive

programming (the mostly classical variant) and conflict-free

replicated data types (specifically join semilattices) provide

abstract reasoning about all points in space and time for local-first

applications. Specifically why reasoning in the abstract is actually

much easier for developers than reasoning about all the hundreds and

thousands of possible special cases their implementation admits.

We hope that this talk helps to spread such better suited programming

models, thus leading to most software being local-first by

default. Then, we may see a future where individuals own their data

and not have it stolen by advertisers, and companies keep their

sovereignty without being at the mercy of the biggest players.

about this event: https://bobkonf.de/2022/mogk.html

Learn how to clean up your large Erlang projects by

detecting and removing code that’s no longer needed with the highest

level of confidence using Hank, an open-source plugin for rebar3.

The presence of source code that is no longer needed is a handicap to

project maintainability. The larger and longer-lived the project, the

higher the chances of accumulating dead code in its different forms.

Manually detecting unused code is time-consuming, tedious,

error-prone, and requires a great level of deep knowledge about the

codebase. In this talk, we examine the kinds of dead code

(specifically, oxbow code) that can appear in Erlang projects, and

formulate rules to identify them with high accuracy.

We also present an open-source static analyzer that implements these

rules, allowing for the automatic detection and confident removal of

oxbow code in Erlang codebases, actively contributing to increasing

their quality and maintainability.

about this event: https://bobkonf.de/2022/castro-brujo.html

Python is well known as a dynamically typed

language, but it has an increasingly mature system of type

annotations which can be gradually introduced to an existing

code base. I’d like to tell you some good stuff, some bad

stuff and some terrible stuff - based around my experience

adding type annotations to a large Python codebase over the

last few years.

about this event: https://bobkonf.de/2022/clifford.html

Unser Gehirn wurde von der Evolution über Hunderte

Generationen auf “Überleben” optimiert. Dabei haben sich einige

Eigenschaften herausgebildet, die uns in Softwareentwicklung und

-architektur unbewusst eine Menge Schwierigkeiten bereiten. Wir

schauen im Vortrag auf einige dieser komischen Phänomene des Gehirns

und betrachten Zusammenhänge zu typischen Situationen in der

Softwareentwicklung.

Die Erforschung mancher dieser Gehirneigenschaften haben einigen

Leuten Nobelpreise eingebracht - und bieten uns in der

Softwareentwicklung gute Ansätze, unsere eigene Arbeitsweise und

unsere Architekturentscheidungen systematisch zu verbessern.

about this event: https://bobkonf.de/2022/starke.html

Haskell and Lua share some similarities, like

support for functional programming, but are otherwise very

different. Nonetheless, the two complement each other in

interesting ways. This is demonstrated by pandoc, the

universal document converter, which is written in Haskell and

uses Lua as extension language. Pandoc’s behavior can be

modified through Lua filters, custom readers, and custom

writers, leveraging the power of Haskell and flexibility of

Lua.

While combining the two languages is made easy by the hslua

package, the internals of that package are not always

straight-forward and a testament to the powers of Haskell’s

Foreign Function Interface. We will take a look at the

encountered impedance mismatch and how it was overcome,

compare it to efforts in adjacent languages like OCaml, and

see how hslua can be used to expose application internals to

scripts effectively and conveniently.

about this event: https://bobkonf.de/2022/krewinkel.html

Drei spannende Konferenztage gehen zu Ende. Ein gemeinsamer Abschluss soll erfolgen mit Rückblick auf die Konferenz und das erlebte. Natürlich auch mit einem Ausblick auf das nächste Jahr 2023.

Drei spannende Konferenztage gehen zu Ende. Ein gemeinsamer Abschluss soll erfolgen mit Rückblick auf die Konferenz und das erlebte. Natürlich auch mit einem Ausblick auf das nächste Jahr 2023.

about this event: https://pretalx.com/fossgis2022/talk/7EGJJG/

Do you, too, think that “implementation-defined” is

a derogary term? Let me describe how I have pushed againt that, and

for development model that puts an abstract specification of the

system to be built in a central, pivotal position, flanked by a

clean-room, decoupled “reference implementation” and a “specification

acceptance test”, using functional programming for good effect in both

cases.

Many developers tend to focus on the “how”, and less on the “what”, of

what they are building. This is not bad per se, but if left unchecked,

this may lead to systems with an “implementation-defined surface”,

with a organically grown interface that leaks abstractions and exposes

implementation details.

To counter this effect, one can write a proper specification for the

system. A document that, in prose and or math, precisely describes the

interface of the system, but also its behavior, i.e. its

semantics. This decouples the outward-facing aspects of the system

from the internals.

On top of that one can write a reference implementation of the system,

based only on the specification. This checks and clarifies the

specification, and by comparing the behavior of the two

implementations, one can triangulate bugs and detect when

implementations and spec went out of sync.

To make things even more rigid, one can add a conformance test suite,

again based soley on the specification, and probes an implementation

and checks for certain behaviours. This can be integrated into the

developent process, e.g. as a CI check, and additionally keep the

implementations honest.

All in all, this gives you a clear picture of the essence of your

system or service, a place to discuss changes between stakeholders on

either side of the interface without getting distracted by

implementation designs, insulates your users from implementation

changes and gives your developers a clearly demarked space to go wild

within.

about this event: https://bobkonf.de/2022/breitner.html