@InProceedings{stoddart23,
  author =       {Bill Stoddart and Frank Zeyda},
  title =        {Prospective values and Forth},
  crossref =     {euroforth23},
  pages =        {5--15},
  url =          {http://www.euroforth.org/ef23/papers/stoddart.pdf},
  video =        {https://www.youtube.com/watch?v=RnQwFbkeNZQ},
  OPTnote =      {not refereed},
  abstract =     {We use $S \diamond E$ to represent the value
                  expression E would have were it to be evaluated
                  after the execution of program S. We call this the
                  prospective value of E after S. This form is
                  expressive enough to describe the semantics of an
                  extended form of sequential programming language
                  that incorporates backtracking and speculative
                  computations. Here we try it out with Forth.}
}

@InProceedings{laagel23,
  author =       {François Laagel},
  title =        {On Solving Hexadoku and Debugging Recursive Programs with Message Digests of the Data Stack},
  crossref =     {euroforth23},
  pages =        {16--19},
  url =          {http://www.euroforth.org/ef23/papers/laagel.pdf},
  url-slides =   {http://www.euroforth.org/ef23/papers/laagel-slides.pdf},
  video =        {https://www.youtube.com/watch?v=OFIxfCywh0Q},
  OPTnote =      {not refereed},
  abstract =     {Debugging Forth code is diﬃcult, especially when
                  dealing with recursive code. One has to maintain
                  invariants and ensure that the data stack is not
                  unduly modiﬁed. This document presents a new
                  technique called stack digesting which helps the
                  programmer quickly converge on coding errors. It is
                  based on a cryptographic message digest algorithm
                  that is completely speciﬁed in [1]. Although the
                  NIST deprecated this message digest generation
                  mechanism in 2011, it serves our debugging purposes
                  well enough. The idea is based on the insertion of
                  strategically placed probing points in the code
                  being debugged so as to make sure that invariants
                  are actually preserved.}
}

@InProceedings{nelson-oracle23,
  author =       {Nick J. Nelson},
  title =        {Accessing an Oracle database using Forth},
  crossref =     {euroforth23},
  pages =        {20--28},
  url =          {http://www.euroforth.org/ef23/papers/nelson-oracle.pdf},
  video =        {https://www.youtube.com/watch?v=V2Yzgc5Xdx8},
  OPTnote =      {not refereed},
  abstract =     {It is occasionally necessary to access an Oracle
                  database from a Forth applications.  This paper
                  illustrates the techniques we have used.}
}

@InProceedings{nelson-enumeration23,
  author =       {Nick J. Nelson},
  title =        {A proposed standard Forth style enumeration word set, using recognisers},
  crossref =     {euroforth23},
  pages =        {29--37},
  url =          {http://www.euroforth.org/ef23/papers/nelson-enumeration.pdf},
  video =        {https://www.youtube.com/watch?v=iTJkxsPJYV0},
  OPTnote =      {not refereed},
  abstract =     {The lack of an ENUM word in the Forth standard has
                  been previously noted.  The paper describes a
                  solution that is fully faithful to Forth styling.
                  The implementation uses recognisers. Some
                  potentially useful extensions will be discussed.}
}

@InProceedings{ertl23,
  author =       {M. Anton Ertl},
  title =        {Fix Spectre in Hardware! Why and How},
  crossref =     {euroforth23},
  pages =        {38--47},
  url =          {http://www.euroforth.org/ef23/papers/ertl.pdf},
  url-slides =   {http://www.euroforth.org/ef23/papers/ertl-slides.pdf},
  OPTnote =      {not refereed},
  abstract =     {Spectre can be fixed in hardware by treating
                  speculative microarchitectural state in the same way
                  as speculative architectural state: On
                  mis-speculation throw away all the
                  speculatively-performed changes.  The
                  resource-contention side channel needs to be closed,
                  too.  This position paper also explains how Spectre
                  works, why software mitigations are not sufficient.}
}

@InProceedings{faulkner23,
  author =       {Glyn Faulkner},
  title =        {4g and F.A.I.L.: Writing all the Forths},
  crossref =     {euroforth23},
  pages =        {48--55},
  url =          {http://www.euroforth.org/ef23/papers/faulkner.pdf},
  url-slides =   {http://www.euroforth.org/ef23/papers/faulkner-slides.pdf},
  video =        {https://www.youtube.com/watch?v=DVHdwEI9Me0},
  OPTnote =      {presentation slides},
  abstract =     {In last year's talk about my unhealthy obsession
                  with writing Forths I joked that the next step would
                  be to automate my hobby. At least I thought I was
                  joking: this year I present 4g, the Forth Generator,
                  which produces Forth interpreters based on a set of
                  user-supplied parameters, and F.A.I.L, the Forth
                  Abstract Instruction Language, a Forth-specific
                  assembly language that abstracts away implementation
                  details like threading-model, register mappings and
                  dictionary structure.}
}

@InProceedings{ertl-ip-updates23,
  author =       {M. Anton Ertl},
  title =        {The Performance Effects of Virtual-Machine Instruction Pointer Updates},
  crossref =     {euroforth23},
  pages =        {56--59},
  url =          {http://www.euroforth.org/ef23/papers/ertl-ip-updates.pdf},
  url-slides =   {http://www.euroforth.org/ef23/papers/ertl-ip-updates-slides.pdf},
  video =        {https://www.youtube.com/watch?v=fTLR33KRp_E},
  OPTnote =      {presentation slides},
  abstract =     {By optimizing instruction-pointer updates away where
                  possible, the number of executed instructions is
                  typically reduced by a factor of 1.2. The speedup
                  varies widely with the microarchitecture and
                  benchmark, from slowdowns by a factor of 1.1 to
                  speedups by a factor of 2.2. This talk looks at how
                  the big speedups can be explained, and at an
                  alternative way to achieve some of the same
                  speedups.}
}

@Misc{wodni23,
  author =       {Gerald Wodni},
  title =        {VFX TUI},
  howpublished = {https://www.youtube.com/watch?v=sog1-puxIUQ},
  year =         {2023},
  note =         {Video of otherwise unpublished talk at EuroForth 2023},
  abstract =     {UI5 is well on its way, but we took a pit-stop to
                  implement some features on a lower level. So now we
                  have a super shiny Terminal interface.}
}

@Misc{hoffmann23,
  author =       {Ulrich Hoffmann},
  title =        {Value Flavoured Structures},
  howpublished = {https://www.youtube.com/watch?v=LB9xzIdlStQ},
  year =         {2023},
  note =         {Video of otherwise unpublished talk at EuroForth 2023},
  abstract =     {This talk presents an implementation of Forth Value
                  Flavoured Structures, collections of data elements
                  with named fields that are associated with their
                  appropriate access operators. This reliefs the
                  programmer to remember the types and access
                  operators for all the fields in structures.}
}

@Proceedings{euroforth23,
  title = 	 {39th EuroForth Conference},
  booktitle = 	 {39th EuroForth Conference},
  year = 	 {2023},
  key =		 {EuroForth'23},
  url =          {http://www.euroforth.org/ef23/papers/proceedings.pdf}
}