jst a blog

Working from the inside out:

not() is applying the unary not operator to an empty tuple, which is not(False), which returns True. This is something I don't think that I explicitly realized - but in Python, certain objects are "falsy", meaning they evaluate to the Boolean False, and an empty sequence or collection, such as empty tuple, is one of those falsy objects.

str() is converting True to the actual string of characters: "True"

min() is returning the character in "True" with the lowest unicode codepoint, which is "T" (84). So here it's useful that capital letters come before lowercase and thus have lower codepoint values.

ord() is returning the integer that represents "T", which is 84.

range() takes that integer and returns the sequence of integers from zero 0 to 84 as a tuple. This works because if you only give range() a single argument (the integer to stop at), it uses the defaults for start (0) and step (1).

sum() is adding up all of the items in that tuple (0+1+2+…83), resulting in 3486. In my opinion, sum(range(84)) is probably the cleverest bit because 3486 is (conveniently) a triangular number, such that it is the sum of the natural numbers 1 to 83.

GPT4 Prompt: Give me a 10-15 word sentence summarizing the compositions and subjects of La Città Nuova by Antonio Sant'Elia, followed by 10 to 15 short phrases, comma-separated, describing the style and aesthetics, then a list of the methods and materials used by the artist in creating the works. GTP4 Response: […] depicts innovative urban structures featuring interconnected, multi-level living spaces. Futuristic, dynamic, geometric, bold lines, vertical, industrial aesthetic, monumental, integrated infrastructure, elevated transportation, modern metropolis. Ink on paper, architectural drawings, perspective sketching. Midjourney Prompt: innovative urban structures featuring interconnected, multi-level living spaces. Futuristic, dynamic, geometric, bold lines, vertical, industrial aesthetic, monumental, integrated infrastructure, elevated transportation, modern metropolis. Sepia, ink on paper, architectural drawing, perspective sketch, white background --v 5

Midjourney gave these as the responses:

For comparison, here are two of Sant'Elia's drawings from La Città Nuova:

Time Generated

Including a timestamp of report generation is a very common approach and, depending on how often that report is generated or the content is updated, displaying just the date may be sufficient. This can be accomplished through the use of SSRS global parameter ExecutionTime. I almost always include this in the footer of the reports I design, typically in a smaller font so that it does not distract the user from the contents of the report.

Content Hash

When it comes to validating the contents of the report, the approach that I tend to use is to call SQL's HASHBYTES() function, passing it values from the report. While in many cases you may be able to pass the full contents of the report into the function, the input is limited to 8000 bytes so you may end up having to choose a subset of values. An added bonus of using a subset is that, as long as you do not indicate which values were used, it makes attempts to falsify a hash all that more difficult (not that this is a practical concern for most applications).

The output of the function is a value that is (in practice) unique to the input which allows for the verification of the contents of the report: the hash on a previously-generated copy could be used to very quickly determine if the contents of the copy had been modified externally after generation or if the values in the database had been changed since its generation.

As of SQL 2016, the weaker hash algorithms have been deprecated, leaving us with SHA2_256 and SHA2_512 both of which have output that is not human-readable and not suitable for displaying on a report. To address this, it's perfectly acceptable to truncate the hash to a more reasonable length for our purposes.

Implementation

Let’s say that we have a report that displays the contents of a single personnel record. The dataset query looks like this:

