Fizzbuzz and complex filtering

#43

With the sources, and variation in the use of Quine often trivially I wonder if we would be better coining a new term perhaps the "ruston " @jeremyruston

The name “quine” was coined by Douglas Hofstadter, in his popular science book Gödel, Escher, Bach: An Eternal Golden Braid, in the honor of philosopher Willard Van Orman Quine, who made an extensive study of indirect self-reference

  • Which I have somewhere having read it a long time ago.

I also read;

It’s relatively easy to write quines in other languages such as Postscript which readily handle programs as data

From this idea we may extract a definition of the “Ruston” from the general and unique properties of tiddlywiki appropriately generalised.

I am working on the definition of a “Ruston”, which is in fact so broad in its possibilities and extent it may take a little time to do this concisely.

1 Like
#44

Nice, Tones!

Just riffing here…

Really
Useful
Software
To
Organise
Notes

The whole “language” (wikitext, filter notation) should be called Jermolene (all the cool languages begin with “J”) and tiddlers are Jerms :nerd_face:

3 Likes
Let's brainstorm a name for the next version of TiddlyWiki
Let's brainstorm a name for the next version of TiddlyWiki
#45

“Every time you get a germ of an idea, create a Jerm !”

#46

I wonder if this could be even more general, because you can organise anything, not just notes?

Nodes?

See Words that start with n | n words | Words starting with n

Now?

excetera?

I like Now its immediate and unlimited.

#47

Notes: Broad audience appeal

Nodes: appeals to a much narrower audience

Now: too vague

#48

And you know how sometimes folks document tiddlers like…

{
  title: My title
  tags: foo bar
  text: This is my content.
}

Well, that’s called JON – Jermolene Object Notation

“Oh, the fun they had.”

:nerd_face:

Let's brainstorm a name for the next version of TiddlyWiki
#49

Ciao @pmario

Nice, detailed factual reply! I like how you take time to move towards the objective in an objective (factually accurate) way.

My comment … TBH, I actually think that terms outside computer science actually also convey what a Quine is well, if not better than it. A Quine is Reflexive; likely best laid-out by French sociologist Pierre Bourdieu in Key Concepts .

I think there are “mind-blow” conceptual issues in the implications of “self-sustaining-self-modification” that can’t be easily reduced to determinate outcomes.

TBH I think the base architecture of TW is quite unusual. It is unusually open for any end-user software.

Just a comment
TT

#50

The “Ruston” …

Lol! Superb! It is a shame @jeremyruston didn’t have a marketing department with you in it at launch time! :smiley:

I think there is merit in advancing / promoting Quineology. But likely best handled by a Marketing Department?

A comment
TT

#51

For ruston, Organize is a bit reductionist. Operate is more open and truer to the possibilities. Why not Operate Necessities?

By Necessities, I mean the stuff that I have to handle and that I know I can do with TW.

It could also be Operate Novelties.

The point is, however, that the first R should mean Ruston because it ought to be a recursive acronym to be really cool!

Would Ruston Uses Software To Operate Needs do it?

1 Like
#52

@pmario I am greatly surprised indeed, and I do very much appreciate such a worthy post to explains all those complex things.

#53

Ciao @TW_Tones

Believe it or not I’m still thinking about how to convey the magic of Quines and thereby TW.

I suddenly realised that philosophy I have been involved with has a good description …

"A Quine in an 'instance of itself ' (iofi)"


IOFI’s share with human consciousness their Reflexive and Re-Entrant nature.

I doubt many will understand what I’m talking about, but the fundamental self-modifying Recursion in TW is both fascinating and profound.

Just a comment
TT

#54

@TiddlyTweeter You said “A Quine in an 'instance of itself ’ (iofi)” but would it not be rather “A Quine iS an 'instance of itself ’ (iofi)” or does my question just shows I am dumb enough around this notion?

One last question: is tw server a quine? it doesn’t write itself, it write files and it can generate a quine, but this quine is not itself. And the big question is how different are the codes of the quine and that of the server? Maybe I’m also wrong there and the server is the same as the quine and that would really really beg my disbelief!

#55

@jypre without a server TiddlyWiki makes use of the browser and the relevant saver to commit changes to file, updates to itself, or copies of itself.

In my view all that the server does is extract this saving layer and serve it. Especially from the user perspective. As soon as we have a layer of course we can fiddle with that layer in such a way that fundamentally changes the structure, but it is to me still a quine from the user perspective, it’s just that it is running in an alternate “platform” in an alternate “ecosystem”, just as even “trivial quines” in any language, still must run on top of an interpreter, or compiled to run on an Operating system.

#56

@TW_Tones Your point of view is an interesting manifesto of perspective matters. Once again, I would not have thought likewise but now, I agree with you that it’s not so much different. And I’m glad that they are different :wink:

