@InProceedings{read18, author = {Ulrich Hoffmann and Andrew Read}, title = {A descriptor based approach to {Forth} strings}, crossref = {euroforth18}, pages = {5--16}, url = {http://www.euroforth.org/ef18/papers/read.pdf}, video = {https://wiki.forth-ev.de/doku.php/events:ef2018:strings}, OPTnote = {refereed}, abstract = {We have developed a novel, descriptor based based approach to Forth strings based on the established technique of array slices, most recently exemplied by the Go programming language. We have done this with the goal of creating a strings package that is suitable be incorporated into the Forth kernel. We illustrate the convenience and potential utility of our approach with a lightweight regular expression matcher. We argue that the descriptor based approach provides much of the functionality that has been traditionally obtained with string stacks, but more simply and closely integrated with Forth, and therefore more easilty adopted as a foundational layer in the kernel. We see a potential role for our approach on any Forth system needing more than the bare minimalism of c-addr u strings.} } @InProceedings{ertl18, author = {M. Anton Ertl and Bernd Paysan}, title = {Closures --- the {Forth} way}, crossref = {euroforth18}, pages = {17--30}, url = {http://www.euroforth.org/ef18/papers/ertl.pdf}, url-slides = {http://www.euroforth.org/ef18/papers/ertl-slides.pdf}, video = {https://wiki.forth-ev.de/doku.php/events:ef2018:closures}, OPTnote = {refereed}, abstract = {In Forth 200x, a quotation cannot access a local defined outside it, and therefore cannot be parameterized in the definition that produces its execution token. We present Forth closures; they lift this restriction with minimal implementation complexity. They are based on passing parameters on the stack when producing the execution token. The programmer has to explicitly manage the memory of the closure. We show a number of usage examples. We also present the current implementation, which takes 109~source lines of code (including some extra features). The programmer can mechanically convert lexical scoping (accessing a local defined outside) into code using our closures, by applying assignment conversion and flat-closure conversion. The result can do everything one expects from closures, including passing Knuth's man-or-boy test and living beyond the end of their enclosing definitions.} } @InProceedings{bensusan18, author = {M. Franck Bensusan}, title = {Method dispatch in {Oforth}}, crossref = {euroforth18}, pages = {31--36}, url = {http://www.euroforth.org/ef18/papers/bensusan.pdf}, url-slides = {http://www.euroforth.org/ef18/papers/bensusan-slides.pdf}, video = {https://wiki.forth-ev.de/doku.php/events:ef2018:oforth}, OPTnote = {not refereed}, abstract = {Oforth is a Forth dialect that implements Object Oriented Programming as a built-in mechanism. For methods, it provides a full dynamic binding : two classes that are unrelated (ie Object is their common parent) can implement methods with the same name and the method to execute is resolved at runtime. Furthermore, classes are never "closed" and it is possible to extend a class with new methods at any moment. As many core words are implemented as methods, method dispatch must be as fast as possible, while, if possible, limiting the memory used. This paper discusses the implementation of method dispatch in Oforth : classic virtual tables are used to cache code addresses but they are allocated and constructed at runtime, while methods are executed. This is done without suffering much performance penalties.} } @InProceedings{knaggs18, author = {Peter Knaggs}, title = {A List Toolkit}, crossref = {euroforth18}, pages = {37--44}, url = {http://www.euroforth.org/ef18/papers/knaggs.pdf}, video = {https://wiki.forth-ev.de/doku.php/events:ef2018:list}, OPTnote = {not refereed} } @InProceedings{hoffmann18, author = {Ulrich Hoffmann and Andrew Read}, title = {Forth: A New Synthesis --- Progress Report: Growing {Forth} with {seedForth}}, crossref = {euroforth18}, pages = {45--51}, url = {http://www.euroforth.org/ef18/papers/hoffmann.pdf}, url-slides = {http://www.euroforth.org/ef18/papers/hoffmann-slides.pdf}, video = {https://wiki.forth-ev.de/doku.php/events:ef2018:synthesis}, OPTnote = {not refereed} } @InProceedings{paysan18, author = {Bernd Paysan}, title = {net2o: {MINOS2} {GUI}, \$quid "crypto"}, crossref = {euroforth18}, pages = {52--53}, url = {http://www.euroforth.org/ef18/papers/paysan.pdf}, url-slides = {http://www.euroforth.org/ef18/papers/paysan-slides.pdf}, video = {https://wiki.forth-ev.de/doku.php/events:ef2018:net2o}, OPTnote = {presentation slides} } @InProceedings{ertl-chaining18, author = {M. Anton Ertl}, title = {Software Vector Chaining}, crossref = {euroforth18}, pages = {54}, url = {http://www.euroforth.org/ef18/papers/ertl-chaining.pdf}, url-slides = {http://www.euroforth.org/ef18/papers/ertl-chaining-slides.pdf}, video = {https://wiki.forth-ev.de/doku.php/events:ef2018:vectors}, OPTnote = {presentation slides}, abstract = {Providing vectors of run-time determined length as opaque value types is a good interface between the machine-level SIMD instructions and portable application-oriented programming languages. Implementing vector operations requires a loop that breaks the vector into SIMD-register-sized chunks. A compiler can fuse the loops of several vector operations together. However, during normal compilation this is only easy if no other control structures are involved. This paper explores an alternative: collect a trace of vector operations at run-time (following the program control flow during this collecting step), and then perform the combined vector loop. This arrangement has a certain run-time overhead, but its implementation is simpler and can happen independently, in a library. Preliminary performance results indicate that the overhead makes this approach beneficial only for long vectors ($>1$KB). For shorter vectors, unfused loops should be used in a library setting. Fortunately, this choice can be made at run time, individually for each vector operation.} } @InProceedings{eaton18, author = {Phillip Eaton}, title = {Programming in {Forth} on the {Vectrex}}, crossref = {euroforth18}, pages = {56}, url = {http://www.euroforth.org/ef18/papers/eaton.pdf}, url-slides = {http://www.euroforth.org/ef18/papers/eaton-slides.pdf}, video = {https://wiki.forth-ev.de/doku.php/events:ef2018:vectrex}, OPTnote = {presentation slides} } @Misc{ef2018:redis, author = {Gerald Wodni}, title = {redis}, howpublished = {https://wiki.forth-ev.de/doku.php/events:ef2018:redis}, year = {2018}, note = {Video of otherwise unpublished talk at EuroForth 2018} } @Misc{ef2018:case, author = {Andrew Haley}, title = {Case}, howpublished = {https://wiki.forth-ev.de/doku.php/events:ef2018:case}, year = {2018}, note = {Video of otherwise unpublished talk at EuroForth 2018} } @Misc{ef2018:dirty-laundry, author = {Nick Nelson}, title = {Dirty Laundry}, howpublished = {https://wiki.forth-ev.de/doku.php/events:ef2018:dirty-laundry}, year = {2018}, note = {Video of otherwise unpublished talk at EuroForth 2018} } @Misc{ef2018:shor, author = {Bill Stoddart}, title = {Shor's Algorithm}, howpublished = {https://wiki.forth-ev.de/doku.php/events:ef2018:shor}, year = {2018}, note = {Video of otherwise unpublished talk at EuroForth 2018} } @Misc{ef2018:64bit, author = {Nick Nelson}, title = {64-Bit Issues}, howpublished = {https://wiki.forth-ev.de/doku.php/events:ef2018:64bit}, year = {2018}, note = {Video of otherwise unpublished talk at EuroForth 2018} } @Misc{ef2018:dual, author = {Stephen Pelc}, title = {Dual words}, howpublished = {https://wiki.forth-ev.de/doku.php/events:ef2018:dual}, year = {2018}, note = {Video of otherwise unpublished talk at EuroForth 2018} } @Misc{ef2018:chuck-speech, author = {Chuck Moore}, title = {50 Years of {Forth}}, howpublished = {https://wiki.forth-ev.de/doku.php/events:ef2018:chuck-speech}, year = {2018}, note = {Video of otherwise unpublished talk at EuroForth 2018} } @Misc{ef2018:style, author = {Andrew Read}, title = {Style Survey}, howpublished = {https://wiki.forth-ev.de/doku.php/events:ef2018:style}, year = {2018}, note = {Video of otherwise unpublished talk at EuroForth 2018} } @Misc{ef2018:forth-in-that, author = {Leon Wagner}, title = {There's {Forth} in That}, howpublished = {https://wiki.forth-ev.de/doku.php/events:ef2018:forth-in-that}, year = {2018}, note = {Video of otherwise unpublished talk at EuroForth 2018} } @Misc{ef2018:theforth, author = {Gerald Wodni}, title = {theForth.net}, howpublished = {https://wiki.forth-ev.de/doku.php/events:ef2018:theforth}, year = {2018}, note = {Video of otherwise unpublished talk at EuroForth 2018} } @Misc{ef2018:64bit2, author = {Ulrich Hoffmann}, title = {Detecting 64-Bit Systems}, howpublished = {https://wiki.forth-ev.de/doku.php/events:ef2018:64bit2}, year = {2018}, note = {Video of otherwise unpublished talk at EuroForth 2018} } @Proceedings{euroforth18, title = {34th EuroForth Conference}, booktitle = {34th EuroForth Conference}, year = {2018}, key = {EuroForth'18}, url = {http://www.complang.tuwien.ac.at/anton/euroforth/ef18/papers/proceedings.pdf} }