schedule Dec 14th 04:00 PM - 04:45 PM place Senate people 6 Interested

Domain Specific Languages (or Libraries because embedded DSLs are just that) are already quite popular.

Modern languages have many useful language features that are conducive to create DSLs with more ease than ever before. Kotlin from JetBrains is a beautifully blended pragmatic programming language that packages many features from many programming languages. Kotlin also have infix operation which makes code written in a DSL made with Kotlin very easy to read (and therefore less error-prone).

In this demonstration, I shall show couple DSLs made from Kotlin

and will dissect the code LIVE to show audience how several language features in Kotlin (which sometimes requires playing with higher order functions) to develop these languages.

*A Unit Testing DSL (a DSL to simplify unit testing of Kotlin, Java Code) that our grand/m/pa can use.

-- All unit test frameworks serve the purpose but elegance is a different matter. A code that works, and a code that is elegant and works is art. In this example, audience will see how they can use several language features that Kotlin has to offer can be put together to create an elegant and expandable unit testing DSL.

* A DSL for Web Scraping and Transformation.

- - A special case of ETL, where Extraction happens from raw HTML, Transformation happens in memory using the DSL designed. and the Load happens by loading this data to a different schema/db/form/representation.

 
2 favorite thumb_down thumb_up 1 comment visibility_off  Remove from Watchlist visibility  Add to Watchlist
 

Outline/structure of the Session

Introduction to Kotlin features

Lambda Expressions

Infix operator

Higher Order functions

Creating DSLs

Q/A

Learning Outcome

After attending this talk, audience will be able

  • Appreciate several language features that Kotlin brings to the table
  • Use these features to their advantage to create DSLs to ease their day-to-day work

Target Audience

Test Developers, Software Developers, Test Architects

Prerequisite

Need to have IntelliJ

schedule Submitted 6 months ago

Comments Subscribe to Comments

