Codemesh Day 1

James Uther
2014-11-28

I was at day 1 of CodeMesh this year (you can see Tim's report on day 2 here. A quick recap:

QOTD: There are 3 fire exits as marked, but we're confident that Erlang programmers who die will be restarted.

Keynote: complexity is outside the code

Jessica Kerr & Dan North

A good, entertaining talk that covered a lot of ground (and thankfully, someone else has a gist of better notes, so you can read them), But my main takeaways were:

We have architectures, Boxes and arrows, or layering, messaging, modularity but complexity is never defeated because it arises from difficult cross-cutting problems like performance, security, monitoring, etc. Each requires a different skill set. A Solution: Master a few, hope the broader team cover the rest.

Research is different from a spike. Cost of a bad design is a long-tail distribution (unbounded). A spike leads to the choice of quickest-to-hello-world solution. Research can be bounded (spend 2 days, or fund a research star and team) but has long-tail payoff.

Lots of ground on estimation and how underestimating accumulates debt which conflicts with the overall the goal to “sustainably minimize lead time to business impact” and it's the sustainably that brings in the harder to sell aspects of a solid development approach.

And a lot more, but probably the best thing to do is read [the slides. video]

The F♯ approach to relaxation

Don Syme

This sold F# really well.

The great disputes of computer science should be struggled with. They are chances to make a better, simpler, more relaxed world as much as create opposing camps. thesis, antithesis, synthesis. but you can take it too far, e.g [Integrating time and food with a mustard watch](http://girard.perso.math.cnrs.fr/mustard/article.html)

F# has a history of trying to integrate things

Functional languages ⇔ interop.

Enterprise ⇔ Openness.

Functional ⇔ Objects

Pattern matching ⇔ Abstraction.

units ⇔ units-of-measure

gpu ⇔ cpu

REPL ⇔ distribution and scale

Functional programming in data sciences

Richard Minerich

Richard is from Bayard Rock, an anti-money laundering co. They use a pairwise entity resolution process. (Fellegi-Sunter circa 1969) matching, datasets, customer (10e6) and list (2e6). pairs of somehow similar records, then scoring, then blocking a transaction based on the result. Scoring is done through a big social pagerank of risk. How likely is this person to be laundering money, given their relationships?

Some points:

Also, Combined regression and ranking, a paper from Google (D. Sculley). In regression, you're trying to guess a number and only distance matters ‐ may do bad job at ordering. But for ranking, you are trying to figure out order. page

Categories for the working programmer

Jeremy Gibbons

Jeremy has a blog

Overall point: Category theory is good for library design, and I can't really argue with that. TIL I need to know more about category theory.

He started with \(sum\), and how it's a generalisation of \(foldr\), and \(foldr\) is nice and generic. In particular you can separate out the data 'shape' from type recursion ‐ eg for list 

        
data ListS a b - MilS | ConsS a b
data Fix s a = In (s a (Fix s a))
or data Fix s a = In {out :: s a (Fix s a)}
type List a - Fix ListS a
bimap :: (a -> a') -> (b -> b') -> ListS a b -> ListS a' b'

Now we can define \(foldr\) on List 

        
foldList :: (ListS a b -> b) List a -> b
foldList f= f . bimap id (foldList f) . out
eg foldLIst add :: List Integer -> Integer, where
add :: ListS Integer Integer -> Integer
add NilS = 0
add (ConsS m n) = m + n

For datatype genericity, a typemap Bifunctor can be used. So, think of a bifunctor, S. It is also a functor in each argument separately. An algebra for functor S A is a pair (B, f) where \(f :: S A B -> B\) A homomorphism between (B, f) and (C,g) is a function \(h :: B -> C\) such that \(h.f=g.bimap id h\) Algebra (B, F) is initial if there is a unique homomorphism to each (C, g) eg, (List Integer, In) and (Integer, add) are both algebras for ListS Integer: 

        
In :: ListS Integer (LIst Integer) -> List Integer
add:: ListS Integer Integer -> Integer

and \(sum::List Integer -> Integer]\) is a homomorphism. The initial algebra is (List Integer, In), and the unique homomorphism to (C,G) is \(fold g\).

I need to meditate on this (or ask someone here to educate me). page

Social Code

Garret Smith

Coding is social (C.F. github). Social coding is a dynamic in programming that respects a communication line from one person to another. The talk became a tutorial in how to write software to express yourself to other coders (or yourself later). Be respectful to the maintainer. I find that my colleges at LShift are already on top of this, so left early and went to: page

MariaDB

Michael Widenius

Stuck around long enough to find out that 10.1 has multimaster mesh. And the foundation structure should keep the project in the open regardless of who buys what.

Type-directed Development

Clement Delafargue

page

Lightning fast cluster computing with spark and cassandra

Pitor Kolaczkowski

It became a tutorial which was not what I was interested in at that moment, so dropped into:

Beyond Shady AI with OpenCL: Massively Parallel Algorithms on GPGPUs

Alex Champandard

Ideas for doing AI on the GPU. TL;DR you have to rethink your algorithm choice a bit because it's highly parallel and you don't want to coordinate. video

Programming and testing a distributed database

Reid Draper

Had to go early but found out that RPC was actually the RFC before TCP! The early thrust of the talk was that we've been trying to figure out distribution for a looong time. Go look at some history and we may learn something. I imagine he got onto what we have learned, so a pity I had to go.

Remarks

Overall a good day. Talks were videoed but most of the ones I went to are not up (yet?). Lunch was great. Perhaps more of those little tables for people to gather and eat at to encourage mingling. Joe Armstrong is not how I imagined him.

(Originally here)