
Learn you an Agda (2011) - jxub
http://learnyouanagda.liamoc.net/pages/introduction.html
======
disconcision
While this starts strong, a heads up: it peters out quick. There's only about
an hour of material here, and the last of the three parts is unfinished, in
the sense that there are gaps, not just an abrupt ending.

After finishing this I jumped over to wadler/kokke's programming language
theory in AGDA:

[https://wenkokke.github.io/sf/](https://wenkokke.github.io/sf/)

Which is also unfinished, but generally more comprehensive and better
motivated. It also stands a much greater probability of being continued.

------
Zalastax
Verified Functional Programming in Agda is the best Agda resource available,
but studying Idris via Type-driven Development with Idris will net you very
transferable insights. These are research languages, so the ideas are
extremely interesting but not production ready. What I like about working in
Agda is: proofs are verified by the compiler (so I know when I've proved
enough), dependent types blurs the lines between types and values in a way
that makes expressing complex typing relations no bother at all, and that
mixfix operators let you create some really neat syntax. (Aspiring) computer
scientists will be well of taking a look.

------
bakhy
Why always Peano numbers? If it's doable, I'd love to see something like a web
server with provable safety guarantees (e.g. eliminating any SQL injection
risk), or a concurrent system with the compiler proving there are no races,
even though the code is sharing memory. Or just proving that some simple
business rules hold. Is stuff like that doable in a dependently typed
language?

~~~
ocharles
We start with Paeno numbers because they are probably the simplest inductive
data type that set the scene for how we tend to proves things in dependently
typed programming (inductive reasoning). Proving the things you want are
probably doable (I can't say for certain, they are vaguely specified which
does not fit with formal methods), but significantly more involved. Trying to
take the reader from nothing to that in a single blog post or talk is beyond
anyone's ability. Generally, this is because dependent types aren't quite
ready for mainstream in terms of convenience.

That said, I'd read some of Edwin Brady's research, as he is actively trying
to find the intersection of "business programming" and dependent types:
[https://edwinb.wordpress.com/publications/](https://edwinb.wordpress.com/publications/)

------
Smaug123
Conor McBride's lecture series CS410 at Strathclyde is freely available on
Youtube, and my team is watching that at lunchtimes - excellent gentle
introduction to proofs-as-types and so forth, and it has turned me onto Agda
as a theorem proving environment.

