Code Mesh

  1. Slides and more info: codemesh.io/codemesh2015/philip-potter

    Registers: Systems of Record with Guaranteed Integrity

    A register is a single authoritative source of truth for structured data within a particular domain. Many parts of the UK government are responsible for maintaining many different registers in diverse domains. A good register preserves the full history of updates, and provides cryptographic guarantees of the integrity of the data. It also makes data available in machine-readable hypermedia formats so that services can easily consume the data it provides. The talk will report on experiences building several registers. It will also report on experience working with an append-only data model and what this means in practice for services that consume data from the register, and also for services that wish to update the register.

    Talk objectives:
    - discuss registers and design considerations when maintaining a canonical system of record
    - share experiences of using cryptography to provide guarantees of integrity
    - share experiences of modelling data as an append-only system of record

    Target audience:
    - anyone who consumes data published by someone else
    - anyone who publishes data consumed by someone else

    About Philip

    Philip is a developer at the UK Government Digital Service, where he has worked on GOV.UK and GOV.UK Verify. Previously he has worked in software development, web operations, research, technical writing, and hardware design. He likes thinking about hard problems and then finding solutions that other people have already written.

    # vimeo.com/145979732 Uploaded 9 Plays 0 Comments
  2. Slides and more info: codemesh.io/codemesh2015/allele-dev

    Communication is hard. Communication is even harder when you have to ensure that computers, team mates, and users are all getting the same message. This is at the heart of programming.

    A great ally in this effort is the compiler and its type checker. A good compiler allows us to express ourselves in great detail, while ensuring that our meaning is consistent. Unfortunately, we've been taught that there's shame in making mistakes. Type errors become a source of pain and frustration rather than a dialogue in search of meaning. I hope to help you befriend your compiler, and to convince compiler writers that friendly compilers are crucial.

    This talk uses Haskell as a medium to explore the intersection of type theory, effective communication, and software development. You don't need to be familiar with Haskell or type theory to understand this talk. Further, the core concepts of this talk are applicable to many languages, gradually or statically typed. Using a combination of live coding and narrative, we'll learn to understand what the compiler is trying to tell us as we encode progressively richer assumptions in a small program.

    Talk objectives:

    Briefly, I hope that I can teach attendees the following:

    * Effective communication: refining a message, removing ambiguity, removing noise

    * Basic type system terminology: type checker, sum types, product types, recursive types, polymorphic types

    * Haskell syntax: pattern matching, deconstruction, data type definition, function definition

    * Reading type signatures and type errors

    * Refactoring with the help of a type checker

    * Optional data, nullability, and the Maybe type

    * Error-handling with Either types

    * Abstraction safety as it relates to consistency

    * Briefly, next steps: the rich tapestry of logic, math, programming, philosophy, and communication

    Target audience:

    - Developers interested in learning more about using type systems in practice, communicating better, or who are Haskell-curious.

    About Allele

    Alelle is a software developer with an interest in programming languages, type theory, social structures, and Haskell. By day, they help write backend services in Haskell for Eduphoria. By night, they'll read research papers, enjoy a great deal of laziness, and make sure the cats are happy and fed. They listen to chip tune and love 4-arrow dance games.

    # vimeo.com/145976470 Uploaded 25 Plays 0 Comments
  3. Slides and more info: codemesh.io/codemesh2015/tony-hoare

    Tony Hoare will open with a 10 minute summary of language features proposed during his career. Each feature was motivated by the desire to reduce the range of programming errors by increasing the range of errors discovered at compile-time and ensuring that those which slip through can be detected and isolated at run-time. Then he and Bruce Tate will introduce the panel and ask the language inventors to give a five minute introduction of their language answering questions like:

    * Was ease of writing correct programs and debugging incorrect ones important to the market segment (ecological niche) at which your language was aimed?

    * Which particular features of your language met this goal, or tried and failed?

    * For what features was correctness sacrificed in the pursuit of alternative goals – eg. compactness, familiarity, compatibility, efficiency, etc?

    * In the light of hindsight, what would you have done differently, and why or why not?

    This will be followed by a discussion amongst inventors of languages such as F#, Erlang and Hack.

    # vimeo.com/145889051 Uploaded 17 Plays 0 Comments
  4. Slides and more info: codemesh.io/codemesh2015/francesco-cesarini

    Erlang/OTP has for years been described as your secret sauce to writing scalable and available systems. Erlang alone, however, will not do any magic. It is merely an enabler that, thanks to its semantics, programming model and predictable virtual machine makes the end results easier to achieve. In this talk, Francesco will walk through the topology patterns of modern distributed Erlang architectures, discussing the tradeoffs in scalability and reliability the actor model, the failure model and the built-in distribution model encourage you to take.

    About Francesco

    Francesco is the founder of Erlang Solutions Ltd. He has used Erlang on a daily basis since 1995, starting as an intern at Ericsson’s computer science laboratory, the birthplace of Erlang. He moved on to Ericsson’s Erlang training and consulting arm, working on the first release of the OTP middleware, which he applied to turnkey solutions and flagship telecom applications. In 1999, soon after Erlang was released as open source, he founded Erlang Solutions. With offices in three countries, they have become the world leaders in Erlang-based support, consulting, training, certification, systems development, and conferences. Francesco has worked in major Erlang-based projects both within and outside Ericsson; and as technical director at Erlang Solutions has led the development and consulting teams. He is the co-author ofErlang Programming, recently published by O’Reilly. He lectures at Oxford University and the IT University of Gothenburg.

    # vimeo.com/145854760 Uploaded 18 Plays 0 Comments
  5. Slides and more info: codemesh.io/codemesh2015/jon-pretty

    Scala's type system allows us to enforce compile-time constraints on our programs, and to take advantage of these constraints to help reason about our code. Yet we still frequently encounter situations where extracting a value from a map is not guaranteed to succeed, or mapping across a set of cases is not guaranteed to be exhaustive. With dependent types we can make operations like these completely safe by construction, in the process eliminating entire classes of errors, and furthermore we can do this without complicating user code. The talk will cover several simple and intermediate examples using dependent types, and will give a brief outline of some of the the challenges involved in implementing typesafe libraries with dependent types in Scala.

    Talk objectives:

    Demonstrating how dependent types can help users write safer, more reliable software.

    Target audience:

    The talk will be accessible to all programmers, though a basic understanding of Scala syntax and type systems will be useful.

    About Jon

    Jon has been having fun riding the bleeding edge of Scala for over a decade, and he's not done yet. While he's not travelling the world attending Scala conferences, or organizing his own (Scala World), Jon spends his time working on the open-source Rapture libraries and Typelevel Scala.

    # vimeo.com/145853726 Uploaded 15 Plays 0 Comments

Code Mesh

Erlang Solutions PRO

Videos from Code Mesh London, for the most recent info check out codemesh.io/

Browse This Channel

Shout Box

Heads up: the shoutbox will be retiring soon. It’s tired of working, and can’t wait to relax. You can still send a message to the channel owner, though!

Channels are a simple, beautiful way to showcase and watch videos. Browse more Channels.