Partiality *

Controversial? Perhaps; Opinionated? Certainly.

Talks and Presentations

Links to talks and other things.
The talks are listed in a reverse chronological order.
## 2014-10-01 – "Abstractions"  {#abstr-goto}

### Resources
 
Presentation: [abstractions.html](http://piyush.purang.net/abstr/abstractions.html)

Quotes on Abstraction: [quotes.html](http://piyush.purang.net/abstr/quotes.html)

Source code: [ppurang/abstractions](http://github.com/ppurang/abstractions)

### Abstract

This is an introductory talk on abstractions. Defining "abstraction" is difficult and we want to focus on unambiguous or sound abstractions and the laws that make them such. We take a very simple task and see where the road of abstractions can take us and what names if any such abstractions carry. One of the main goals is to make you excited about the world of sound abstractions and a secondary goal is to show how Scala or other powerful type systems allow you to express these concepts without peeking at the type of values using runtime reflection or such.

### Description
What is an Abstraction? Are all abstractions leaky? What has a semigroup, monoid or such to do with abstractions? How does abstraction relate to generalization? How do you use abstractions in your favourite programming language?; and no `AbstractSomethingSomething` isn’t an abstraction. How about Design Patterns - do they fit in somehow? In this talk we aren’t chicken and we go through some tough questions not necessarily in the same order or detail but we certainly do.

The talk will use Scala for code examples but could just as easily have used Haskell or others with a powerful enough type system. We will encounter type classes, higher kinded types etc. along the way.

To prime yourself for this talk please do the following task. This is a recommendation and not a requirement so don’t worry too much if you can’t manage it.

In any programming language of choice create a function, let’s call it `sum` (name doesn’t really matter), that takes a list of integers and computes and returns the sum of those integers. After you have accomplished this rather simple task, introduce abstractions that allow you to use the same method in different scenarios. Try to minimize the code you have to introduce and maximize the utility/applicability. Here are some questions, whose answers should help you along. 

1. What if it were a list of floating point numbers/doubles? 
2. What if it were a list of `String`s? What should be the result? 
3. What if it were an _Array_, _Queue_, _Sequence_, _Vector_ or other such _Iterable_ structures of integers? A tree of integers?
4. What if it were a Map/Associative-Array from Strings to Integers? 
5. What if sum in another universe should be __sum(List(1,2,3,4,5)) == 120__. What sort of sum is that? Oh no! guess what that universe is really ours. Are we doomed? Hint: Don't think about the __+__ sign too much. 

Link to the event : [GOTO Night with Piyush Purang & Jacob Fahrenkrug](https://secure.trifork.com/berlin-2014/freeevent/index.jsp?eventOID=6508)