http://lambda-the-ultimate.org/taxonomy/term/1 2/0 Main Discussion Forum en http://lambda-the-ultimate.org/node/5706 <p >It might be because I'm posting from strange timezone (UTC+12hr, my evening is before dawn in UK/small hours in USA), but often when I try posting I get Server Error and even fail to get SQL connection. If I wait and retry, often I've ended up posting twice.</p> <p >Is there I time I should avoid posting?</p> Site Discussion Wed, 08 Apr 2026 22:52:02 +0000 http://lambda-the-ultimate.org/node/5700 <p >I am writing a book "Lambda the Ultimate Object". It's quite advanced at the moment, and already covers all the usual topics of OOP, though I'm still working on CLOS features that most other languages are lacking (I did method combinations, now working on multiple dispatch, then dynamic vs static dispatch, then the meta-object protocol). Feedback welcome.</p> <p ><a href="http://fare.tunes.org/files/cs/poof/ltuo.html">http://fare.tunes.org/files/cs/poof/ltuo.html</a></p> LtU Forum Fri, 06 Mar 2026 05:10:32 +0000 http://lambda-the-ultimate.org/node/5695 <p >I am writing a book "Lambda the Ultimate Object". It's quite advanced at the moment, and already covers all the usual topics of OOP, though I'm still working on CLOS features that most other languages are lacking (I did method combinations, now working on multiple dispatch, then dynamic vs static dispatch, then the meta-object protocol). Feedback welcome.</p> <p ><a href="http://fare.tunes.org/files/cs/poof/ltuo.html">http://fare.tunes.org/files/cs/poof/ltuo.html</a></p> LtU Forum Fri, 06 Mar 2026 05:10:31 +0000 http://lambda-the-ultimate.org/node/5696 <p >I am writing a book "Lambda the Ultimate Object". It's quite advanced at the moment, and already covers all the usual topics of OOP, though I'm still working on CLOS features that most other languages are lacking (I did method combinations, now working on multiple dispatch, then dynamic vs static dispatch, then the meta-object protocol). Feedback welcome.</p> <p ><a href="http://fare.tunes.org/files/cs/poof/ltuo.html">http://fare.tunes.org/files/cs/poof/ltuo.html</a></p> LtU Forum Fri, 06 Mar 2026 05:10:31 +0000 http://lambda-the-ultimate.org/node/5697 <p >I am writing a book "Lambda the Ultimate Object". It's quite advanced at the moment, and already covers all the usual topics of OOP, though I'm still working on CLOS features that most other languages are lacking (I did method combinations, now working on multiple dispatch, then dynamic vs static dispatch, then the meta-object protocol). Feedback welcome.</p> <p ><a href="http://fare.tunes.org/files/cs/poof/ltuo.html">http://fare.tunes.org/files/cs/poof/ltuo.html</a></p> LtU Forum Fri, 06 Mar 2026 05:10:31 +0000 http://lambda-the-ultimate.org/node/5698 <p >I am writing a book "Lambda the Ultimate Object". It's quite advanced at the moment, and already covers all the usual topics of OOP, though I'm still working on CLOS features that most other languages are lacking (I did method combinations, now working on multiple dispatch, then dynamic vs static dispatch, then the meta-object protocol). Feedback welcome.</p> <p ><a href="http://fare.tunes.org/files/cs/poof/ltuo.html">http://fare.tunes.org/files/cs/poof/ltuo.html</a></p> LtU Forum Fri, 06 Mar 2026 05:10:31 +0000 http://lambda-the-ultimate.org/node/5699 <p >I am writing a book "Lambda the Ultimate Object". It's quite advanced at the moment, and already covers all the usual topics of OOP, though I'm still working on CLOS features that most other languages are lacking (I did method combinations, now working on multiple dispatch, then dynamic vs static dispatch, then the meta-object protocol). Feedback welcome.</p> <p ><a href="http://fare.tunes.org/files/cs/poof/ltuo.html">http://fare.tunes.org/files/cs/poof/ltuo.html</a></p> LtU Forum Fri, 06 Mar 2026 05:10:31 +0000 http://lambda-the-ultimate.org/node/5694 <p >I am writing a book "Lambda the Ultimate Object". It's quite advanced at the moment, and already covers all the usual topics of OOP, though I'm still working on CLOS features that most other languages are lacking (I did method combinations, now working on multiple dispatch, then dynamic vs static dispatch, then the meta-object protocol). Feedback welcome.</p> <p ><a href="http://fare.tunes.org/files/cs/poof/ltuo.html">http://fare.tunes.org/files/cs/poof/ltuo.html</a></p> LtU Forum Fri, 06 Mar 2026 05:10:30 +0000 http://lambda-the-ultimate.org/node/5691 <p >I am writing a book "Lambda the Ultimate Object". It's quite advanced at the moment, and already covers all the usual topics of OOP, though I'm still working on CLOS features that most other languages are lacking (I did method combinations, now working on multiple dispatch, then dynamic vs static dispatch, then the meta-object protocol). Feedback welcome.</p> <p ><a href="http://fare.tunes.org/files/cs/poof/ltuo.html">http://fare.tunes.org/files/cs/poof/ltuo.html</a></p> LtU Forum Fri, 06 Mar 2026 05:10:03 +0000 http://lambda-the-ultimate.org/node/5690 <p >I invented a simple way to write lexers. I should probably write a formal paper about it but I have no academic institution nor business pushing me to, so I probably won't. It is data-directed, so it has flow-of-control far simpler than most lexers. It relies heavily on bitmask operations instead of control logic. </p> <p >The lexer uses a hash table. The table is keyed by an input character and optionally by the position in the token where the character is read. There is a 'base' entry for every character, automatically generated from the character properties and the lexical rules for simple nonfixed tokens like identifiers and numbers. There are additional entries for characters which can appear in fixed tokens, indexed by both the character and the positions in which it appears in fixed tokens. The data stored in the table is bitmasks. </p> <p >The number of bits in each bitmask in this system is one per token class you want to recognize. Most of these are fixed tokens such as keywords and operators. Some are nonfixed tokens such as identifiers, numbers, and the text of inline constants. Depending on the complexity of the nonfixed tokens some may need to be represented by more than one bit. For example if you have a "no tabs in indentation" rule you may have type-1 whitespace that consists of a newline followed by some number of spaces, and type-2 whitespace that may contain spaces and tabs but no newlines. The parser could then enforce the no-tabs-in-indentation rule by declaring an error if it finds any instances of type-1 immediately followed by type-2.</p> <p >Each fixed token corresponds to one bit on the bitmask. If the bit is on, then that keyword or syntax has not yet been ruled out as the value of the token being parsed. </p> <p >So the lexer works thus: </p> <pre > // PSEUDOCODE ONLY. THIS IS NOT EXPECTED TO COMPILE, THIS HAS NOT BEEN TESTED, AND IT HAS NOT EVEN BEEN FORMALLY VERIFIED. { for (index=0, workmask = oldmask = ALL_ONES; workmask != 0; index++) { input = readInput(); oldmask = workmask; workmask &amp;= table(input, index); } unread(input) // push excluded letter back into file cache, to be read as first character next time. repeat{ tokenidx = round(log2(oldmask)); // get the index of the highest bit set if ((tokenidx &lt; fixtokencount) || // if it's the bit of a nonfixed token return that (tokenlengths[tokenidx] == index return(tokenidx); // if it's the bit of a fixed token check to make sure length matches. oldmask -= 0x1&lt;&lt;tokenidx; // clear the bit. } until (oldmask == 0); // until we have returned or all remaining set bits have been checked. print ("This never happens."); // If we get here it's a bug, so report an error. } </pre><p > At the start of a new token, it sets its working bitmask to all ones. Then it iterates through the input. Each time it reads a character C at position P, it fetches bitmask(C,P) from the hash table and ANDs it with its working bitmask.</p> <p >So for example, we can set our working bitmask to ones, then process 'w', 'h', 'i' 'l', 'e', ' ', by masking it with table('w',0), table('h',1), table('i',2), table('l',3), and table('e',4). At this point the bit for the 'while' keyword is the only one still set. When we mask with table(' ',5) it goes dark. We check that the length of the token corresponding with that bit matches the number of tokens we've processed and output 'while'. </p> <p >(note: in this case the 'while' bit and the 'identifier' bit will both be set. After processing the table(' ',5) both will be unset, so both are candidates in the 'last nonzero mask' rule. But given a conflict between keyword and identifier, we will always pick the keyword.)</p> <p >The length check is to handle things like '-' and '--' and '-=' all being syntax. After masking with table('-',0) all three will still be set. Some letter in position '1' would mask all three at the same time. But only one of those three finalists has length equal to the number of characters processed. </p> <p >There is a 'base' bitmap for each character. These simply define a character's relationship to the non-fixed categories with properties such as whether it's a digit, hex digit, binary digit, possible identifier character, etc. These are auto-generated based on the character's properties, and ignore the fixed tokens completely. </p> <p >What I like about this method is the absolute simplicity. of setting it up. You simply iterate through your list of fixed tokens, doing very obvious things with each: </p> <pre > // PSEUDOCODE ONLY. THIS IS NOT EXPECTED TO COMPILE, THIS HAS NOT BEEN TESTED, AND IT HAS NOT EVEN BEEN FORMALLY VERIFIED. for (bitplace = fixtokencount; bitplace &gt;0; bitplace--){ // fixed-tokens have highest priority so they get highest bit positions bitval = 0x1 &lt;&lt; bitplace; // nonfixed tokens like identifiers and numbers will have low bit positions for (letters in fixtokenlist[bitplace] ) Tmask = table(letter,place) if it exists, table(letter,base) if it doesn't. // get existing or copy default bitmask for letter and place Tmask &amp;= ~bitval; // poke a hole at bitplace table(a,place) = Tmask. // store the changed mask back in the table } Lexerlengths[bitplace]=place; // store the length of the token in the lexer's length table. } </pre><p > And you are done with fixed tokens. The lexer will recognize all of them, won't hallucinate tokens that don't exist, will run reasonably efficiently, and most important, the source will explain very clearly exactly how and why. </p> <p >There is no "mysterious" or "difficult" or even "complicated" thing going on here. Deterministic finite-state Automata and Chomsky grammars and state machines are lovely, but the way this works is so brutally simple it should be clear to any student on the first day it's explained.</p> <p >Benefits: </p> <p >Stunning simplicity of implementation. Better scaling than state-machine or flow-of-control approaches. Takes advantage of bit operations to parallelize a lot of things that would otherwise require sequential or carefully state-dependent implementation. Likely to further parallelize more easily than existing approaches.</p> <p >Costs: </p> <p >One Hash table lookup per character read is definitely the most expensive thing I'm doing. Depending on the size of the code set in use and the size of the bitmap, the table can break L2 cache even on high-end desktop machines. A complex language having ~250 fixed tokens (using a 16-byte bitmap) and all ~169K unicode codepoints (excluding private use, excluding surrogates) would make the table about 2.6 megabytes plus overhead. Overhead is brutal for hash tables, so that's no smaller than 4.5 megabytes and means definitely a lot of L2 cache misses. An implementation excluding Chinese characters and using an 8-byte bitmask on the other hand could have a table under 0.5 megabytes plus overhead, which will fit handily into most L2 caches. </p> <p >I'm using a logarithm operation to get the highest bit set. On reflex this seemed wrong because "transcendental function are SLOOOWW!" However on reflection I realized I had learned that a very long time ago and it's no longer true. Logarithms are implemented directly in hardware on modern CPUs and take barely longer than a multiplication.</p> LtU Forum Wed, 24 Dec 2025 06:29:49 +0000 http://lambda-the-ultimate.org/node/5689 <p >We showed in a forthcoming paper (CSF'24) that a compiler can translate high-level sequential code into a distributed concurrent program that uses cryptography to achieve security. All source-level security properties are preserved -- robust hyperproperty preservation. This requires a new kind of compiler correctness proof based on the kind of simulation used in Universal Composability.<br > See <a href="https://www.cs.cornell.edu/andru/papers/viaduct-formal/">Acay, Gancher, Recto, Myers, "Secure Synthesis of Distributed Cryptographic Applications"</a>.</p> LtU Forum Thu, 25 Jan 2024 13:02:50 +0000 http://lambda-the-ultimate.org/node/5687 <p >Haxl allows for IO operations to be batched by having Applicative operators that result in a "slightly unlawful" Monad instance -- rather than strictly having <code >(&lt;*&gt;) = ap where ap f x = f &gt;&gt;= (&lt;$&gt; x)</code>, it's merely "morally equivalent," as it performs the IO operations in parallel rather than in serial as <code >ap</code> would do.</p> <p >I'm wondering if it's possible to implement something similar in a language that implements effects in terms of delimited continuations rather than in terms of monads. It seems a lot less obvious how to do so, at least; when evaluating the arguments of an applicative-shaped function call (pure function, effectful arguments), the effect handler must process them one by one, and can't introspect on the continuation to see what future effects might be performed.</p> <p >An unfortunate solution might be to have a domain-specific optimization pass, reliant on inlining and other optimizations, that notes an effect as having some "do these in parallel" operator and transforms a program that unconditionally performs multiple effects in sequence to a single effect that uses that operator. However, this is terribly unsatisfying, since it's a non-semantics-preserving optimization, rather than something that falls directly out of the user-written code.</p> LtU Forum Wed, 27 Dec 2023 00:22:23 +0000 http://lambda-the-ultimate.org/node/5686 <p >I implemented a language a while ago.</p> <p >Based on some feedback, I change it's syntax from concatenative:</p> <p ><a href="https://github.com/cicada-lang/inet-cute">https://github.com/cicada-lang/inet-cute</a></p> <p >- Stack-based like forth.<br > - Simple and shorter code.<br > - Easy to do refactoring.</p> <p >to applicative:</p> <p ><a href="https://github.com/cicada-lang/inet-js">https://github.com/cicada-lang/inet-js</a></p> <p >- JavaScript-like syntax.<br > - Using pattern matching to define interaction rule.<br > - Can use currying, because we have explicit parentheses.</p> <p >But I am still not sure which is better.</p> <p >What do you think?</p> LtU Forum Sun, 24 Sep 2023 03:47:55 +0000 http://lambda-the-ultimate.org/node/5683 <p >website: <a href="https://inet.run">https://inet.run</a></p> <p >code: <a href="https://github.com/cicada-lang/inet-js">https://github.com/cicada-lang/inet-js</a></p> LtU Forum Sat, 23 Sep 2023 19:37:31 +0000 http://lambda-the-ultimate.org/node/5681 <p >Hi There, <p >Perhaps someone here might be kind enough to check out a paper I have published at [1] and provide some feedback. <p >It is an analysis of the travelling salesman problem and the sorting problem, examining the topologies of their solution spaces. <p >1.- <a href="https://github.com/enriquepablo/article-tsp/blob/mirror/article.ipynb">https://github.com/enriquepablo/article-tsp/blob/mirror/article.ipynb</a> <p >Thank you. LtU Forum Tue, 05 Sep 2023 16:33:14 +0000