1 Like
#57

I’ve done a fizzbuzz without macro thanks to the new function pragmas!

\function .fizz(n) [<n>remainder[3]match[0]then[fizz]else<n>]
\function .buzz(n) [<n>remainder[5]match[0]then[buzz]else<n>]
\function .fizzbuzz(n) [.fizz<n>] [.buzz<n>] +[!match<n>join[]else<n>]

* fizz {{{ [range[17]] :map[.fizz<currentTiddler>] +[dump[fizz]join[ ]] }}}
* buzz {{{ [range[17]] :map[.buzz<currentTiddler>] +[dump[buzz]join[ ]] }}}
* fizzbuzz {{{ [range[17]] :map[.fizzbuzz<currentTiddler>] +[dump[fizzbuzz]join[ ]] }}}

if I only wanted fizzbuzz and not use neither fizz nor buzz out of fizzbuzz, I could have it in less code:

\function .fizz(n) [<n>remainder[3]match[0]then[fizz]]
\function .buzz(n) [<n>remainder[5]match[0]then[buzz]]
\function .fizzbuzz(n) [.fizz<n>] [.buzz<n>] +[join[]else<n>]

* fizzbuzz {{{ [range[17]] :map[.fizzbuzz<currentTiddler>] +[dump[fizzbuzz]join[ ]] }}}

But then fizz and buzz still exists in the wild. It would be nice if we could restrict them to fizzbuzz. For instance, if the code below was OK.

\function .fizzbuzz(n)
\function .fizz(n) [<n>remainder[5]match[0]then[fizz]]
\function .buzz(n) [<n>remainder[5]match[0]then[buzz]]
[.fizz<n>] [.buzz<n>] +[join[]else<n>]
\end

We could do it with an import pragma like we can have for macro definition. Currently, \import do not cater for function definition. IMHO, it should.

in “fizzbuzz.private” tiddler:

\function .fizz(n) [<n>remainder[3]match[0]then[fizz]]
\function .buzz(n) [<n>remainder[5]match[0]then[buzz]]

and in “fizzbuzz.public” tiddler:

\import [[fizzbuzz.private]]
\function .fizzbuzz(n) [.fizz<n>] [.buzz<n>] +[join[]else<n>]
#58

Could you check that again? Function definitions can be imported in the usual way.

#59

Sorry @jeremyruston you’re right. I had misspelled something that broke the process.

But this is not as simple as that.

First, I see that I can \import after \function. Even though the \define use what is imported, all is functioning.

But now, I add a third tiddler.

This one \import the tiddler that imported the core functions. And if the intermediate \import precedes the \function, then the outer tiddler is able to call the imported function, but there is no importing of the core function there. This render the whole import process unfit to hide implementation details. And if in the middle tiddler, the \function precedes the \import then the outer tiddler can’t call the function that the middle tiddler define.

here are the tiddlers to avoid being confused.

  • core tiddler
\function .fizz0(n) [<n>remainder[3]match[0]then[fizz]]
\function .buzz0(n) [<n>remainder[5]match[0]then[buzz]]
  • middle tiddler
\import [[core]]
\function .fizzbuzz(n) [.fizz0<n>] [.buzz0<n>] +[join[]else<n>]

* fizzbuzz {{{ [range[17]] :map[.fizzbuzz<currentTiddler>] +[dump[fizzbuzz]join[ ]] }}}
  • outer tiddler
\import [[middle]]
{{{ [range[17]] :map[.fizzbuzz<currentTiddler>] +[dump[fizzbuzz]join[ ]] }}}
#60

Hi @jypre – the behaviour you’re seeing is not restricted to functions, it’s a general limitation of the “import” pragma/widget that it does not process nested imports. It would obviously be useful to be able to do so but there are some implementation wrinkles that prompted us to postpone that functionality.

#61

Thank you @jeremyruston for these clear explanations that must be taken into consideration when coding.

#62

In this example I import the myfunctions inside a procedure, and they become available to the procedure;

“import functions” contains

\procedure fizzbuzz(n) 
\import [[myfunctions]]
# <<test hi>>
# <$transclude $variable=test n=<<n>>/>
\end fizzbuzz

<<fizzbuzz 4>>

myfunctions contains

\function test(n) [<n>addprefix[item-]]

Note

  • Although import may not import nested procedures and functions, it accepts a filter which can itself import multiple tiddlers containing definitions
  • However is the following not actualy doing this?

Further given the above;
Reimport contains

\import [[import functions]]

<<fizzbuzz 4>>
  • This works as follows
    • Reimport imports [[import functions]]
    • <<fizzbuzz 4>> works
      • The procedure fizzbuzz is defined in [[import functions]]
      • Inside procedure fizzbuzz we import [[myfunctions]]
      • [[myfunctions]] contains the definition of the test function
1 Like