comment Comment on this Submission
  • Naresh Jain
    By Naresh Jain  ~  3 months ago
    reply Reply

    Hi Sudipta,

    Thanks for the proposal. The two demos that you plan to give, is the code open sourced? Can we have a look at the code?


    • Liked Saurabh Nanda
      keyboard_arrow_down

      Saurabh Nanda - "Refresh-driven" development with Haskell & Elm

      Saurabh Nanda
      Saurabh Nanda
      Founder
      Vacation Labs
      schedule 5 months ago
      Sold Out!
      45 Mins
      Tutorial
      Beginner

      We sorely missed the rapid "refresh-based" feedback loop available in Rails (and other dynamically typed web frameworks), while writing Haskell. Change your code, hit save, and refresh your browser!

      In this talk we will share a few tips on how we finally hit productivity nirvana with ghcid and automated code-gen.

      Best of both worlds -- rock-solid type-safety AND being able to reload code with every change.

    • Liked Raghu Ugare
      keyboard_arrow_down

      Raghu Ugare / Vijay Anant - (Why) Should You know Category Theory ?

      45 Mins
      Talk
      Intermediate

      Category Theory has been found to have a vast field of applications not limited to programming alone.

      In this fun-filled talk (Yes! We promise!) , we want to make the audience fall in love with Math & Category Theory in general, and Haskell in particular.

      We will address questions such as below:

      • What is the mysterious link between the abstract mathematical field of Category Theory and the concrete world of real-world Programming ? And why is it relevant especially in Functional Programming?
      • Most of all, how can You benefit knowing Category Theory ? (Examples in Haskell)

    • Liked Harendra Kumar
      keyboard_arrow_down

      Harendra Kumar - High Performance Haskell

      45 Mins
      Talk
      Intermediate

      Haskell can and does perform as well as C, sometimes even better. However,
      writing high performance software in Haskell is often challenging especially
      because performance is sensitive to strictness, inlining and specialization.
      This talk focuses on how to write high performance code using Haskell. It is
      derived from practical experience writing high performance Haskell libraries. We
      will go over some of the experiences from optimizing the "unicode-transforms"
      library whose performance rivals the best C library for unicode normalization.
      From more recent past, we will go over some learnings from optimizing and
      benchmarking "streamly", a high performance concurrent streaming library. We
      will discuss systematic approach towards performances improvement, pitfalls and
      the tools of the trade.

    • Liked Michael Ho
      keyboard_arrow_down

      Michael Ho - Making the Switch: How We Transitioned from Java to Haskell

      Michael Ho
      Michael Ho
      Sr. Software Engineer
      SumAll
      schedule 5 months ago
      Sold Out!
      45 Mins
      Case Study
      Intermediate

      In this case study presentation, SumAll's CTO, Todd Sundsted, and Senior Software Engineer, Michael Ho, will discuss the move from Java to Haskell along two parallel paths. First, the business/political story — how SumAll convinced the decision makers, fought the nay-sayers, and generally managed the people impacted by the transition. Second, the technical story — how they actually replaced their Java code with Haskell code. Along the way, they will address their hopes and expectations from transitioning from Java to Haskell, and will conclude with the results they've gained and seen to date.

    • Liked Anupam Jain
      keyboard_arrow_down

      Anupam Jain - Purely Functional User Interfaces that Scale

      Anupam Jain
      Anupam Jain
      Haskell Consultant
      S&P Global
      schedule 5 months ago
      Sold Out!
      45 Mins
      Talk
      Beginner

      A virtual cottage industry has sprung up around Purely functional UI development, with many available libraries that are essentially just variants on two distinct approaches: Functional Reactive Programming (FRP), and some form of functional views like "The Elm Architecture". After having worked extensively with each of them, I have found that none of the approaches scale with program complexity. Either they are too difficult for beginners trying to build a hello world app, or they have unpredictable complexity curves with some simple refactorings becoming unmanageably complex, or they "tackle" the scaling problem by restricting developers to a safe subset of FP which becomes painful for experienced developers who start hitting the complexity ceiling.

      In this talk I give an overview of the current Purely Functional UI Development Landscape, and then present "Concur", a rather unusual UI framework, that I built to address the shortcomings of the existing approaches. In particular, it completely separates monoidal composition in "space" (i.e. on the UI screen), from composition in "time" (i.e. state transitions), which leads to several benefits. It's also a general purpose approach, with Haskell and Purescript implementations available currently, and can be used to build user interfaces for the web or for native platforms.

      The biggest advantage of Concur that has emerged is its consistent UI development experience that scales linearly with program complexity. Simple things are easy, complex things are just as complex as the problem itself, no more. Reusing existing widgets, and refactoring existing code is easy and predictable. This means that Concur is suitable for all levels of experience.

      1. For Learners - Concur provides a consistent set of tools which can be combined in predictable ways to accomplish any level of functionality. Due to its extremely gentle learning curve, Concur is well suited for learners of functional programming (replacing console applications for learners).
      2. For experienced folks - Assuming you are already familiar with functional programming, Concur will provide a satisfying development experience. Concur does not artificially constrain you in any form. You are encouraged to use your FP bag of tricks in predictable ways, and you are never going against the grain. It's a library in spirit, rather than a framework.
    • Liked Emily Pillmore
      keyboard_arrow_down

      Emily Pillmore - A Radically New Functional Blockchain Architecture: Chainweb

      Emily Pillmore
      Emily Pillmore
      Haskell Engineer
      Kadena.io
      schedule 5 months ago
      Sold Out!
      45 Mins
      Talk
      Advanced

      Proof-of-work blockchain networks like Bitcoin, Litecoin and Ethereum are characterized by low throughput (5-15 transactions per second). Efforts to improve throughput through protocol modifications, such as block size increases, have no hope of reaching levels required to take on modern fiat-currency payment networks. However, efforts that seek to replace Proof-of-Work (Proof-of-Stake and variants) or integrate it with off-chain networks and processes (payment channels, side chains) degrade assurance, censorship resistance or trustless-ness of the original design. Recovering and elaborating on early proposals for Bitcoin scaling, we present ChainWeb, a parallel-chain architecture which can combine hundreds to thousands of Proof-of-Work blockchains pushing throughput to 10,000 transactions per second and beyond. The network transacts a single currency, using atomic and trustless SPV (Simple Payment Verification) cross-chain transfers orchestrated at the application layer with capability and coroutine support in the Pact smart contract language. Chains incorporate each other’s Merkle tree receipts to enforce a single “super branch” offering an effective hash power that is the sum of each individual chain’s hash rate. In addition to massive throughput, other benefits accrue from having a truly parallelized smart-contract blockchain system.

    • Liked Andrew McCluskey
      keyboard_arrow_down

      Andrew McCluskey - Property-based State Machine Testing

      45 Mins
      Talk
      Intermediate

      Automated testing is key to ensuring the ongoing health and well-being of any software project,giving developers and users confidence that their software works as intended. Property based testing is a significant step forward compared to traditional unit tests, exercising code with randomly generated inputs to ensure that key properties hold. However, both of these techniques tend to be used at the level of individual functions. Many important properties of an application only appear at a higher level, and depend on the state of the application under test. The Haskell library hedgehog, a relative newcomer to the property based testing world, includes facilities for property-based state machine testing, giving developers a foundation on which to build these more complicated tests.

      In this talk, Andrew will give you an introduction to state machine property testing using hedgehog. He'll start with a quick refresher on property based testing, followed by a brief introduction to state machines and the sorts of applications they can be used to model. From there, he'll take you on a guided tour of hedgehog's state machine testing facilities. Finally, Andrew will present a series of examples to show off what you can do and hopefully give you enough ideas to start applying this tool to your own projects. The first set of examples will test a web application written in Haskell. These tests will include: content creation and deletion, uniqueness constraints, authentication, and concurrent transactions. A second set of examples will test an application written in a language other than Haskell to demonstrate that this technique is not limited to applications written in Haskell.

      An intermediate knowledge of Haskell and familiarity with property based testing will be beneficial,but not essential. The slides and demo application will be available after the talk for people to study in detail.

    • Liked Emily Pillmore
      keyboard_arrow_down

      Emily Pillmore - Pact: An Open Source Language for Smart Contracts

      Emily Pillmore
      Emily Pillmore
      Haskell Engineer
      Kadena.io
      schedule 5 months ago
      Sold Out!
      45 Mins
      Demonstration
      Intermediate

      In this talk we'll discuss the design and implementation of a smart contract property verification tool for Pact.

      The revolutionary idea of putting computer programs in a blockchain to create smart contracts has opened up a whole new world of possibilities. But these programs have very different characteristics from other software. This talk explores these differences, some of the challenges that have been encountered, and then discusses how Kadena is solving these problems with its smart contract language Pact. We'll discuss the design and implementation of a smart contract property verification tool for Pact. We leverage these (lack of) features to build a system capable of proving many properties of contracts via the Z3 SMT solver. We'll also give examples of real bugs caught by the system.

    • Liked Neeraj Sharma
      keyboard_arrow_down

      Neeraj Sharma - BeamParticle - A Polyglot Dynamic Programming Engine

      Neeraj Sharma
      Neeraj Sharma
      Director Engineering
      redBus
      schedule 5 months ago
      Sold Out!
      90 Mins
      Tutorial
      Intermediate

      BeamParticle is an open source project built on top of the Erlang virtual machine (BEAM), which allows dynamic (re)programming in multiple programming languages. This project tries to take some simple decisions thereby making the life of developer easy in realizing dynamic code patching and reprogrammability. It is very easy to setup this software on any of the modern GNU/Linux distributions, although Debian packages are available for Ubuntu Xenial. The project supports six different programming languages; namely: Erlang, Elixir, Java, Python, Efene, and PHP.

      The system is deployed in a limited capacity in production within redBus to serve numerous use cases.

    • Liked Krishna mahadevan Ramakrishnan
      keyboard_arrow_down

      Krishna mahadevan Ramakrishnan / Akshay Kini / Muthukumar Suriyanarayanan - Architectural transformation of a massively concurrent J2EE Enterprise Application for Network Management using Elixir

      45 Mins
      Case Study
      Intermediate

      This talk starts with setting the context on how the every growing demands of networks (like IOT, SDN) pushes the limits of monitoring applications in terms of scale, availability, resource consumption and accuracy. The heterogeneous nature of networks in enterprises and telecom service providers adds to the scale and resource demands. A J2EE application attempting to fulfill the scale out needs of such a ever growing demanding domain, is pushed to its limits from system design perspective.


      The talk presents an evolutionary architecture of moving core components of an existing Network Management J2EE application architecture into Elixir based eco system. It presents the problem chosen to be scaled out and evaluation that led to rewriting the components with Elixir. It also presents the learning in productising a Elixir based subsystem co-existing with a J2EE application.


      It concludes with the comparative results in terms of performance, scale out ability, elastic load patterns, resource consumption between old J2EE architectue and new J2EE + Elixir based architecture. It gives a perspective on architectural patterns for transforming J2EE enterprise application in to Elixir based applications.