updates

[phd-thesis.git] / tiot.bib

diff --git a/tiot.bib b/tiot.bib
index ecd62ca..956c207 100644 (file)
--- a/tiot.bib
+++ b/tiot.bib
@@ -203,19 +203,6 @@ pages = {59–70},
        author = {Guinard, Dominique and Trifa, Vlad},
        year = {2016}
 }
-
-@inproceedings{ireland2009classification,
-  title={A classification of object-relational impedance mismatch},
-  author={Ireland, Christopher and Bowers, David and Newton, Michael and Waugh, Kevin},
-  booktitle={2009 First International Confernce on Advances in Databases, Knowledge, and Data Applications},
-  pages={36--43},
-  year={2009},
-  organization={IEEE},
-  publisher={IEEE},
-       doi={10.1109/DBKDA.2009.11},
-       address={Gosier, France}
-}
-
 @article{maccormack2007impact,
   title={The impact of component modularity on design evolution: Evidence from the software industry},
   author={MacCormack, Alan and Rusnak, John and Baldwin, Carliss Y},
@@ -596,24 +583,13 @@ series = {Onward! 2020}
 }
 
 @misc{CircuitPython,
-       author = "CircuitPython Team",
+       author = {{CircuitPython Team}},
        title = "CircuitPython",
        year = "2022",
        url = "https://circuitpython.org/",
        note = "[Online; accessed 2-March-2022]"
 }
 
-@article{barendsen_smetsers_1996,
-       title={Uniqueness typing for functional languages with graph rewriting semantics}, 
-       volume={6}, 
-       DOI={10.1017/S0960129500070109}, 
-       number={6}, 
-       journal={Mathematical Structures in Computer Science}, 
-       publisher={Cambridge University Press}, 
-       author={Barendsen, Erik and Smetsers, Sjaak}, 
-       year={1996}, 
-       pages={579–612}
-}
 @InProceedings{GenericProgrammingExtensionForClean,
        author = "Alimarine, Artem and Plasmeijer, Rinus",
        editor = "Arts, Thomas and Mohnen, Markus",
@@ -634,7 +610,7 @@ series = {Onward! 2020}
        publisher = {Association for Computing Machinery},
        address = {New York, NY, USA},
        doi = {10.1145/325694.325709},
-       abstract = {This paper describes a new approach to generic functional programming, which allows us to define functions generically for all datatypes expressible in Haskell. A generic function is one that is defined by induction on the structure of types. Typical examples include pretty printers, parsers, and comparison functions. The advanced type system of Haskell presents a real challenge: datatypes may be parameterized not only by types but also by type constructors, type definitions may involve mutual recursion, and recursive calls of type constructors can be arbitrarily nested. We show that—despite this complexity—a generic function is uniquely defined by giving cases for primitive types and type constructors (such as disjoint unions and cartesian products). Given this information a generic function can be specialized to arbitrary Haskell datatypes. The key idea of the approach is to model types by terms of the simply typed λ-calculus augmented by a family of recursion operators. While conceptually simple, our approach places high demands on the type system: it requires polymorphic recursion, rank-n types, and a strong form of type constructor polymorphism. Finally, we point out connections to Haskell's class system and show that our approach generalizes type classes in some respects.},
+       abstract = {This paper describes a new approach to generic functional programming, which allows us to define functions generically for all datatypes expressible in Haskell. A generic function is one that is defined by induction on the structure of types. Typical examples include pretty printers, parsers, and comparison functions. The advanced type system of Haskell presents a real challenge: datatypes may be parameterized not only by types but also by type constructors, type definitions may involve mutual recursion, and recursive calls of type constructors can be arbitrarily nested. We show that—despite this complexity—a generic function is uniquely defined by giving cases for primitive types and type constructors (such as disjoint unions and cartesian products). Given this information a generic function can be specialized to arbitrary Haskell datatypes. The key idea of the approach is to model types by terms of the simply typed $\lambda-calculus augmented by a family of recursion operators. While conceptually simple, our approach places high demands on the type system: it requires polymorphic recursion, rank-n types, and a strong form of type constructor polymorphism. Finally, we point out connections to Haskell's class system and show that our approach generalizes type classes in some respects.},
        booktitle = {Proceedings of the 27th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages},
        pages = {119–132},
        numpages = {14},
@@ -1382,7 +1358,7 @@ series = {Onward! 2014}
 
 @misc{diffmicro,
  title = "MicroPython Differences from CPython",
- author = "Micropython Official Website",
+ author = {{Micropython Team}},
  year = "2022",
  note = "https://docs.micropython.org/en/latest/genrst/index.html",
 }