user = User.new(password: "あ" * 25) # 25 characters, 75 bytes

Chunked encoding is useful when larger amounts of data are sent to the client and the total size of the response may not be known until the request has been fully processed. For example, when generating a large HTML table resulting from a database query or when transmitting large images.A chunked response looks like this:

And misunderstandings so easily occur here, when we're talking about encodings, but not those encodings, the other encoding, which is really charset. And it's especially hard because you can't visually tell the difference and in so many cases everything still works even though it is wrong.

The btoa() function takes a JavaScript string as a parameter. In JavaScript strings are represented using the UTF-16 character encoding: in this encoding, strings are represented as a sequence of 16-bit (2 byte) units. Every ASCII character fits into the first byte of one of these units, but many other characters don't. Base64, by design, expects binary data as its input. In terms of JavaScript strings, this means strings in which each character occupies only one byte. So if you pass a string into btoa() containing characters that occupy more than one byte, you will get an error, because this is not considered binary data:

If you need to encode Unicode text as ASCII using btoa(), one option is to convert the string such that each 16-bit unit occupies only one byte.

The character exists in Unicode/ISO 10646, but not in the character encoding used for the document. In this case, use Numeric Character References (NCRs, example: 噸).

If you're using JavaScript for writing to a HTML Attribute, look at the .setAttribute and [attribute] methods which will automatically HTML Attribute Encode. Those are Safe Sinks as long as the attribute name is hardcoded and innocuous, like id or class.

If you're using JavaScript for writing to HTML, look at the .textContent attribute as it is a Safe Sink and will automatically HTML Entity Encode.

A decision takes place when the encoding of a cognitive selection triggers, upondecoding, an occurrence of a difference that is, a state change within the system [11 ].

the brain stores social information differently thanit stores information that is non-social. Social memories are encoded in a distinctregion of the brain. What’s more, we remember social information moreaccurately, a phenomenon that psychologists call the “social encodingadvantage.” If findings like this feel unexpected, that’s because our culturelargely excludes social interaction from the realm of the intellect. Socialexchanges with others might be enjoyable or entertaining, this attitude holds, butthey’re no more than a diversion, what we do around the edges of school orwork. Serious thinking, real thinking, is done on one’s own, sequestered fromothers.

�Yes, but how will we ever keep track of such a large project?�

Vol. 29, No. 1, Winter/Spring 2018 (includes ΓÇ£Conferences,ΓÇ¥ ΓÇ£Symposium,ΓÇ¥ ΓÇ£Publishing items,ΓÇ¥ ΓÇ£Citations received;ΓÇ¥ memoriam for William Ittelson, written by John Hollander; book note of ΓÇ£An Anthropology of Landscape: The Ex-traordinary in the Ordinar;ΓÇ¥ book review by Thomas Barrie; essays by Barbara Erwine, Edward Relph, and Dennis Pohl; poems by Sheryl L. Nelms.)

As far as "Is there really no way to escape the < here?" there is a way... but you're not going to like it: %r<(?#{'<'}!foo)> == %r((?<!foo))

The use of U+212B 'Angstrom sign', which was encoded due to round-trip mapping compatibility with an East-Asian character encoding, is discouraged, and the preferred representation is U+00C5 'capital letter A with ring above', which has the same glyph.

The quirky looking printf is necessary to correctly expand the script's arguments in $@ while protecting possibly quoted parts of the command (see example below).

o put it in the language of psy­chology, there are limits on the number of distinct concepts which we can manipulate cognitively at any one time, and we. are therefore forced, if we wish to get a view of the whole problem, to re-encode these items.1

One does not have to escape ] outside of the character class.

If you needed a literal { character in your markup, you could always do {'{'}. (This is how it's done in React.) Or you could do &#123;, which is pleasingly easy to remember. Does there need to be some method of escaping beyond that?

By default all content inside template strings is escaped. This is great for strings, but not ideal if you want to insert HTML that's been returned from another function (for example: a markdown renderer). Use nanohtml/raw for to interpolate HTML directly.

Escaping is a subset of encoding: You only encode certain characters by prefixing a special character instead of transferring (typically all or many) characters to another representation.

Yet it can be deceivingly difficult to properly encode (user) input

When processing untrusted user input for (web) applications, filter the input, and encode the output.

Encoding is dependent on the type of output - which means that for example a string, which will be used in a JavaScript variable, should be treated (encoded) differently than a string which will be used in plain HTML.

Escaping is a subset of encoding, where not all characters need to be encoded. Only some characters are encoded (by using an escape character).

Encoding is transforming data from one format into another format.

what's the difference between escaping and encoding

Before MDX, some of the benefits of writing Markdown were lost when integrating with JSX. Implementations were often template string-based which required lots of escaping and cumbersome syntax.

Encoding API parameters of array and hash types

'

What we actually want to do is to escape content if it is unsafe, but leave it unescaped if it is safe. To achieve this we can simply use SafeBuffer's concatenation behavior:

Our helper still returns a safe string, but correctly escapes content if it is unsafe. Note how much more flexible our group helper has become because it now works as expected with both safe and unsafe arguments. We can now leave it up to the caller whether to mark input as safe or not, and we no longer need to make any assumptions about the safeness of content.

A common mistake is to see those escaped angle brackets, and "improve" the helper by making everything html_safe:

You don't "sanitize your output" you encode it for proper context within the application it is being presented. You encode the output for HTML, HTML Attribute, URL, JavaScript

When you output the data, you know the use case of the data. This knowledge allows you to safely sanitize the output data accordingly.

I would call this output encoding instead of sanitization

1- Validation: you “validate”, ie deem valid or invalid, data at input time. For instance if asked for a zipcode user enters “zzz43”, that’s invalid. At this point, you can reject or… sanitize. 2- sanitization: you make data “sane” before storing it. For instance if you want a zipcode, you can remove any character that’s not [0-9] 3- escaping: at output time, you ensure data printed will never corrupt display and/or be used in an evil way (escaping HTML etc…)

we want to code categorical variables into numbers, but we are concerned about this dimensionality problem

Formati aperti per i dati

How we insist that the hateful language they hear from public figures on TV does not represent the true spirit of this country.

h?Bb `mMbb?`THv +QmMi2` iQ i?2 T`2pBHBM; aBHB+QM oHH2v M``iBp2- r?B+? Bb 2bb2MiBHHvQM2 Q7i2+?MQHQ;B+H /2i2`KBMBbKĜ i?2 B/2 i?i i2+?MQHQ;v /`Bp2b ?BbiQ`vX