-
Notifications
You must be signed in to change notification settings - Fork 3
/
XXX
1698 lines (1637 loc) · 78.8 KB
/
XXX
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
# auto generated from _meta/bibtex.bib
- key: Sculthorpe-13-KURE
cite: |
N. Sculthorpe, N. Frisby, and A. Gill, “The <span>K</span>ansas
<span>U</span>niversity <span>R</span>ewrite <span>E</span>ngine: A
<span>H</span>askell-embedded strategic programming language with custom
closed universes,” *Journal of Functional Programming*, 2014.
a_cite: |
N. Sculthorpe, N. Frisby, and A. Gill, “[The <span>K</span>ansas
<span>U</span>niversity <span>R</span>ewrite <span>E</span>ngine: A
<span>H</span>askell-embedded strategic programming language with custom
closed universes](/papers/Sculthorpe-13-KURE),” *Journal of Functional Programming*, 2014.
year: 2014
links:
- <http://www.ittc.ku.edu/csdl/fpg/files/Sculthorpe-14-KURE.pdf>
- <http://www.ittc.ku.edu/csdl/fpg/software/kure.html>
abstract: |
When writing transformation systems, a significant amount of engineering effort goes into setting
up the infrastructure needed to direct individual transformations to specific targets in the data
being transformed. Strategic programming languages provide general-purpose infrastructure for
this task, which the author of a transformation system can use for any algebraic data structure.
The Kansas University Rewrite Engine (KURE) is a typed strategic programming language, implemented
as a Haskell-embedded domain-specific language. KURE is designed to support typed transformations
over typed data, and the main challenge is how to make such transformations compatible with
generic traversal strategies that should operate over any type.
Strategic programming in a typed setting has much in common with datatype-generic programming.
Compared to other approaches to datatype-generic programming, the distinguishing feature of KURE's
solution is that the user can configure the behaviour of traversals based on the location of each
datum in the tree, beyond their behaviour being determined by the type of each datum.
This article describes KURE's approach to assigning types to generic traversals, and the
implementation of that approach. We also compare KURE, its design choices, and their
consequences, with other approaches to strategic and datatype-generic programming.
bibtex: |
@article{Sculthorpe:13:KURE,
author = {Neil Sculthorpe and Nicolas Frisby and Andy Gill},
title = {The {K}ansas {U}niversity {R}ewrite {E}ngine: A {H}askell-Embedded Strategic Programming Language with Custom Closed Universes},
xurl = {http://www.ittc.ku.edu/csdl/fpg/software/kure.html},
journal = {Journal of Functional Programming},
publisher = {Cambridge University Press},
year = {2014},
}
- key: Bracker-14-Sunroof
cite: |
J. Bracker and A. Gill, “Sunroof: A monadic <span>DSL</span> for
generating <span>J</span>ava<span>S</span>cript,” in *Practical Aspects
of Declarative Languages*, ser. Lecture Notes in Computer Science,
M. Flatt and H.-F. Guo, Eds. Springer International Publishing, 2014,
vol. 8324, pp. 65–80.
a_cite: |
J. Bracker and A. Gill, “[Sunroof: A monadic <span>DSL</span> for
generating <span>J</span>ava<span>S</span>cript](/papers/Bracker-14-Sunroof),” in *Practical Aspects
of Declarative Languages*, ser. Lecture Notes in Computer Science,
M. Flatt and H.-F. Guo, Eds. Springer International Publishing, 2014,
vol. 8324, pp. 65–80.
year: 2014
links:
- <http://dx.doi.org/10.1007/978-3-319-04132-2_5>
abstract: |
Sunroof is a Haskell-hosted Domain Specific Language (DSL)
for generating JavaScript. The central feature of
Sunroof is a JavaScript monad, which, like the
Haskell IO-monad, allows access to external
resources, but specifically JavaScript resources. As
such, Sunroof is primarily a feature-rich
foreign-function API to the browser’s JavaScript
engine, and all the browser-specific functionality,
including HTML-based rendering, event handling, and
drawing to the HTML5 canvas element.
In this paper,
we give the design and implementation of
Sunroof. Using monadic reification, we generate
JavaScript from a deep embedding of the JavaScript
monad. The Sunroof DSL has the feel of native
Haskell, with a simple Haskell-based type schema to
guide the Sunroof programmer. Furthermore, because
we are generating code, we can offer Haskell-style
concurrency patterns, such as MVars and Channels. In
combination with a web-services package, the Sunroof
DSL offers a robust platform to build interactive
web applications.
bibtex: |
@incollection{Bracker:14:Sunroof,
year = {2014},
isbn = {978-3-319-04131-5},
booktitle = {Practical Aspects of Declarative Languages},
volume = {8324},
series = {Lecture Notes in Computer Science},
editor = {Flatt, Matthew and Guo, Hai-Feng},
doi = {10.1007/978-3-319-04132-2_5},
title = {Sunroof: A Monadic {DSL} for Generating {J}ava{S}cript},
publisher = {Springer International Publishing},
keywords = {DSLs; JavaScript; Web Technologies; Cloud Computing},
author = {Bracker, Jan and Gill, Andy},
pages = {65-80},
}
- key: Farmer-14-HERMITinStream
cite: |
A. Farmer, C. <span>Höner zu Siederdissen</span>, and A. Gill, “The
hermit in the stream: Fusing stream fusion’s concatmap,” in *Proceedings
of the ACM SIGPLAN 2014 Workshop on Partial Evaluation and Program
Manipulation*, ser. PEPM ’14. New York, NY, USA: ACM, 2014, pp. 97–108.
a_cite: |
A. Farmer, C. <span>Höner zu Siederdissen</span>, and A. Gill, “[The
hermit in the stream: Fusing stream fusion’s concatmap](/papers/Farmer-14-HERMITinStream),” in *Proceedings
of the ACM SIGPLAN 2014 Workshop on Partial Evaluation and Program
Manipulation*, ser. PEPM ’14. New York, NY, USA: ACM, 2014, pp. 97–108.
year: 2014
links:
- <http://doi.acm.org/10.1145/2543728.2543736>
- <http://www.ittc.ku.edu/csdl/fpg/files/Farmer-14-HERMITinStream.pdf>
abstract: |
Stream Fusion, a popular deforestation technique in the Haskell community, cannot fuse the concatMap combinator. This is a serious limitation, as concatMap represents computations on nested streams. The original implementation of Stream Fusion used the Glasgow Haskell Compiler’s user-directed rewriting system. A transformation which allows the compiler to fuse many uses of concatMap has previously been proposed, but never implemented, because the host rewrite system was not expressive enough to implement the proposed transformation. In this paper, we develop a custom optimization plugin which implements the proposed concatMap transformation, and study the effectiveness of the transformation in practice. We also provide a new translation scheme for list comprehensions which enables them to be optimized. Within this framework, we extend the transformation to monadic streams. Code featuring uses of concatMap experiences significant speedup when compiled with this optimization. This allows Stream Fusion to outperform its rival, foldr/build, on many list computations, and enables performance-sensitive code to be expressed at a higher level of abstraction.
bibtex: |
@inproceedings{Farmer:14:HERMITinStream,
author = {Andrew Farmer and Christian {H\"{o}ner zu Siederdissen} and Andy Gill},
title = {The HERMIT in the Stream: Fusing Stream Fusion's concatMap},
booktitle = {Proceedings of the ACM SIGPLAN 2014 Workshop on Partial Evaluation and Program Manipulation},
series = {PEPM '14},
year = {2014},
isbn = {978-1-4503-2619-3},
location = {San Diego, California, USA},
pages = {97--108},
numpages = {12},
xurl = {http://www.ittc.ku.edu/csdl/fpg/files/Farmer-14-HERMITinStream.pdf},
doi = {10.1145/2543728.2543736},
acmid = {2543736},
publisher = {ACM},
address = {New York, NY, USA},
keywords = {deforestation, functional programming, ghc, haskell, optimization, program fusion, program transformation, stream fusion},
}
- key: Adams-14-OSIE
cite: |
M. D. Adams, A. Farmer, and J. P. Magalhães, “Optimizing syb is easy!”
in *Proceedings of the ACM SIGPLAN 2014 Workshop on Partial Evaluation
and Program Manipulation*, ser. PEPM ’14. New York, NY, USA: ACM, 2014,
pp. 71–82.
a_cite: |
M. D. Adams, A. Farmer, and J. P. Magalhães, “[Optimizing syb is easy!”
in *Proceedings of the ACM SIGPLAN 2014 Workshop on Partial Evaluation
and Program Manipulation*, ser. PEPM ’14. New York, NY, USA: ACM, 2014,
pp. 71–82.
year: 2014
links:
- <http://doi.acm.org/10.1145/2543728.2543730>
- <http://www.ittc.ku.edu/csdl/fpg/files/Adams-14-OSIE.pdf>
abstract: |
The most widely used generic-programming system in the Haskell community, Scrap Your Boilerplate (SYB), also happens to be one of the slowest. Generic traversals in SYB are about an order of magnitude slower than equivalent handwritten, non-generic traversals. Thus while SYB allows the concise expression of many traversals, its use incurs a significant runtime cost. Existing techniques for optimizing other generic-programming systems are not able to eliminate this overhead.
This paper presents an optimization that completely eliminates this cost. The optimization takes advantage of domain-specific knowledge about the structure of SYB and in so doing can optimize SYB-style traversals to be as fast as handwritten, non-generic code.
This paper presents both the formal structure of the optimization and the results of benchmarking the optimized SYB code against both unoptimized SYB code and handwritten, non-generic code. In these benchmarks, the optimized SYB code matches the performance of handwritten code even when the unoptimized SYB code is an order of magnitude or more slower.
bibtex: |
@inproceedings{Adams:14:OSIE,
author = {Adams, Michael D. and Farmer, Andrew and Magalh\~{a}es, Jos{\'e} Pedro},
title = {Optimizing SYB is Easy!},
booktitle = {Proceedings of the ACM SIGPLAN 2014 Workshop on Partial Evaluation and Program Manipulation},
series = {PEPM '14},
year = {2014},
isbn = {978-1-4503-2619-3},
location = {San Diego, California, USA},
pages = {71--82},
numpages = {12},
xurl = {http://www.ittc.ku.edu/csdl/fpg/files/Adams-14-OSIE.pdf},
doi = {10.1145/2543728.2543730},
acmid = {2543730},
publisher = {ACM},
address = {New York, NY, USA},
keywords = {datatype-generic programming, haskell, keywords: optimization, partial evaluation, performance, scrap your boilerplate (syb)},
}
- key: Sculthorpe-13-ConstrainedMonad
cite: |
N. Sculthorpe, J. Bracker, G. Giorgidze, and A. Gill, “The
constrained-monad problem,” in *International Conference on Functional
Programming*. ACM, 2013, pp. 287–298.
a_cite: |
N. Sculthorpe, J. Bracker, G. Giorgidze, and A. Gill, “[The
constrained-monad problem](/papers/Sculthorpe-13-ConstrainedMonad),” in *International Conference on Functional
Programming*. ACM, 2013, pp. 287–298.
year: 2013
links:
- <http://dl.acm.org/citation.cfm?doid=2500365.2500602>
- <http://www.ittc.ku.edu/csdl/fpg/theory/constrainedTypeClassInstances.html>
abstract: |
In Haskell, there are many data types that would form
monads were it not for the presence of type-class
constraints on the operations on that data type.
This is a frustrating problem in practice, because
there is a considerable amount of support and
infrastructure for monads that these data types
cannot use. Using several examples, we show that a
monadic computation can be restructured into a
normal form such that the standard monad class
can be used. The technique is not specific
to monads, and we show how it can also be applied to
other structures, such as applicative functors. One
significant use case for this technique is domain-specific
languages, where it is often desirable to
compile a deep embedding of a computation to some
other language, which requires restricting the types
that can appear in that computation.
bibtex: |
@inproceedings{Sculthorpe:13:ConstrainedMonad,
author = {Neil Sculthorpe and Jan Bracker and George Giorgidze and Andy Gill},
title = {The Constrained-Monad Problem},
booktitle = {International Conference on Functional Programming},
publisher = {ACM},
location = {Boston, Massachusetts},
xurl = {http://www.ittc.ku.edu/csdl/fpg/theory/constrainedTypeClassInstances.html},
pages = {287--298},
year = {2013},
}
- key: Sculthorpe-14-WorkIt
cite: |
N. Sculthorpe and G. Hutton, “Work it, wrap it, fix it, fold it,”
*Journal of Functional Programming*, vol. 24, no. 1, pp. 113–127, 2014.
a_cite: |
N. Sculthorpe and G. Hutton, “[Work it, wrap it, fix it, fold it](/papers/Sculthorpe-14-WorkIt),”
*Journal of Functional Programming*, vol. 24, no. 1, pp. 113–127, 2014.
year: 2014
links:
- <http://dx.doi.org/10.1017/S0956796814000045>
abstract: |
The worker/wrapper transformation is a general-purpose technique
for refactoring recursive programs to improve their performance.
The two previous approaches to formalising the technique were
based upon different recursion operators and different correctness
conditions. In this article we show how these two approaches can
be generalised in a uniform manner by combining their correctness
conditions, extend the theory with new conditions that are
both necessary and sufficient to ensure the correctness of the
worker/wrapper technique, and explore the benefits that result.
All the proofs have been mechanically verified using the Agda system.
bibtex: |
@article{Sculthorpe:14:WorkIt,
author = {Neil Sculthorpe and Graham Hutton},
title = {Work It, Wrap It, Fix It, Fold It},
journal = {Journal of Functional Programming},
pages = {113--127},
volume = {24},
number = {1},
year = {2014},
}
- key: Gill-13-TypesKansasLava
cite: |
A. Gill, T. Bull, A. Farmer, G. Kimmell, and E. Komp, “Types and
associated type families for hardware simulation and synthesis: The
internals and externals of <span>K</span>ansas <span>L</span>ava,” 2013,
accepted for publication in the Journal of Higher-Order and Symbolic
Computation.
a_cite: |
A. Gill, T. Bull, A. Farmer, G. Kimmell, and E. Komp, “[Types and
associated type families for hardware simulation and synthesis: The
internals and externals of <span>K</span>ansas <span>L</span>ava](/papers/Gill-13-TypesKansasLava),” 2013,
accepted for publication in the Journal of Higher-Order and Symbolic
Computation.
year: 2013
links:
abstract: |
In this article
we overview the design and implementation of the second generation
of Kansas Lava.
Driven by the needs and experiences
of implementing telemetry decoders and other circuits,
we have made a number of improvements to both the external API
and the internal representations used.
We have retained our dual shallow/deep
representation of signals in general, but now have a number of externally visible
abstractions for combinatorial and sequential circuits, and enabled signals.
We introduce these abstractions, as well as our abstractions for
reading and writing memory.
Internally, we found the need to represent unknown values inside our circuits,
so we made aggressive use of associated type families to lift our values in a principled
and regular way. We discuss this design decision, how it unfortunately
complicates the internals of Kansas Lava, and how
we mitigate this complexity.
Finally, when connecting Kansas Lava to the real world,
the standardized idiom of using named input and output ports
is provided by Kansas Lava using a new monad, called \verb|Fabric|.
We present the design of this Fabric monad, and
illustrate its use in a small but complete example.
bibtex: |
@article{Gill:13:TypesKansasLava,
title = {Types and Associated Type Families for Hardware Simulation and Synthesis:
The Internals and Externals of {K}ansas {L}ava},
author = {Andy Gill and Tristan Bull and Andrew Farmer and Garrin Kimmell and Ed Komp},
booktitle = {Post-Proceedings of Trends in Functional Programming},
note = {Accepted for publication in the Journal of Higher-Order and Symbolic Computation},
year = {2013},
}
- key: Sculthorpe-13-HERMITinTree
cite: |
N. Sculthorpe, A. Farmer, and A. Gill, “The <span>HERMIT</span> in the
tree: Mechanizing program transformations in the <span>GHC</span> core
language,” in *Proceedings of the 24th Symposium on Implementation and
Application of Functional Languages*, ser. Lecture Notes in Computer
Science, vol. 8241, 2013, pp. 86–103.
a_cite: |
N. Sculthorpe, A. Farmer, and A. Gill, “[The <span>HERMIT</span> in the
tree: Mechanizing program transformations in the <span>GHC</span> core
language](/papers/Sculthorpe-13-HERMITinTree),” in *Proceedings of the 24th Symposium on Implementation and
Application of Functional Languages*, ser. Lecture Notes in Computer
Science, vol. 8241, 2013, pp. 86–103.
year: 2013
links:
- <http://dx.doi.org/10.1007/978-3-642-41582-1_6>
- <http://www.ittc.ku.edu/csdl/fpg/files/Sculthorpe-13-HERMITinTree-extended.pdf>
abstract: |
This paper describes our experience using the HERMIT toolkit to apply
well-known transformations to the internal core language of the
Glasgow Haskell Compiler. HERMIT provides several mechanisms to
support writing general-purpose transformations: a domain-specific
language for strategic programming specialized to GHC's core
language, a library of primitive rewrites, and a shell-style--based
scripting language for interactive and batch usage.
There are many program transformation techniques that have been
described in the literature but have not been mechanized and made
available inside GHC --- either because they are too specialized to
include in a general-purpose compiler, or because the developers'
interest is in theory rather than implementation. The mechanization
process can often reveal pragmatic obstacles that are glossed over in
pen-and-paper proofs; understanding and removing these obstacles is our
concern. Using HERMIT, we implement eleven examples of three program
transformations, report on our experience, and describe improvements
made in the process.
bibtex: |
@inproceedings{Sculthorpe:13:HERMITinTree,
author = {Neil Sculthorpe and Andrew Farmer and Andy Gill},
title = {The {HERMIT} in the Tree: Mechanizing Program Transformations in the {GHC} Core Language},
booktitle = {Proceedings of the 24th Symposium on Implementation and Application of Functional Languages},
location = {Oxford, England},
series = {Lecture Notes in Computer Science},
pages = {86--103},
volume = {8241},
year = {2013},
xurl = {http://www.ittc.ku.edu/csdl/fpg/files/Sculthorpe-13-HERMITinTree-extended.pdf},
}
- key: Farmer-12-HERMITinMachine
cite: |
A. Farmer, A. Gill, E. Komp, and N. Sculthorpe, “The <span>HERMIT</span>
in the machine: A plugin for the interactive transformation of
<span>GHC</span> core language programs,” in *Proceedings of the ACM
SIGPLAN Haskell Symposium*, ser. Haskell ’12. ACM, 2012, pp. 1–12.
a_cite: |
A. Farmer, A. Gill, E. Komp, and N. Sculthorpe, “[The <span>HERMIT</span>
in the machine: A plugin for the interactive transformation of
<span>GHC</span> core language programs](/papers/Farmer-12-HERMITinMachine),” in *Proceedings of the ACM
SIGPLAN Haskell Symposium*, ser. Haskell ’12. ACM, 2012, pp. 1–12.
year: 2012
links:
- <http://doi.acm.org/10.1145/2364506.2364508>
- <http://www.ittc.ku.edu/csdl/fpg/files/Farmer-12-HERMITinMachine.pdf>
abstract: |
The importance of reasoning about and refactoring programs
is a central tenet of functional programming.
Yet our compilers and development toolchains
only provide rudimentary support for these tasks.
This paper introduces
a programmatic and compiler-centric interface
that facilitates refactoring and equational reasoning.
To develop our ideas, we have implemented HERMIT, a toolkit enabling
informal but systematic transformation of Haskell
programs from \emph{inside} the Glasgow Haskell Compiler{\textquoteright}s
optimization pipeline.
With HERMIT, users can experiment with optimizations
and equational reasoning, while the
tedious heavy lifting of performing the actual transformations
is done for them.
HERMIT provides a transformation API that can be
used to build higher-level rewrite tools.
One use-case is
prototyping new optimizations as clients of this API
before being committed to the GHC toolchain.
We describe a HERMIT application---a
read-eval-print shell for performing transformations using HERMIT.
We also demonstrate using this shell to prototype an optimization
on a specific example, and report our initial experiences and
remaining challenges.
bibtex: |
@inproceedings{Farmer:12:HERMITinMachine,
author = {Andrew Farmer and Andy Gill and Ed Komp and Neil Sculthorpe},
title = {The {HERMIT} in the Machine: A Plugin for the Interactive Transformation of {GHC} Core Language Programs},
booktitle = {Proceedings of the ACM SIGPLAN Haskell Symposium},
series = {Haskell '12},
year = {2012},
isbn = {978-1-4503-1574-6},
location = {Copenhagen, Denmark},
pages = {1--12},
xurl = {http://www.ittc.ku.edu/csdl/fpg/files/Farmer-12-HERMITinMachine.pdf},
doi = {10.1145/2364506.2364508},
acmid = {2364508},
publisher = {ACM},
keywords = {{DSL}s, equational reasoning, {GHC}, optimization, strategic programming},
}
- key: Farmer-12-WebDSLs
cite: |
A. Farmer and A. Gill, “Haskell <span>DSL</span>s for interactive web
services,” in *1st International Workshop on Cross-model Language Design
and Implementation*, Sep 2012.
a_cite: |
A. Farmer and A. Gill, “[Haskell <span>DSL</span>s for interactive web
services](/papers/Farmer-12-WebDSLs),” in *1st International Workshop on Cross-model Language Design
and Implementation*, Sep 2012.
year: 2012
links:
abstract: |
Robust cross-platform GUI-based applications are challenging to write in Haskell,
not because providing hooks into existing GUI frameworks is hard,
but because these hooks are both platform dependent and prone to rapid bit-rot.
Browser-based user interfaces implemented using
Javascript and HTML5 offer some relief from this situation,
providing a standardized cross-platform API.
However, Javascript is a client-side scripting language, and
a traditional shallow, foreign-function-call style Haskell
interface to the client does not scale well because calling a
Javascript command involves sending the command, and optionally waiting for a response, over a network.
Instead, we build a deep embedding of Javascript commands inside a Javascript monad.
Along with supporting web-based infrastructure,
we deliver entire program fragments
to our web-based applications.
Using our monad, the Haskell programmer can choose the
granularity of interaction, with the option of
having reactive interfaces that are completely
handled by the client.
bibtex: |
@inproceedings{Farmer:12:WebDSLs,
author = {Andrew Farmer and Andy Gill},
title = {Haskell {DSL}s for Interactive Web Services},
booktitle = {1st International Workshop on Cross-model Language Design and Implementation},
location = {Copenhagen, Denmark},
year = {2012},
month = {Sep},
}
- key: Frisby-12-AlmostHomomorphicFunctions
cite: |
N. Frisby, A. Gill, and P. Alexander, “A pattern for almost homomorphic
functions,” in *ACM SIGPLAN Workshop on Generic Programming*, Sep 2012.
a_cite: |
N. Frisby, A. Gill, and P. Alexander, “[A pattern for almost homomorphic
functions](/papers/Frisby-12-AlmostHomomorphicFunctions),” in *ACM SIGPLAN Workshop on Generic Programming*, Sep 2012.
year: 2012
links:
abstract: |
Strong typing presents the programmer with a trade-off between correctness and
code complexity: more exact types prevent errors but less exact types enable
reuse.
Current functional programming practice prefers general types over exact types
in large programs like compilers because of the reuse. Exact typing in these
programs would require numerous similar data types and conversions between
them.
We factor out a pattern in such conversions as a reusable Haskell function. We
extend existing generic programming techniques to define it and to use it
without introducing undue obfuscation.
Our reusable function eliminates the boilerplate for conversions between the
numerous exact types. It therefore delivers the benefits of exact types and
simulates the reusability of general types with lightweight generic
programming.
We demonstrate our function by using it to define a lambda-lifting function
with an exact range type that has no constructor for lambdas.
bibtex: |
@inproceedings{Frisby:12:AlmostHomomorphicFunctions,
author = {Nicolas Frisby and Andy Gill and Perry Alexander},
title = {A Pattern for Almost Homomorphic Functions},
booktitle = {ACM SIGPLAN Workshop on Generic Programming},
location = {Copenhagen, Denmark},
year = {2012},
month = {Sep},
}
- key: Gill-12-PatchLogic
cite: |
A. Gill and B. Neuenschwander, “Handshaking in <span>K</span>ansas
<span>L</span>ava using patch logic,” in *Practical Aspects of
Declarative Languages*, ser. LNCS, vol. 7149. Springer-Verlag, January
2012.
a_cite: |
A. Gill and B. Neuenschwander, “[Handshaking in <span>K</span>ansas
<span>L</span>ava using patch logic](/papers/Gill-12-PatchLogic),” in *Practical Aspects of
Declarative Languages*, ser. LNCS, vol. 7149. Springer-Verlag, January
2012.
year: 2012
links:
- <http://www.ittc.ku.edu/csdl/fpg/files/Gill-11-PatchLogic.pdf>
abstract: |
Designing hardware is like writing music for an
orchestra - lots of pieces have to come together at
the correct time for everything to work. In systems
design, there is a confusing array of standards for
allowing cooperating components, and little
type-level support in traditional design
methodologies for helping connect components with
pre-arranged protocols. In this paper, we explore
bringing protocol-level types to communicating
processes. Inside our hardware description language
Kansas Lava we introduce the notation of a patch,
which is a communicating component with
well-understood protocols. We build a theory round
the notion of patches, which we call patch logic,
and then use the patch abstraction to build a small
driver for an FPGA board.
bibtex: |
@inproceedings{Gill:12:PatchLogic,
title = {Handshaking in {K}ansas {L}ava using Patch Logic},
author = {Andy Gill and Bowe Neuenschwander},
booktitle = {Practical Aspects of Declarative Languages},
publisher = {Springer-Verlag},
series = {LNCS},
volume = {7149},
location = {Philadelphia, PA},
year = {2012},
month = {January},
}
- key: IFL11
cite: |
A. Gill and J. Hage, Eds., *Implementation and Application of Functional
Languages*. Springer, LNCS 7257, October 2011.
a_cite: |
A. Gill and J. Hage, Eds., *Implementation and Application of Functional
Languages*. Springer, LNCS 7257, October 2011.
year: 2011
links:
bibtex: |
@proceedings{IFL11,
title = {Implementation and Application of Functional Languages},
editor = {Andy Gill and Jurriaan Hage},
publisher = {Springer, LNCS 7257},
year = {2011},
month = {October},
}
- key: Gill-11-Declarative
cite: |
A. Gill, “Declarative <span>FPGA</span> circuit synthesis using
<span>K</span>ansas <span>L</span>ava,” in *The International Conference
on Engineering of Reconfigurable Systems and Algorithms*, July 2011.
a_cite: |
A. Gill, “[Declarative <span>FPGA</span> circuit synthesis using
<span>K</span>ansas <span>L</span>ava](/papers/Gill-11-Declarative),” in *The International Conference
on Engineering of Reconfigurable Systems and Algorithms*, July 2011.
year: 2011
links:
- <http://www.ittc.ku.edu/csdl/fpg/files/Gill-11-Declarative.pdf>
abstract: |
Designing and debugging hardware components is
challenging, especially when performance
requirements demands a complex orchestra of
cooperating and highly synchronized computation
engines. New language-based solutions to this problem
have the potential to revolutionize how we think
about and build circuits. In this paper, we describe
our language- based approach to semi-formal
co-design. Using examples, we will show how
generative techniques, high-level interfaces, and
refinement techniques like the worker/wrapper
transformation can be used to take descriptions of
specialized computation, and generate efficient
circuits. Kansas Lava, our high-level hardware
description language built on top of the functional
language Haskell, acts as a bridge between these
computational descriptions and synthesizable
VHDL. Central to the whole approach is the use of
Haskell types to express communication and timing
choices between computational components. Design
choices and engineering compromises during co-design
become type-centric refinements, encouraging
architectural exploration.
bibtex: |
@inproceedings{Gill:11:Declarative,
title = {Declarative {FPGA} Circuit Synthesis using {K}ansas {L}ava},
booktitle = {The International Conference on Engineering of Reconfigurable Systems and Algorithms},
year = {2011},
month = {July},
location = {Las Vegas, Nevada, USA},
author = {Andy Gill},
}
- key: Gill-11-DerivingLDPC
cite: |
A. Gill and A. Farmer, “Deriving an efficient <span>FPGA</span>
implementation of a low density parity check forward error corrector,”
in *Proceedings of the 16th ACM SIGPLAN international conference on
Functional programming*, ser. ICFP ’11. ACM, Sep 2011, pp. 209–220.
a_cite: |
A. Gill and A. Farmer, “[Deriving an efficient <span>FPGA</span>
implementation of a low density parity check forward error corrector](/papers/Gill-11-DerivingLDPC),”
in *Proceedings of the 16th ACM SIGPLAN international conference on
Functional programming*, ser. ICFP ’11. ACM, Sep 2011, pp. 209–220.
year: 2011
links:
- <http://doi.acm.org/10.1145/2034773.2034804>
bibtex: |
@inproceedings{Gill:11:DerivingLDPC,
author = {Gill, Andy and Farmer, Andrew},
title = {Deriving an Efficient {FPGA} Implementation of a Low Density Parity Check Forward Error Corrector},
booktitle = {Proceedings of the 16th ACM SIGPLAN international conference on Functional programming},
series = {ICFP '11},
year = {2011},
isbn = {978-1-4503-0865-6},
location = {Tokyo, Japan},
pages = {209--220},
numpages = {12},
doi = {10.1145/2034773.2034804},
acmid = {2034804},
publisher = {ACM},
keywords = {dsl, error correction, lava, ldpc},
month = {Sep},
location = {Tokyo, Japan},
}
- key: Gill-11-GeneratingLDPC
cite: |
A. Gill, T. Bull, D. DePardo, A. Farmer, E. Komp, and E. Perrins, “Using
functional programming to generate an <span>LDPC</span> forward error
corrector,” in *Proceedings of the IEEE 19th Annual International
Symposium on Field-Programmable Custom Computing Machines*, ser. FCCM
’11. IEEE Computer Society, May 2011, pp. 133–140.
a_cite: |
A. Gill, T. Bull, D. DePardo, A. Farmer, E. Komp, and E. Perrins, “[Using
functional programming to generate an <span>LDPC</span> forward error
corrector](/papers/Gill-11-GeneratingLDPC),” in *Proceedings of the IEEE 19th Annual International
Symposium on Field-Programmable Custom Computing Machines*, ser. FCCM
’11. IEEE Computer Society, May 2011, pp. 133–140.
year: 2011
links:
- <http://dx.doi.org/10.1109/FCCM.2011.31>
bibtex: |
@inproceedings{Gill:11:GeneratingLDPC,
author = {Gill, Andy and Bull, Tristan and DePardo, Dan and Farmer, Andrew and Komp, Ed and Perrins, Erik},
title = {Using Functional Programming to Generate an {LDPC} Forward Error Corrector},
booktitle = {Proceedings of the IEEE 19th Annual International Symposium on Field-Programmable Custom Computing Machines},
series = {FCCM '11},
year = {2011},
isbn = {978-0-7695-4301-7},
pages = {133--140},
numpages = {8},
doi = {10.1109/FCCM.2011.31},
acmid = {1990171},
publisher = {IEEE Computer Society},
month = {May},
location = {Salt Lake City, UT, USA},
}
- key: Bull-11-FECandFP
cite: |
T. Bull, “Forward error correction and functional programming,” Master’s
thesis, The University of Kansas, 2011.
a_cite: |
T. Bull, “[Forward error correction and functional programming](/papers/Bull-11-FECandFP),” Master’s
thesis, The University of Kansas, 2011.
year: 2011
links:
- <http://www.ittc.ku.edu/csdl/fpg/files/Bull-11-FECandFP.pdf>
abstract: |
This thesis contains a collection of work I have
performed while working on Dr. Erik Perrins’
Efficient Hardware Implementation of Iterative FEC
Decoders project. The following topics and my
contributions to those topics are included in this
thesis. The first topic is a Viterbi decoder
implemented in the Haskell programming
language. Next, I will briefly introduce Kansas
Lava, a Haskell DSL developed by my advisor,
Dr. Andy Gill, and other students and staff. The
goal of Kansas Lava is to generate efficient
synthesizable VHDL for complex circuits. I will
discuss one such circuit, a large-scale LDPC decoder
implemented in Kansas Lava that has been synthesized
and tested on FPGA hardware. After discussing the
synthesis and simulation results of the decoder
circuit, I will discuss a memory interface that was
developed for use in our HFEC system. Finally, I tie
these individual projects together in a discussion
on the benefits of functional programming in
hardware design.
bibtex: |
@mastersthesis{Bull:11:FECandFP,
author = {Tristan Bull},
title = {Forward Error Correction and Functional Programming},
school = {The University of Kansas},
year = {2011},
}
- key: Gill-11-CatchingSat
cite: |
A. Gill and G. Kimmell, “Capturing functions and catching satellites,”
Tech. Rep., January 2011, iTTC Technical Report
ITTC-FY2011-TR-29952011-1.
a_cite: |
A. Gill and G. Kimmell, “[Capturing functions and catching satellites](/papers/Gill-11-CatchingSat),”
Tech. Rep., January 2011, iTTC Technical Report
ITTC-FY2011-TR-29952011-1.
year: 2011
links:
abstract: |
The 2009 ICFP programming contest problem required contestants to control
virtual satellites that obey basic physical laws. The orbital physics
behavior of the system was simulated via a binary provided to contestants
which ran on top of a simple virtual machine. Contestants were required to
implement the virtual machine along with a controller program to manipulate
the satellite{\textquoteright}s behavior. In this paper, we describe the modeling of the
simulation environment, with a focus on the compilation and testing
infrastructure for the generated binaries for this virtual machine. This
infrastructure makes novel use of an implementation of a deeply embedded
Domain Specific Language (DSL) within Haskell. In particular, with use of
IO-based observable sharing, it was straightforward for a function to be both
an executable specification as well as a portable implementation,
and because of this the rendered binary was found to be robust and reliable.
bibtex: |
@techreport{Gill:11:CatchingSat,
title = {Capturing Functions and Catching Satellites},
note = {ITTC Technical Report ITTC-FY2011-TR-29952011-1},
year = {2011},
month = {January},
author = {Andy Gill and Garrin Kimmell},
}
- key: Gill-10-F5
cite: |
G. Hutton, M. Jaskelioff, and A. Gill, “Factorising folds for faster
functions,” *Journal of Functional Programming*, vol. 20, no. 3–4, pp.
353–373, 2010.
a_cite: |
G. Hutton, M. Jaskelioff, and A. Gill, “[Factorising folds for faster
functions](/papers/Gill-10-F5),” *Journal of Functional Programming*, vol. 20, no. 3–4, pp.
353–373, 2010.
year: 2010
links:
abstract: |
The worker/wrapper transformation is a general technique for improving the performance of
recursive programs by changing their types. The previous formalisation (Gill & Hutton, 2009) was
based upon a simple fixed point semantics of recursion. In this article we develop a more structured
approach, based upon initial algebra semantics. In particular, we show how the worker/wrapper
transformation can be applied to programs defined using the structured pattern of recursion captured
by fold operators, and illustrate our new technique with a number of examples.
bibtex: |
@article{Gill:10:F5,
author = {Graham Hutton and Mauro Jaskelioff and Andy Gill},
title = {Factorising Folds for Faster Functions},
journal = {Journal of Functional Programming},
publisher = {Cambridge University Press},
volume = {20},
number = {3--4},
pages = {353--373},
year = {2010},
}
- key: Matlage-10-BeginningMiddleEnd
cite: |
K. Matlage and A. Gill, “Every animation should have a beginning, a
middle, and an end,” in *Post-Proceedings of Trends in Functional
Programming*, ser. LNCS, vol. 6546. Springer-Verlag, May 2010.
a_cite: |
K. Matlage and A. Gill, “[Every animation should have a beginning, a
middle, and an end](/papers/Matlage-10-BeginningMiddleEnd),” in *Post-Proceedings of Trends in Functional
Programming*, ser. LNCS, vol. 6546. Springer-Verlag, May 2010.
year: 2010
links:
- <http://www.ittc.ku.edu/csdl/fpg/files/Matlage-10-BeginningMiddleEnd.pdf>
abstract: |
Animations are sequences of still images chained
together to tell a story. Every story should have a
beginning, a middle, and an end. We argue that this
advice leads to a simple and useful idiom for
creating an animation Domain Specific Language
(DSL). We introduce our animation DSL, and show how
it captures the concept of beginning, middle, and
end inside a Haskell applicative functor we call
Active. We have an implementation of our DSL inside
the image generation accelerator, ChalkBoard, and we
use our DSL on an extended example, animating a
visual demonstration of the Pythagorean Theorem.
bibtex: |
@inproceedings{Matlage:10:BeginningMiddleEnd,
title = {Every Animation Should Have a Beginning, a Middle, and an End},
author = {Kevin Matlage and Andy Gill},
booktitle = {Post-Proceedings of Trends in Functional Programming},
month = {May},
year = {2010},
xurl = {http://www.ittc.ku.edu/csdl/fpg/files/Matlage-10-BeginningMiddleEnd.pdf},
publisher = {Springer-Verlag},
series = {LNCS},
volume = {6546},
}
- key: Gill-10-TypesKansasLava
cite: |
A. Gill, T. Bull, A. Farmer, G. Kimmell, and E. Komp, “Types and type
families for hardware simulation and synthesis: The internals and
externals of <span>K</span>ansas <span>L</span>ava,” in
*Post-Proceedings of Trends in Functional Programming*, ser. LNCS, vol.
6546. Springer-Verlag, May 2010.
a_cite: |
A. Gill, T. Bull, A. Farmer, G. Kimmell, and E. Komp, “[Types and type
families for hardware simulation and synthesis: The internals and
externals of <span>K</span>ansas <span>L</span>ava](/papers/Gill-10-TypesKansasLava),” in
*Post-Proceedings of Trends in Functional Programming*, ser. LNCS, vol.
6546. Springer-Verlag, May 2010.
year: 2010
links:
abstract: |
In this paper,
we overview the design and implementation of our latest
version of Kansas Lava. Driven by needs and experiences
of implementing telemetry circuits,
we have made a number of recent improvements to both the external API
and the internal representations used.
We have retained our dual shallow/deep
representation of signals in general, but now have a number of externally visible
abstractions for combinatorial, sequential, and enabled signals.
We introduce these abstractions, as well as our new abstractions for
memory and memory updates.
Internally, we found the need to represent unknown values inside our circuits,
so we made aggressive use of type families to lift our values in a principled
and regular way. We discuss this design decision, how it unfortunately
complicates the internals of Kansas Lava, and how
we mitigate this complexity.
bibtex: |
@inproceedings{Gill:10:TypesKansasLava,
title = {Types and Type Families for Hardware Simulation and Synthesis: The Internals and Externals of {K}ansas {L}ava},
author = {Andy Gill and Tristan Bull and Andrew Farmer and Garrin Kimmell and Ed Komp},
booktitle = {Post-Proceedings of Trends in Functional Programming},
month = {May},
year = {2010},
publisher = {Springer-Verlag},
series = {LNCS},
volume = {6546},
}
- key: Farmer-10-WhatsTheMatter
cite: |
A. Farmer, G. Kimmell, and A. Gill, “What’s the matter with
<span>K</span>ansas <span>L</span>ava?” in *Post-Proceedings of Trends
in Functional Programming*. Springer-Verlag, LNCS 6546, May 2010.
a_cite: |
A. Farmer, G. Kimmell, and A. Gill, “[What’s the matter with
<span>K</span>ansas <span>L</span>ava?” in *Post-Proceedings of Trends
in Functional Programming*. Springer-Verlag, LNCS 6546, May 2010.
year: 2010
links:
abstract: |
Kansas Lava is a functional hardware description language implemented
in Haskell. In the course of attempting to generate ever larger circuits,
we have found the need to effectively test and debug the internals of
Kansas Lava. This includes confirming both the simulated behavior of the
circuit and its hardware realization via generated VHDL. In
this paper we share our approach to this problem, and discuss
the results of these efforts.
bibtex: |
@inproceedings{Farmer:10:WhatsTheMatter,
title = {What's the matter with {K}ansas {L}ava?},
author = {Andrew Farmer and Garrin Kimmell and Andy Gill},
booktitle = {Post-Proceedings of Trends in Functional Programming},
month = {May},
publisher = {Springer-Verlag, LNCS 6546},
year = {2010},
}
- key: Gill-10-ImprovingVideo
cite: |
A. Gill, G. Kimmell, and K. Matlage, “Improving the presentation of
technical material in video talks using post production,” in *2010
Midwest Section Conference of the American Society for Engineering
Education*, September 2010.
a_cite: |
A. Gill, G. Kimmell, and K. Matlage, “[Improving the presentation of
technical material in video talks using post production](/papers/Gill-10-ImprovingVideo),” in *2010
Midwest Section Conference of the American Society for Engineering
Education*, September 2010.
year: 2010
links:
- <http://www.ittc.ku.edu/csdl/fpg/files/Gill-10-ImprovingVideo.pdf>
abstract: |
In this paper, we present our experiences using our image processing toolkit
ChalkBoard and other video processing tools to post-process a pre-recorded
conference talk. With inexpensive video cameras, video services like youtube.com
and vimeo.com, and widely available and inexpensive video editing software, we
expect this new media to be increasingly used as a mechanism to both promote
research agendas and deliver technical content. In order to explore the use of
such media in more detail, the Functional Programming group at KU recorded a
technical talk and experimented with various post-processing tricks to enhance
the value of the talk. Specifically, we fixed a common lensing issue in software,
added small animations and pictures which matched the gestures of the actors,
improved the visual quality of the slides being talked to,
and experimented with a post-hoc zoom. Overall, the post-processing
stage took considerably longer than anticipated, but did add perceivable
value and impact to the final video.
bibtex: |
@inproceedings{Gill:10:ImprovingVideo,
title = {Improving the Presentation of Technical Material in Video Talks using Post Production},
booktitle = {2010 Midwest Section Conference of the American Society for Engineering Education},
year = {2010},
month = {September},
author = {Andy Gill and Garrin Kimmell and Kevin Matlage},
what = {Minor},
}
- key: Matlage-09-ChalkBoard
cite: |
K. Matlage and A. Gill, “Chalk<span>B</span>oard: <span>M</span>apping
functions to polygons,” in *Proceedings of the Symposium on
Implementation and Application of Functional Languages*, ser. LNCS, vol.
6041. Springer-Verlag, Sep 2009.
a_cite: |
K. Matlage and A. Gill, “[Chalk<span>B</span>oard: <span>M</span>apping
functions to polygons](/papers/Matlage-09-ChalkBoard),” in *Proceedings of the Symposium on
Implementation and Application of Functional Languages*, ser. LNCS, vol.
6041. Springer-Verlag, Sep 2009.
year: 2009
links:
abstract: |
ChalkBoard is a domain specific language for describing images.
The ChalkBoard language is uncompromisingly functional
and encourages the use of modern functional idioms.
ChalkBoard uses off-the-shelf
graphics cards to speed up rendering of functional descriptions.
In this paper, we
describe the design of the core ChalkBoard language,
and the architecture of our static image generation accelerator.
bibtex: |
@inproceedings{Matlage:09:ChalkBoard,
author = {Kevin Matlage and Andy Gill},
title = {Chalk{B}oard: {M}apping Functions to Polygons},
booktitle = {Proceedings of the Symposium on Implementation and Application of Functional Languages},
publisher = {Springer-Verlag},
series = {LNCS},
volume = {6041},
month = {Sep},
year = {2009},
}
- key: Gill-09-KansasLava
cite: |
A. Gill, T. Bull, G. Kimmell, E. Perrins, E. Komp, and B. Werling,
“Introducing <span>K</span>ansas <span>L</span>ava,” in *Proceedings of
the Symposium on Implementation and Application of Functional
Languages*, ser. LNCS, vol. 6041. Springer-Verlag, Sep 2009.
a_cite: |
A. Gill, T. Bull, G. Kimmell, E. Perrins, E. Komp, and B. Werling,
“[Introducing <span>K</span>ansas <span>L</span>ava](/papers/Gill-09-KansasLava),” in *Proceedings of
the Symposium on Implementation and Application of Functional
Languages*, ser. LNCS, vol. 6041. Springer-Verlag, Sep 2009.
year: 2009
links:
abstract: |
Kansas Lava is a domain specific language for hardware description.
Though there have been a number of previous implementations of Lava,
we have found the design space rich, with unexplored choices.
We use a direct (Chalmers style)
specification of circuits, and make significant use of Haskell
overloading of standard classes, leading to concise circuit
descriptions.
Kansas Lava supports both simulation (inside GHCi),
and execution via VHDL, by having a dual shallow and deep embedding
inside our Signal type.
We also have a lightweight sized-type mechanism,
allowing for MATLAB style matrix based specifications to be directly
expressed in Kansas Lava.
bibtex: |
@inproceedings{Gill:09:KansasLava,
author = {Andy Gill and Tristan Bull and Garrin Kimmell and Erik Perrins and Ed Komp and Brett Werling},
title = {Introducing {K}ansas {L}ava},
booktitle = {Proceedings of the Symposium on Implementation and Application of Functional Languages},
publisher = {Springer-Verlag},
series = {LNCS},
volume = {6041},
month = {Sep},
year = {2009},
}
- key: Werling-09-ITC
cite: |
B. Werling, E. Perrins, and A. Gill, “Implementation of an
<span>LDPC</span> decoder using functional programming languages,” in
*Proceedings of the International Telemetering Conference*, Oct 2009,
(Student Paper).
a_cite: |
B. Werling, E. Perrins, and A. Gill, “[Implementation of an
<span>LDPC</span> decoder using functional programming languages](/papers/Werling-09-ITC),” in
*Proceedings of the International Telemetering Conference*, Oct 2009,
(Student Paper).
year: 2009
links:
bibtex: |