Eric Demko's Homepage
I am a software engineer interested in designing ergonomic systems for writing correct, performant, evolvable software.
To that end, I study and experiment with the semantics of programming languages, especially drawing on developments in dependent type theory.
I strongly believe that formal mathematics is a powerful tool to sharpen one's ideas, and is especially under-used in software development, where fuzzy ideas breed bugs.
I currently work for Layer 3 Communications in the Advanced Services division,
where I use Haskell to help build high-performance SIEM, NPM, and related network management tooling.
This work allows us to contribute open source Haskell libraries that improve the ecosystem's ability to operate on contiguous data, unlifted/unboxed data, and networking standards-related data.
Links
Software
- Big Literals: tiny library so compilers can work with big number literals
- e-exprs:
I never want to write a parser again.
E-exprs are based on s-exprs, but allow several more forms to aid with the ergonomics.
Highlights include: indented blocks, separating terms by commas/semicolons, dot-access syntax.
- Nanopass
a Haskell port of the Nanopass Compiler Framework.
I absolutely fell in love with this idea when I first saw it, but I was unwilling to give up static typing.
Now, I have statically-typed nanopass, and I can rest easy again.
System Administration Utilities
- will: executable installation notes
- skel: retrieve and fill templated files and directories
- dotsync: not just my dotfiles, but also a system to synchronize them
- technicolor: interface to terminal coloring
- gitstat: check that a git repo is up to dat with upstream
The Zedo Build System
Inspired by DJB's redo proposal, I periodically experiment with improvements to the interface and specification.
These are still not quite stable or fully-featured, but every time I look at it again, I get a little closer.
- zedo-shim: non-incremental, single bash script
- zedo (WIP) full bash implementation with specification
Job Stuff
Language Experiments
This section is more for my own notes.
I frankly have too many irons in the fire/pots on the stove/planes in the sky/whatever, and it's nice to have some sort of overview.
- BVSM:
a virtual machine that could reasonably be hand-compiled if necessary.
I thought it would be useful as a ground for bootstrapped compilers, bit it turns out that I need to balance the ground language for both ease of implementation and implementing _with_.
It may be possible to pivot into lisp-like semantics if I can build a simple-enough garbage collector.
- C Shim Library:
contains common C algorithms that usually just keep getting re-implemented.
- Ediacara:
a portable assembler because C isn't.
Ediacara should have assembly notions built-in from the start: "advanced" control-flow (like tail-calls and escape continuations), and arbitrary calling conventions per-function.
- Functional Programming Garbage Collector
aims to be a standard garbage collector written in C for general-purpose functional programming language runtimes.
It is currently just some notes on what I need to support and how I might do it.
- Anemone
attempts to pack as many abstractive features as possible (i.e. first-class everything) into a language;
the focus is on operational rather than static semantics
Random Corner
- env-cabal: find exes produced by cabal and put them
<project>/bin/
- haxplay: because music players keep screwing up my metadata
- a clock/astrolabe I started work on a while back
- My Master's Thesis which describes first-class continuations and their applications. I don't actually recommend reading it unless perhaps you want an introduction to their uses. However, I realized literally days after defending it that there's an improvement to be made to the formal system, and I've only found more improvements since.