@InProceedings{read16,
  author =       {Ulrich Hoffmann and Andrew Read},
  title =        {A synchronous FORTH framework for hard real-time control},
  crossref =     {euroforth16},
  pages =        {5--29},
  url =          {http://www.euroforth.org/ef16/papers/read.pdf},
  video =	 {https://wiki.forth-ev.de/lib/exe/fetch.php/events:sync-rt.mp4},
  OPTnote =      {refereed},
  abstract =     {Forth control programs are typically written in an
                  event triggered style: events that take place in the
                  environment interrupt the main control program. The
                  interrupt handler either handles the event
                  completely on its own (if that's simple enough or
                  timing requires it) or it triggers a task from an
                  underlying multitasking system to take care of the
                  event (in a non timing critical way). Most Forth
                  multitasking systems are cooperative thus oering
                  high reliability and predictable timing
                  behavior. The framework described here uses a
                  synchronous approach to meet hard real-time
                  requirements. The approach borrows from dierent
                  sources, most notably from synchronous hardware
                  design, where signals are updated at a xed cycle
                  rate, and program logic is implemented via nite
                  state machines. Despite the fact that applications
                  built with this framework follow hard real time
                  constraints they may still retain interactivity
                  through a FORTH interpreter. This is accomplished by
                  means of an optional high level threaded code
                  interpreter which can be executed in a step-wise way
                  and will only progress as fast as necessary to still
                  be within the real-time boundaries. The only
                  requirement for this framework is a single
                  free-running counter/timer with a known clock
                  period. All other functionality is expressed in
                  standard Forth and is thus portable to different
                  standard systems.}
}

@InProceedings{baranov16,
  author =       {Sergey Baranov},
  title =        {Simulating Recurrent Neural Networks in Forth},
  crossref =     {euroforth16},
  pages =        {30--38},
  url =          {http://www.euroforth.org/ef16/papers/baranov.pdf},
  video =	 {https://wiki.forth-ev.de/lib/exe/fetch.php/events:neural-networks.mp4},
  OPTnote =      {refereed}
}

@InProceedings{nelson16,
  author =       {Nick J. Nelson},
  title =        {Tunnel Vision},
  crossref =     {euroforth16},
  pages =        {39--44},
  url =          {http://www.euroforth.org/ef16/papers/nelson.pdf},
  video =	 {https://wiki.forth-ev.de/lib/exe/fetch.php/events:tunnel-vision.mp4},
  OPTnote =      {not refereed},
  abstract =     {An industrial control system written in Forth is
                  described, using multiple techniques introduced in
                  previous Euroforth presentations.}
}

@InProceedings{stoddart16,
  author =       {Bill Stoddart},
  title =        {The Halting Problem in Forth},
  crossref =     {euroforth16},
  pages =        {45--48},
  url =          {http://www.euroforth.org/ef16/papers/stoddart.pdf},
  video =	 {https://wiki.forth-ev.de/lib/exe/fetch.php/events:halting.mp4},
  OPTnote =      {not refereed},
  abstract =     {Forth can be used to formulate a simplied but fully
                  general statement of the halting problem and to
                  formulate a short and simple proof.}
}

@InProceedings{read-ax16,
  author =       {Andrew Read},
  title =        {An Axiomatic Approach to Forth},
  crossref =     {euroforth16},
  pages =        {49--53},
  url =          {http://www.euroforth.org/ef16/papers/read-ax.pdf},
  video =	 {https://wiki.forth-ev.de/lib/exe/fetch.php/events:axiomatic.mp4},
  OPTnote =      {not refereed}
}

@InProceedings{wejgaard16,
  author =       {Wolf Wejgaard},
  title =        {Planet Holonforth},
  crossref =     {euroforth16},
  pages =        {54},
  url =          {http://www.euroforth.org/ef16/papers/wejgaard.pdf},
  video =	 {https://wiki.forth-ev.de/lib/exe/fetch.php/events:holonforth.mp4},
  OPTnote =      {not refereed}
}

@InProceedings{ertl-sections16,
  author =       {M. Anton Ertl},
  title =        {Sections},
  crossref =     {euroforth16},
  pages =        {55--57},
  url =          {http://www.euroforth.org/ef16/papers/ertl-sections.pdf},
  video =	 {https://wiki.forth-ev.de/lib/exe/fetch.php/events:sections.mp4},
  OPTnote =      {not refereed},
  abstract =     {A section is a contiguous region of memory, to which
                  data or code can be appended (like the Forth
                  dictionary). Assembly languages and linkers have
                  supported multiple sections for a long time. This
                  paper describes the benefits of supporting multiple
                  sections in Forth, interfaces and implementation
                  techniques.}
}

@InProceedings{ertl-recognizers16,
  author =       {M. Anton Ertl},
  title =        {Recognizers: Arguments and Design Decisions},
  crossref =     {euroforth16},
  pages =        {58--63},
  url =          {http://www.euroforth.org/ef16/papers/ertl-recognizers.pdf},
  video =	 {https://wiki.forth-ev.de/lib/exe/fetch.php/events:recognizers.mp4},
  OPTnote =      {not refereed},
  abstract =     {The Forth text interpreter processes words and
                  numbers.  Currently the set of words can be extended
                  by programmers, but not the recognized numbers.
                  User-defined recognizers allow to extend the
                  number-recognizer part, too.  This paper shows the
                  benefits of recognizers and discusses
                  counterarguments.  It also discusses several design
                  decisions: Whether to define temporary words, or a
                  set of interpretation, compilation, and postponing
                  actions; and whether to hook the recognizers inside
                  \code{find} or in the text interpreter.}
}

@InProceedings{pelc16,
  author =       {Stephen Pelc},
  title =        {The Sockpuppet Forth to C interface},
  crossref =     {euroforth16},
  pages =        {64--70},
  url =          {http://www.euroforth.org/ef16/papers/pelc.pdf},
  video =	 {https://wiki.forth-ev.de/lib/exe/fetch.php/events:sockpuppet.mp4},
  OPTnote =      {not refereed},
  abstract =     {As processors become ever more complex and the
                  software we are asked to write becomes more complex,
                  it takes ever longer to write the basic drivers for
                  an embedded system. A full digital audio chain is
                  vastly more complex than pumping DAC output into an
                  audio amplifier. Silicon vendors provide C libraries
                  to make using their chips easier. Rather than
                  convert these libraries to Forth, MPE now provides a
                  mechanism to call the C library from Forth.}
}

@InProceedings{hoffmann16,
  author =       {Ulrich Hoffmann},
  title =        {Implementing the Forth Inner Interpreter in High Level Forth},
  crossref =     {euroforth16},
  pages =        {71--78},
  url =          {http://www.euroforth.org/ef16/papers/hoffmann.pdf},
  video =	 {https://wiki.forth-ev.de/lib/exe/fetch.php/events:interpreter.mp4},
  OPTnote =      {not refereed},
  abstract =     {This document defines a Forth threaded code (inner)
                  interpreter written entirely in high level standard
                  Forth. For this it defines a specific threaded code
                  structure of colon definitions, a compiler from high
                  level Forth to this threaded code and a
                  corresponding inner interpreter to execute it. This
                  inner interpreter can run in a stepwise way and so
                  gives the surrounding environment control of its
                  execution behavior. A real time environment thus
                  might slice the execution of threaded code in small
                  pieces and provide an interactive command shell
                  while still meeting its real time requirements.}
}

@InProceedings{wodni16,
  author =       {Gerald Wodni},
  title =        {f --- A package manager for (the)Forth(.net)},
  crossref =     {euroforth16},
  pages =        {79},
  url =          {http://www.euroforth.org/ef16/papers/wodni.pdf},
  video =	 {https://wiki.forth-ev.de/lib/exe/fetch.php/events:f.mp4},
  OPTnote =      {not refereed},
  abstract =     {Let us join Forthes and share great code with each
                  other --- in an orderly fashion.}
}

@InProceedings{paysan16,
  author =       {Bernd Paysan},
  title =        {net2o: Using net2o},
  crossref =     {euroforth16},
  pages =        {80--81},
  url =          {http://www.euroforth.org/ef16/papers/paysan.pdf},
  url-slides =   {http://www.euroforth.org/ef16/papers/paysan-slides.pdf},
  video =	 {https://wiki.forth-ev.de/lib/exe/fetch.php/events:using-net2o.mp4},
  OPTnote =      {presentation slides}
}

@InProceedings{ertl-secure16,
  author =       {M. Anton Ertl},
  title =        {Security},
  crossref =     {euroforth16},
  pages =        {82--83},
  url =          {http://www.euroforth.org/ef16/papers/ertl-secure.pdf},
  video =	 {https://wiki.forth-ev.de/lib/exe/fetch.php/events:security.mp4},
  OPTnote =      {presentation slides}
}

@InProceedings{schleisiek16,
  author =       {Klaus Schleisiek},
  title =        {synthesizing Forth},
  crossref =     {euroforth16},
  pages =        {84},
  url =          {http://www.euroforth.org/ef16/papers/schleisiek.pdf},
  video =        {https://wiki.forth-ev.de/lib/exe/fetch.php/events:synthesizing-forth.mp4},
  OPTnote =      {presentation slides},
  abstract =     {}
}

@Proceedings{euroforth16,
  title = 	 {32nd EuroForth Conference},
  booktitle = 	 {32nd EuroForth Conference},
  year = 	 {2016},
  key =		 {EuroForth'16},
  url =          {http://www.complang.tuwien.ac.at/anton/euroforth/ef16/papers/proceedings.pdf}
}