Ah, So you are asking whether I think this: {1:[1,2,3],'foo':'bar',3:{1:2,3:[1,2,3]}} is more readable than this: #(#Dictionary 1 #(#Array 1 2 3) 'foo' 'bar' 3 #(#Dictionary 1 2 3 #(#Array 1 2 3))) My answer is that I find the JSON style more readable. With JSON, I can look a sequence from the middle of the character sequence and recognize the syntactic elements: 'foo': bar', 3 as a key/value pair (foo/bar) and that 3 is probably a key ... while the following sequence is not recognizable as anything: 'foo' 'bar' 3 is it 3 elements in an array? is foo, bar or 3 a key? To get it right I have to count the key value pairs from the beginning of the dictionary, something that only a machine can do or a human presented with a small list of elements to look at. This readability is important when looking at larger structures that may span a screen full of items in a text editor. The {} delimiting a dictionary allows me to recognize the following sequence: 3]} as the end of an array and a dictionary whereas the following sequence could mean anything in the literal Smalltalk array world: 3)) I can use a text editor to find the terminator for a dictionary or an array. With a smalltalk literal array it isn't possible..again the human must resort to careful counting. I wouldn't think that I would need to point out that the #Dictionary and #Array also introduce quite a bit of visual noise... and the JSON sequence is about half as long as the literal array sequence and still quite readable... So, yes I find the JSON format more readable than Igor's suggested format. Dale ----- Original Message ----- | From: "Eliot Miranda" <eliot.miranda@gmail.com> | To: Pharo-project@lists.gforge.inria.fr | Sent: Friday, October 19, 2012 2:47:22 PM | Subject: Re: [Pharo-project] Yet another Notation format: Object literals | | | | | On Fri, Oct 19, 2012 at 2:42 PM, Dale Henrichs < dhenrich@vmware.com | > wrote: | | | Eliot, | | STON (and JSON IIRC) allows either $" or $' as string literal | delimiters, so I am not holding onto the $" as a key readability | component. | | For me: | | { 'category' : 'Topez-Client-Core'} | | is perfectly readable and could be accomplished with the JSON | reader/writer.... | | | | agreed, but you're not answering my question. Is Igor's any the less | readable? | | | | | Dale | ----- Original Message ----- | | | From: "Eliot Miranda" < eliot.miranda@gmail.com > | | To: Pharo-project@lists.gforge.inria.fr | | | | Sent: Friday, October 19, 2012 2:07:28 PM | | Subject: Re: [Pharo-project] Yet another Notation format: Object | | literals | | | | HI Dale, Hi Igor, | | | | | | On Fri, Oct 19, 2012 at 9:33 AM, Dale Henrichs < | | dhenrich@vmware.com | | > wrote: | | | | | | Igor, | | | | "you can do anything you like" ... you mean like choosing to use | | STON | | and not invent my own notation format? | | | | STON is a perfectly good notation format for Smalltalk... | | | | Methinks that with your recent suggestions are no longer using | | literal Smalltalk syntax which is fine, if we are not restricted to | | literal Smalltalk syntax, then the following should be a valid | | format: | | | | { | | "category" : "Topez-Client-Core", | | "classinstvars" : [ | | ], | | "classvars" : [ | | ], | | "commentStamp" : "", | | "instvars" : [ | | "project", | | "package", | | "currentClass", | | "classOrInstance", | | "category", | | "selector", | | "history", | | "currentWindowId", | | "windows", | | "namedWindows" ], | | "name" : "TZTopezStatus", | | "pools" : [ | | ], | | "super" : "Object", | | "type" : "normal" } | | | | which brings us back to were we started. | | | | | | | | Sorry to come late to the party and sorry to point out the obvious | | but the above is fine in Igor's scheme if one gives up double | | quotes | | (since these are comment characters). So the above, with single | | quotes replacing the double quotes, and #(...) replacing {...} is a | | valid Smalltalk literal. Is the latter any the less readable? I | | don't think so. Do you, Dale? (and sorry if the conversation has | | already moved on). | | | | | | | | | | Smalltalk does not have a literal syntax for dictionaries. While | | fabricating dictionaries from literal arrays is possible, the | | results are not very readable ... unless you start taking liberties | | with Smalltalk syntax... | | | | If you are no longer restricting yourself to Smalltalk syntax, then | | what's wrong with the STON notation above? | | | | | | Dale | | | | ----- Original Message ----- | | | From: "Igor Stasenko" < siguctua@gmail.com > | | | | | | | To: Pharo-project@lists.gforge.inria.fr | | | Sent: Friday, October 19, 2012 9:10:26 AM | | | Subject: Re: [Pharo-project] Yet another Notation format: Object | | | literals | | | | | | On 19 October 2012 16:55, Dale Henrichs < dhenrich@vmware.com > | | | wrote: | | | > Igor, | | | > | | | > I'm afraid that your notation is not very friendly to humans | | | > ... | | | > a | | | > computer can keep track of the key value pairs in the literal | | | > dictionary, but a human will fail very quickly... | | | > | | | > The appeal of JSON (and STON) is that the output is readable by | | | > mere mortals: | | | > | | | > (JavaScript Object Notation) is a lightweight | | | > data-interchange format. It is easy for humans to | | | > read and write. | | | > | | | > What we're missing from Smalltalk is a literal dictionary or | | | > literal map syntax ... without that I'm afraid that for human | | | > friendly, lightweight notations we have to step away from the | | | > Smalltalk syntax - STON does this very nicely BTW... | | | | | | no problem, Dale. | | | What symbol you want to have to separate keys from values? | | | is '->' ok? | | | | | | Dictionary>>asObjectLiteral | | | | | | "convert a receiver into an object literal " | | | | | | ^ Array streamContents: [:stream | | | | stream nextPut: self class name. | | | self keysAndValuesDo: [:key :value | | | | stream | | | nextPut: key asObjectLiteral; | | | nextPut: #->; | | | nextPut: value asObjectLiteral ] ] | | | | | | (Dictionary newFromPairs: #( a b c d)) asObjectLiteral | | | | | | #(#Dictionary | | | #a #'->' #b | | | #c #'->' #d) | | | | | | which if you pretty-print will look like: | | | | | | #( | | | Dictionary | | | a -> b | | | c -> d | | | ) | | | | | | is it better? | | | or you prefer this one: | | | | | | #( | | | Dictionary | | | (a -> b) | | | (c -> d) | | | ) | | | | | | you can do anything you like, by implementing the conversion | | | methods | | | in a way you like :) | | | | | | > | | | > Dale | | | > | | | > ----- Original Message ----- | | | > | From: "Igor Stasenko" < siguctua@gmail.com > | | | > | To: "Pharo Development" < Pharo-project@lists.gforge.inria.fr | | | > | > | | | > | Sent: Friday, October 19, 2012 4:09:22 AM | | | > | Subject: [Pharo-project] Yet another Notation format: Object | | | > | literals | | | > | | | | > | Hi, | | | > | as i promised before, here the simple smalltalk-based literal | | | > | format. | | | > | It based on smalltalk syntax, and so, unlike JSON, it doesn't | | | > | needs | | | > | to | | | > | have separate parser (a normal smalltalk parser used for | | | > | that). | | | > | | | | > | The idea is quite simple: | | | > | you can tell any object to represent itself as an 'object | | | > | literal' , | | | > | for example: | | | > | | | | > | (1@3) asObjectLiteral | | | > | --> #(#Point 1 3) | | | > | | | | > | { 1@2. 3@4. true. false . nil } asObjectLiteral | | | > | | | | > | -> #(#Array #(#Point 1 2) #(#Point 3 4) true false nil) | | | > | | | | > | (Dictionary newFromPairs: { 1->#(1 2 3) . 'foo' -> 'bar' }) | | | > | asObjectLiteral | | | > | -> | | | > | #(#Dictionary 1 #(#Array 1 2 3) 'foo' 'bar') | | | > | | | | > | Next thing, you can 'pretty-print' it (kinda): | | | > | | | | > | #(#Dictionary 1 #(#Array 1 2 3) 'foo' 'bar') | | | > | printObjectLiteral | | | > | | | | > | '#(#Dictionary | | | > | 1 | | | > | (#Array 1 2 3) | | | > | ''foo'' ''bar'')' | | | > | | | | > | | | | > | and sure thing, you can do reverse conversion: | | | > | | | | > | '#(#Dictionary | | | > | 1 | | | > | (#Array 1 2 3) | | | > | ''foo'' ''bar'')' parseAsObjectLiteral | | | > | | | | > | a Dictionary('foo'->'bar' 1->#(1 2 3) ) | | | > | | | | > | Initially, i thought that it could be generic (by | | | > | implementing | | | > | default | | | > | Object>>#asObjectLiteral), | | | > | but then after discussing it with others, we decided to leave | | | > | | | | > | Object>>#asObjectLiteral to be a subclass responsibility. | | | > | So, potentially the format allows to represent any object(s) | | | > | as | | | > | literals, except from circular referencing objects, of | | | > | course. | | | > | | | | > | The implementation is fairly simple, as you may guess and | | | > | contains no | | | > | new classes, but just extension methods here and there. | | | > | | | | > | Take it with grain and salt, since it is just a small proof | | | > | of | | | > | concept. (And if doing it for real it may need some changes | | | > | etc). | | | > | Since i am far from areas right now, where it can be used, i | | | > | don't | | | > | want to pursue it further or advocate if this is the right | | | > | way | | | > | to | | | > | do | | | > | things. | | | > | Neither i having a public repository for this project.. | | | > | | | | > | So, if there anyone who willing to pick it up and pursue the | | | > | idea | | | > | further, please feel free to do so and make a public | | | > | repository | | | > | for | | | > | project. | | | > | | | | > | | | | > | -- | | | > | Best regards, | | | > | Igor Stasenko. | | | > | | | | > | | | | | | | | | | | | -- | | | Best regards, | | | Igor Stasenko. | | | | | | | | | | | | | | | | | | -- | | best, | | Eliot | | | | | | | | -- | best, | Eliot |