guest271314 (2019-06-14T18:17:20.000Z)
guest271314 at gmail.com (2019-06-14T18:53:59.513Z)
Terms such as "more robust", "Less fragile." , "Less mess." are subjective. "Fragile" how? What is meant by "mess"? If the proposal is that ```nameof``` is briefer than using shorthand property names or computed property names to get an identifier as a string, then ```nameof``` would be less code. > You can rename field/property without fear you break something (using IDE refactoring tools). The use case appears to be within the context of an IDE? For users that roll their own code by hand at a simple text editor (GUI or CLI) and do not use an IDE for composing code (or relying on an IDE for logging errors), am not able to discern how ```nameof``` is different than using ```Object.getOwnPropertyDescriptors(other).name.value``` or ```Object.keys({userName})[0]```. The actual code will need to be tested in different browsers anyway before deployment to get the actual results. If a user has decided they _have to_ use some form of an "IDE" (which is ultimately an individual _choice_) to compose code and log errors - while they are writing the code - they can open DevTools at Chromium or Chrome then select ```Sources``` => ```Snippets``` => ```New snippet```, where ``` const n = 123; const n = 456; ``` will highlight the line where the error occurs - during writing the code - the as a red circle with a transparent "x" in the middle (the same circle with "x" will be shown on DevTools panel with ```1``` indicating ```1 error``` which can be clicked and will "navigate" DevTools to the line where the error occurs) and hovering over the red circle with the "x" in the middle will provide detail of the error message ```Uncaught SyntaxError: Identifier 'n' has already been declared``` To run the code press ```Ctrl+Enter```. -- > Case 2. Accessing property extended info e.g. > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, 'property1');``` > > vs > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, nameof object1.property1);``` > > 2nd variant (proposed) has more chances not to be broken during refactoring (robustness). Under what circumstances will the 1st example be "broken"? Again, the term "robustness" might be significant to some, though from perspective here has no clear meaning in code other than being an adjective describing the code. The human applies the descriptor to the code. Some other human has to concur with such a description in order for that term to have any relevance - to them individually. If the term is not adopted as meaningful within the scope of the code by the other human, the term can be omitted as irrelevant. Objectively the only observable traits of code are input and output (and time - if all tests are done at the same machine; or all hardware is listed at the various machines where code is tested as to time), which means that it should not matter _how_ (in code) output is derived as long as the output meets the requirement.
guest271314 at gmail.com (2019-06-14T18:42:52.745Z)
Terms such as "more robust", "Less fragile." , "Less mess." are subjective. "Fragile" how? What is meant by "mess"? If the proposal is that ```nameof``` is briefer than using shorthand property names or computed property names to get an identifier as a string, then ```nameof``` would be less code. > You can rename field/property without fear you break something (using IDE refactoring tools). The use case appears to be within the context of an IDE? For users that roll their own code by hand at a simple text editor (GUI or CLI) and do not use an IDE for composing code (or relying on an IDE for logging errors), am not able to discern how ```nameof``` is different than using ```Object.getOwnPropertyDescriptors(other).name.value``` or ```Object.keys({userName})[0]```. The actual code will need to be tested in different browsers anyway before deployment to get the actual results. If a user has decided they _have to_ use some form of an "IDE" (which is ultimately an individual _choice_) to compose code and log errors - while they are writing the code - they can open DevTools at Chromium or Chrome then select ```Sources``` => ```Snippets``` => ```New snippet```, where ``` const n = 123; const n = 456; ``` will highlight the line where the error occurs - during writing the code - the as a red circle with a transparent "x" in the middle (the same circle with "x" will be shown on DevTools panel with ```1``` indicating ```1 error``` which can be clicked and will "navigate" DevTools to the line where the error occurs) and hovering over the red circle with the "x" in the middle will provide detail of the error message ```Uncaught SyntaxError: Identifier 'n' has already been declared``` To run the code press ```Ctrl+Enter```. -- > Case 2. Accessing property extended info e.g. > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, 'property1');``` > > vs > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, nameof object1.property1);``` > > 2nd variant (proposed) has more chances not to be broken during refactoring (robustness). Under what circumstances will the 1st example be "broken"? Again, the term "robustness" might be significant to some, though from perspective here has no clear meaning in code other than being an adjective describing the code. The human applies the descriptor to the code. Some other human has to concur with such a description in order for that term to have any relevance - to them individually. If the term is not adopted as meaningful within the scope of the code by the other human, the term can be omitted as irrelevant. Objectively the only observable traits of code are input and output (and time - if all tests are done at the same machine; or all hardware is listed at the various machines where code is tested as to time).
guest271314 at gmail.com (2019-06-14T18:41:34.016Z)
Terms such as "more robust", "Less fragile." , "Less mess." are subjective. "Fragile" how? What is meant by "mess"? If the proposal is that ```nameof``` is briefer than using shorthand property names or computed property names to get an identifier as a string, then ```nameof``` would be less code. > You can rename field/property without fear you break something (using IDE refactoring tools). The use case appears to be within the context of an IDE? For users that roll their own code by hand at a simple text editor (GUI or CLI) and do not use an IDE for composing code (or relying on an IDE for logging errors), am not able to discern how ```nameof``` is different than using ```Object.getOwnPropertyDescriptors(other).name.value``` or ```Object.keys({userName})[0]```. The actual code will need to be tested in different browsers anyway before deployment to get the actual results. If a user has decided they _have to_ (which is ultimately an individual _choice_) use some form of an "IDE" to compose code and log errors - while they are writing the code - they can open DevTools at Chromium or Chrome then select ```Sources``` => ```Snippets``` => ```New snippet```, where ``` const n = 123; const n = 456; ``` will highlight the line where the error occurs - during writing the code - the as a red circle with a transparent "x" in the middle (the same circle with "x" will be shown on DevTools panel with ```1``` indicating ```1 error``` which can be clicked and will "navigate" DevTools to the line where the error occurs) and hovering over the red circle with the "x" in the middle will provide detail of the error message ```Uncaught SyntaxError: Identifier 'n' has already been declared``` To run the code press ```Ctrl+Enter```. -- > Case 2. Accessing property extended info e.g. > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, 'property1');``` > > vs > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, nameof object1.property1);``` > > 2nd variant (proposed) has more chances not to be broken during refactoring (robustness). Under what circumstances will the 1st example be "broken"? Again, the term "robustness" might be significant to some, though from perspective here has no clear meaning in code other than being an adjective describing the code. The human applies the descriptor to the code. Some other human has to concur with such a description in order for that term to have any relevance - to them individually. If the term is not adopted as meaningful within the scope of the code by the other human, the term can be omitted as irrelevant. Objectively the only observable traits of code are input and output (and time - if all tests are done at the same machine; or all hardware is listed at the various machines where code is tested as to time).
guest271314 at gmail.com (2019-06-14T18:40:35.373Z)
Terms such as "more robust", "Less fragile." , "Less mess." are subjective. "Fragile" how? What is meant by "mess"? If the proposal is that ```nameof``` is briefer than using shorthand property names or computed property names to get an identifier as a string, then ```nameof``` would be less code. > You can rename field/property without fear you break something (using IDE refactoring tools). The use case appears to be within the context of an IDE? For users that roll their own code by hand at a simple text editor (GUI or CLI) and do not use an IDE for composing code (or relying on an IDE for logging errors), am not able to discern how ```nameof``` is different than using ```Object.getOwnPropertyDescriptors(other).name.value``` or ```Object.keys({userName})[0]```. The actual code will need to be tested in different browsers anyway before deployment to get the actual results. If a user has decided they _have to_ (which is ultimately an individual _choice_) use some form of an "IDE" to compose code and log errors - while they are writing the code - they can open DevTools at Chromium or Chrome then select ```Sources``` => ```Snippets``` => ```New snippet```, where ``` const n = 123; const n = 456; ``` will highlight the line where the error occurs - during writing the code - the as a red circle with a transparent "x" in the middle (the same circle with "x" will be shown on DevTools panel with ```1``` indicating ```1 error``` which can be clicked and will "navigate" DevTools to the line where the error occurs) and hovering over the red circle with the "x" in the middle will provide detail of the error message ```Uncaught SyntaxError: Identifier 'n' has already been declared``` To run the code press ```Ctrl+Enter```. -- > Case 2. Accessing property extended info e.g. > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, 'property1');``` > > vs > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, nameof object1.property1);``` > 2nd variant (proposed) has more chances not to be broken during refactoring (robustness). Under what circumstances will the 1st example be "broken"? Again, the term "robustness" might be significant to some, though from perspective here has no clear meaning in code other than being an adjective describing the code. The human applies the descriptor to the code. Some other human has to concur with such a description in order for that term to have any relevance - to them individually. If the term is not adopted as meaningful within the scope of the code by the other human, the term can be omitted as irrelevant. Objectively the only observable traits of code are input and output (and time - if all tests are done at the same machine; or all hardware is listed at the various machines where code is tested as to time).
guest271314 at gmail.com (2019-06-14T18:39:17.561Z)
Terms such as "more robust", "Less fragile." , "Less mess." are subjective. "Fragile" how? What is meant by "mess"? If the proposal is that ```nameof``` is briefer than using shorthand property names or computed property names to get an identifier as a string, then ```nameof``` would be less code. > You can rename field/property without fear you break something (using IDE refactoring tools). The use case appears to be within the context of an IDE? For users that roll their own code by hand at a simple text editor (GUI or CLI) and do not use an IDE for composing code (or relying on an IDE for logging errors), am not able to discern how ```nameof``` is different than using ```Object.getOwnPropertyDescriptors(other).name.value``` or ```Object.keys({userName})[0]```. The actual code will need to be tested in different browsers anyway before deployment to get the actual results. If a user has decided they _have to_ (which is ultimately an individual _choice_) use some form of an "IDE" to compose code and log errors - while they are writing the code - they can open DevTools at Chromium or Chrome then select ```Sources``` => ```Snippets``` => ```New snippet```, where ``` const n = 123; const n = 456; ``` will highlight the line where the error occurs - during writing the code - the as a red circle with a transparent "x" in the middle (the same circle with "x" will be shown on DevTools panel with ```1``` indicating ```1 error``` which can be clicked and will "navigate" DevTools to the line where the error occurs) and hovering over the red circle with the "x" in the middle will provide detail of the error message ```Uncaught SyntaxError: Identifier 'n' has already been declared``` To run the code press ```Ctrl+Enter```. -- > Case 2. Accessing property extended info e.g. > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, 'property1');``` > > vs > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, nameof object1.property1);``` > 2nd variant (proposed) has more chances not to be broken during refactoring (robustness). Under what circumstances will the 1st example be "broken"? Again, the term "robustness" might be significant to some, though from perspective here has no clear meaning in code other than being an adjective. The human applies the descriptor to the code. Some other human has to concur with such a description in order for that term to have any relevance. If the term is not adopted as meaningful within the scope of the code by the other human, the term can be omitted as irrelevant. Objectively the only observable traits of code are input and output (and time - if all tests are done at the same machine; or all hardware is listed at the various machines where code is tested as to time).
guest271314 at gmail.com (2019-06-14T18:37:34.995Z)
Terms such as "more robust", "Less fragile." , "Less mess." are subjective. "Fragile" how? What is meant by "mess"? If the proposal is that ```nameof``` is briefer than using shorthand property names or computed property names to get an identifier as a string, then ```nameof``` would be less code. > You can rename field/property without fear you break something (using IDE refactoring tools). The use case appears to be within the context of an IDE? For users that roll their own code by hand at a simple text editor (GUI or CLI) and do not use an IDE for composing code (or relying on an IDE for logging errors), am not able to discern how ```nameof``` is different than using ```Object.getOwnPropertyDescriptors(other).name.value``` or ```Object.keys({userName})[0]```. The actual code will need to be tested in different browsers anyway before deployment to get the actual results. If a user has decided they _have_ (which is ultimately an individual _choice_) to use some form of an "IDE" to compose code and log errors - while they are writing the code - they can open DevTools at Chromium or Chrome then select ```Sources``` => ```Snippets``` => ```New snippet```, where ``` const n = 123; const n = 456; ``` will highlight the line where the error occurs - during writing the code - the as a red circle with a transparent "x" in the middle (the same circle with "x" will be shown on DevTools panel with ```1``` indicating ```1 error``` which can be clicked and will "navigate" DevTools to the line where the error occurs) and hovering over the red circle with the "x" in the middle will provide detail of the error message ```Uncaught SyntaxError: Identifier 'n' has already been declared``` To run the code press ```Ctrl+Enter```. -- > Case 2. Accessing property extended info e.g. > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, 'property1');``` > > vs > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, nameof object1.property1);``` > 2nd variant (proposed) has more chances not to be broken during refactoring (robustness). Under what circumstances will the 1st example be "broken"? Again, the term "robustness" might be significant to some, though from perspective here has no clear meaning in code other than being an adjective. The human applies the descriptor to the code. Some other human has to concur with such a description in order for that term to have any relevance. If the term is not adopted as meaningful within the scope of the code by the other human, the term can be omitted as irrelevant. Objectively the only observable traits of code are input and output (and time - if all tests are done at the same machine; or all hardware is listed at the various machines where code is tested as to time).
guest271314 at gmail.com (2019-06-14T18:36:51.519Z)
Terms such as "more robust", "Less fragile." , "Less mess." are subjective. "Fragile" how? What is meant by "mess"? If the proposal is that ```nameof``` is briefer than using shorthand property names or computed property names to get an identifier as a string, then ```nameof``` would be less code. > You can rename field/property without fear you break something (using IDE refactoring tools). The use case appears to be within the context of an IDE? For users that roll their own code by hand at a simple text editor (GUI or CLI) and do not use an IDE for composing code (or relying on an IDE for logging errors), am not able to discern how ```nameof``` is different than using ```Object.getOwnPropertyDescriptors(other).name.value``` or ```Object.keys({userName})[0]```. The actual code will need to be tested in different browsers anyway before deployment to get the actual results. If a user has decided they _have_ (which is ultimately an individual _choice_) to use some form of an "IDE" to compose code and log errors - while they are writing the code - they can open DevTools at Chromium or Chrome then select ```Sources``` => ```Snippets``` => ```New snippet```, where ``` const n = 123; const n = 456; ``` will highlight the line where the error occurs - during writing the code - the as a red circle with a transparent "x" in the middle (the same circle with "x" will be shown on DevTools panel with ```1``` indicating ```1 error``` which can be clicked and will "navigate" DevTools to the line where the error occurs) and hovering over the red circle with the "x" in the middle will provide detail of the error message ```Uncaught SyntaxError: Identifier 'n' has already been declared``` To run the code press ```Ctrl+Enter```. -- > Case 2. Accessing property extended info e.g. > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, 'property1');``` > > vs > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, nameof object1.property1);``` > 2nd variant (proposed) has more chances not to be broken during refactoring (robustness). Under what circumstances will the 1st example be "broken"? Again, the term "robustness" might be significant to some, though from perspective here has no clear meaning in code other than being an adjective. The human applies the descriptor to the code. Some other human has to concur with such a description in order for that term to have any relevance. If the term is not adopted as meaningful within the scope of the code, the term can be omitted as irrelevant. Objectively the only observable traits of code are input and output (and time - if all tests are done at the same machine; or all hardware is listed at the various machines where code is tested as to time).
guest271314 at gmail.com (2019-06-14T18:33:25.630Z)
Terms such as "more robust", "Less fragile." , "Less mess." are subjective. "Fragile" how? What is meant by "mess"? If the proposal is that ```nameof``` is briefer than using shorthand property names or computed property names to get an identifier as a string, then ```nameof``` would be less code. > You can rename field/property without fear you break something (using IDE refactoring tools). The use case appears to be within the context of an IDE? For users that roll their own code by hand at a simple text editor (GUI or CLI) and do not use an IDE for composing code (or relying on an IDE for logging errors), am not able to discern how ```nameof``` is different than using ```Object.getOwnPropertyDescriptors(other).name.value``` or ```Object.keys({userName})[0]```. The actual code will need to be tested in different browsers anyway before deployment to get the actual results. If a user has decided they _have_ (which is ultimately an individual _choice_) to use some form of an "IDE" to compose code and log errors - while they are writing the code - they can open DevTools at Chromium or Chrome then select ```Sources``` => ```Snippets``` => ```New snippet```, where ``` const n = 123; const n = 456; ``` will highlight the line where the error occurs - during writing the code - the as a red circle with a transparent "x" in the middle and hovering over the red circle with the "x" in the middle will provide detail of the error message ```Uncaught SyntaxError: Identifier 'n' has already been declared``` To run the code press ```Ctrl+Enter```. -- > Case 2. Accessing property extended info e.g. > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, 'property1');``` > > vs > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, nameof object1.property1);``` > 2nd variant (proposed) has more chances not to be broken during refactoring (robustness). Under what circumstances will the 1st example be "broken"? Again, the term "robustness" might be significant to some, though from perspective here has no clear meaning in code other than being an adjective. The human applies the descriptor to the code. Some other human has to concur with such a description in order for that term to have any relevance. If the term is not adopted as meaningful within the scope of the code, the term can be omitted as irrelevant. Objectively the only observable traits of code are input and output (and time - if all tests are done at the same machine; or all hardware is listed at the various machines where code is tested as to time).
guest271314 at gmail.com (2019-06-14T18:32:09.299Z)
Terms such as "more robust", "Less fragile." , "Less mess." are subjective. "Fragile" how? What is meant by "mess"? If the proposal is that ```nameof``` is briefer than using shorthand property names or computed property names to get an identifier as a string, then ```nameof``` would be less code. > You can rename field/property without fear you break something (using IDE refactoring tools). The use case appears to be within the context of an IDE? For users that roll their own code by hand at a simple text editor (GUI or CLI) and do not use an IDE for composing code (or relying on an IDE for logging errors), am not able to discern how ```nameof``` is different than using ```Object.getOwnPropertyDescriptors(other).name.value``` or ```Object.keys({userName})[0]```. The actual code will need to be tested in different browsers anyway before deployment to get the actual results. If a user has decided they _have_ to use some form of an "IDE" to compose code and log errors - while they are writing the code - they can open DevTools at Chromium or Chrome then select ```Sources``` => ```Snippets``` => ```New snippet```, where ``` const n = 123; const n = 456; ``` will highlight the line where the error occurs - during writing the code - the as a red circle with a transparent "x" in the middle and hovering over the red circle with the "x" in the middle will provide detail of the error message ```Uncaught SyntaxError: Identifier 'n' has already been declared``` To run the code press ```Ctrl+Enter```. -- > Case 2. Accessing property extended info e.g. > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, 'property1');``` > > vs > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, nameof object1.property1);``` > 2nd variant (proposed) has more chances not to be broken during refactoring (robustness). Under what circumstances will the 1st example be "broken"? Again, the term "robustness" might be significant to some, though from perspective here has no clear meaning in code other than being an adjective. The human applies the descriptor to the code. Some other human has to concur with such a description in order for that term to have any relevance. If the term is not adopted as meaningful within the scope of the code, the term can be omitted as irrelevant. Objectively the only observable traits of code are input and output (and time - if all tests are done at the same machine; or all hardware is listed at the various machines where code is tested as to time).
guest271314 at gmail.com (2019-06-14T18:30:34.689Z)
Terms such as "more robust", "Less fragile." , "Less mess." are subjective. "Fragile" how? What is meant by "mess"? If the proposal is that ```nameof``` is briefer than using shorthand property names or computed property names to get an identifier as a string, then ```nameof``` would be less code. > You can rename field/property without fear you break something (using IDE refactoring tools). The use case appears to be within the context of an IDE? For users that roll their own code by hand at a simple text editor (GUI or CLI) and do not use an IDE for composing code (or relying on an IDE for logging errors), am not able to discern how ```nameof``` is different than using ```Object.getOwnPropertyDescriptors(other).name.value``` or ```Object.keys({userName})[0]```. The actual code will need to be tested in different browsers anyway before deployment to get the actual results. If a user has decided they _have_ to use some form of an "IDE" to compose code and log errors - while they are writing the code - they can open DevTools at Chromium or Chrome then select ```Sources``` => ```Snippets``` => ```New snippet```, where ``` const n = 123; const n = 456; ``` will highlight the line where the error occurs - during writing the code - the as a red circle with a transparent "x" in the middle and hovering over the red circle with the "x" in the middle will provide detail of the error message ```Uncaught SyntaxError: Identifier 'n' has already been declared``` To run the code press ```Ctrl+Enter```. -- > Case 2. Accessing property extended info e.g. > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, 'property1');``` > > vs > > ```const descriptor1 = Object.getOwnPropertyDescriptor(object1, nameof object1.property1);``` > 2nd variant (proposed) has more chances not to be broken during refactoring (robustness). Under what circumstances will the 1st example be "broken"? Again, the term "robustness" might be significant to some, though from perspective here has no clear meaning in code other than being an adjective. The human applies the descriptor to the code. Objectively the only observable traits of code are input and output (and time - if all tests are done at the same machine; or all hardware is listed at the various machines where code is tested as to time).
guest271314 at gmail.com (2019-06-14T18:24:11.400Z)
Terms such as "more robust", "Less fragile." , "Less mess." are subjective. "Fragile" how? What is meant by "mess"? If the proposal is that ```nameof``` is briefer than using shorthand property names or computed property names to get an identifier as a string, then ```nameof``` would be less code. > You can rename field/property without fear you break something (using IDE refactoring tools). The use case appears to be within the context of an IDE? For users that roll their own code by hand at a simple text editor (GUI or CLI) and do not use an IDE for composing code (or relying on an IDE for logging errors), am not able to discern how ```nameof``` is different than using ```Object.getOwnPropertyDescriptors(other).name.value``` or ```Object.keys({userName})[0]```. The actual code will need to be tested in different browsers anyway before deployment to get the actual results. If a user has decided they _have_ to use some form of an "IDE" to compose code and log errors - while they are writing the code - they can open DevTools at Chromium or Chrome then select ```Sources``` => ```Snippets``` => ```New snippet```, where ``` const n = 123; const n = 456; ``` will highlight the line where the error occurs - during writing the code - the as a red circle with a transparent "x" in the middle and hovering over the red circle with the "x" in the middle will provide detail of the error message ```Uncaught SyntaxError: Identifier 'n' has already been declared``` To run the code press ```Ctrl+Enter```.
guest271314 at gmail.com (2019-06-14T18:23:40.392Z)
Terms such as "more robust", "Less fragile." , "Less mess." are subjective. "Fragile" how? What is meant by "mess"? If the proposal is that ```nameof``` is briefer than using shorthand property names or computed property names to get an identifier as a string, then ```nameof``` would be less code. > You can rename field/property without fear you break something (using IDE refactoring tools). The use case appears to be within the context of an IDE? For users that roll their own code by hand at a text editor and do not use an IDE for composing code (or relying on an IDE for logging errors), am not able to discern how ```nameof``` is different than using ```Object.getOwnPropertyDescriptors(other).name.value``` or ```Object.keys({userName})[0]```. The actual code will need to be tested in different browsers anyway before deployment to get the actual results. If a user has decided they _have_ to use some form of an "IDE" to compose code and log errors - while they are writing the code - they can open DevTools at Chromium or Chrome then select ```Sources``` => ```Snippets``` => ```New snippet```, where ``` const n = 123; const n = 456; ``` will highlight the line where the error occurs - during writing the code - the as a red circle with a transparent "x" in the middle and hovering over the red circle with the "x" in the middle will provide detail of the error message ```Uncaught SyntaxError: Identifier 'n' has already been declared``` To run the code press ```Ctrl+Enter```.
guest271314 at gmail.com (2019-06-14T18:22:13.521Z)
Terms such as "more robust", "Less fragile." , "Less mess." are subjective. "Fragile" how? What is meant by "mess"? If the proposal is that ```nameof``` is briefer than using shorthand property names or computed property names to get an identifier as a string, then ```nameof``` would be less code. > You can rename field/property without fear you break something (using IDE refactoring tools). The use case appears to be within the context of an IDE? For users that roll their own code by hand at a text editor and do not use an IDE for composing code (or relying on an IDE for logging errors), am not able to discern how ```nameof``` is different than using ```Object.getOwnPropertyDescriptors(other).name.value``` or ```Object.keys({userName})[0]```. The actual code will need to be tested in different browsers anyway before deployment to get the actual results. If a user has decided they _have_ to use some form of an "IDE" to compose code and log errors - while they are writing the code - they can open DevTools at Chromium or Chrome then select ```Sources``` => ```Snippets``` => ```New snippet```, where ``` const n = 123; const n = 456; ``` will highlight the line where the error occurs - during writing the code - the as a red circle with a transparent "x" in the middle and hovering over the highlighted line will provide detail of the error message ```Uncaught SyntaxError: Identifier 'n' has already been declared``` To run the code press ```Ctrl+Enter```.
guest271314 at gmail.com (2019-06-14T18:21:05.213Z)
Terms such as "more robust", "Less fragile." , "Less mess." are subjective. "Fragile" how? What is meant by "mess"? If the proposal is that ```nameof``` is briefer than using shorthand property names or computed property names to get an identifier as a string, then ```nameof``` would be less code. > You can rename field/property without fear you break something (using IDE refactoring tools). The use case appears to be within the context of an IDE? For users that roll their own code by hand at a text editor and do not use an IDE for composing code (or relying on an IDE for logging errors), am not able to discern how ```nameof``` is different than using ```Object.getOwnPropertyDescriptors(other).name.value``` or ```Object.keys({userName})[0]```. The actual code will need to be tested in different browsers anyway before deployment to get the actual results. If a user has decided they _have_ to use some form of an "IDE" to compose code and log errors - while they are writing the code - they can open DevTools at Chromium or Chrome then select ```Sources``` => ```Snippets``` => ```New snippet```, where ``` const n = 123; const n = 456; ``` will highlight the line where the error occurs - during writing the code - the as a red circle with a transparent "x" in the middle ```Uncaught SyntaxError: Identifier 'n' has already been declared``` To run the code press ```Ctrl+Enter```.
guest271314 at gmail.com (2019-06-14T18:20:13.713Z)
Terms such as "more robust", "Less fragile." , "Less mess." are subjective. "Fragile" how? What is meant by "mess"? If the proposal is that ```nameof``` is briefer than using shorthand property names or computed property names to get an identifier as a string, then ```nameof``` would be less code. > You can rename field/property without fear you break something (using IDE refactoring tools). The use case appears to be within the context of an IDE? For users that roll their own code by hand at a text editor and do not use an IDE for composing code (or relying on an IDE for logging errors), am not able to discern how ```nameof``` is different than using ```Object.getOwnPropertyDescriptors(other).name.value``` or ```Object.keys({userName})[0]```. The actual code will need to be tested in different browsers anyway before deployment to get the actual results. If a user has decided they _have_ to use some form of a dynamic "IDE" to compose code and log errors - while they are writing the code, they can open DevTools at Chromium or Chrome then select ```Sources``` => ```Snippets``` => ```New snippet```, where ``` const n = 123; const n = 456; ``` will highlight the line where the error occurs - during writing the code - the as a red circle with a transparent "x" in the middle ```Uncaught SyntaxError: Identifier 'n' has already been declared``` To run the code press ```Ctrl+Enter```.
guest271314 at gmail.com (2019-06-14T18:19:19.638Z)
Terms such as "more robust", "Less fragile." , "Less mess." are subjective. "Fragile" how? What is meant by "mess"? If the proposal is that ```nameof``` is briefer than using shorthand property names or computed property names to get an identifier as a string, then ```nameof``` would be less code. > You can rename field/property without fear you break something (using IDE refactoring tools). The use case appears to be within the context of an IDE? For users that roll their own code by hand at a text editor and do not use an IDE for composing code (or relying on an IDE for logging errors), am not able to discern how ```nameof``` is different than using ```Object.getOwnPropertyDescriptors(other).name.value``` or ```Object.keys({userName})[0]```. The actual code will need to be tested in different browsers anyway before deployment to get the actual results. If a user has decided they _have_ to use some form of a dynamic "IDE" to compose code and log errors - while they are writing the code, they can open DevTools at Chromium or Chrome then select ```Sources``` => ```Snippets``` => ```New snippet```, where ``` const n = 123; const n = 456; ``` will highlight the line where the error occurs - during writing the code - the as a red circle with a transparent "x" in the middle ```Uncaught SyntaxError: Identifier 'n' has already been declared```` To run the code press ```ctrl+enter```.