SELECT [Id],[FirstName],[LastName],[Username],[HireDate],[AccessLevel],[Notes]` FROM [Employees] WHERE [Id] = @userid

Now, let's say that our primary concern is the integrity of the [AccessLevel] and [Notes]. We'll include the following line in the SELECT statement to generate the hash using SHA256, convert it to varchar, and truncate it to the first sixteen characters:

LEFT(CONVERT(VARCHAR(64),HASHBYTES('SHA2_256',[AccessLevel]+[Notes]),2),16) AS [ReportHash]

The output could then be displayed in the footer of the report alongside the generation timestamp and would look something like this:

Device manager indicated that the keyboard device threw an error:

Windows cannot start this hardware device because its configuration information (in the Registry) is incomplete or damaged.

The issue is that the registry entry carries some deprecated values for things like Lenovo’s UltraNav and Synaptics devices. So we need to track it down and clean it up. Use RegEdit and navigate to the following key:

HKLM\SYSTEM\CurrentControlSet\Control\Class\{4d36e96b-e325-11ce-bfc1-08002be10318}

Edit UpperFilters so that the only entry in it is kbdclass.

A Tale of Two Addresses

Email relies on something called the Simple Mail Transfer Protocol (SMTP) which is a standard that allows any computer to transmit an email message to any other computer. SMTP uses two "from" addresses: the "envelope from" and the "header from".

The "envelope from" is hidden in the email header and tells the recipient's mail server where the email should be returned ("bounced") to - like the return address on the outside of a physical piece of mail. The "header from" address is what you see displayed in the "From:" field in your email client - like the header you might see on the letter that was mailed inside an envelope. These two addresses do not have to be the same.

Unfortunately, both of these addresses can be spoofed; a malicious third party can craft an email to a recipient that appears to have come from a legitimate sender. Sometimes it can be difficult for a recipient to determine if the email is legitimate. Together, the three authentication protocols allow the recipient's email server to make that determination and handle the email appropriately.

Sender Policy Framework (SPF)

SPF is a "path-based" protocolt that allows the recipient to verify that the email is indeed from the domain that it claims to be sent from. This is accomplished through the use of DNS records on the sender's domain that specify a whitelist of IP addresses that are allowed to send mail from that domain. If the email claims to have been sent by [email protected] but the email headers indicate that it was sent from a computer whose IP address does not appear on that whitelist, the recipient can treat the email accordingly. This check is performed before the recipient receives the contents of the email, allowing them to reject malicious emails without being exposed to anything that they might have contained. However, SPF only checks the "envelope from" address, meaning that the "header from" address can still be spoofed.

DomainKeys Indentified Mail (DKIM)

DKIM is an "identity-based" protocol and forms the second layer. This protocol is a little more complicated. It essentially allows a sender to electronically sign emails in a way that can be verified by the recipient. This is done through the use of an asymmetric cryptographic algorithm and a set of two keys, one of which is known only to the sender (the "private" key) and the other is provided in a DNS record for the recipient to use (the "public" key). The cryptographic process is outside the scope of this article, but it essentially takes the email (the header, the content, or both) and uses the private key to calculate a special value called a "hash" in such a way that there is no way to back-calculate the private key from the hash and the email contents. This hash is sent along with the email. The public key is the other half of this unique key pair which allows the recipient to verify that the email was indeed sent by someone who holds the private key.

Domain-based Message Authentication, Reporting, and Conformance (DMARC)

When enabled, SSRS opens a single connection, executes the datasets/queries that use the data source, and closes the connection. The queries are executed in order of appearance in the RDL file (same as in the design view), from top to bottom. This can be useful in certain situations:

The report datasets or queries contain things like UPDATE statements that make changes to the data being returned.

You want to reduce the amount of network traffic being generated.

The report contains a large number of queries that when executed in parallel have an adverse effect on performance.

There are licensing restrictions that limit the number of concurrent connections to the database

To create this type of IFTTT applet, start with the RSS Feed Service, then either “New Feed Item” or “New Feed Item Matches”. Give it the feed URL (and any other specifics if you’re going with the matching item version) and hit “Create Trigger”. Now, we have to tell IFTTT what to do when that thing triggers. Here, you can either use the standard IFTTT Email service or the Gmail service that uses your Gmail account to send the emails from your own account to yourself. That does require granting IFTTT permissions through linking your Google Account, however. Either way, the final step is configuring email filters or automatic labels.