One of the basic tasks Integration Engineers do is to compare files that we use or receive.  There are some interesting and useful tools that people can get out there to DIFF files.  But on Linux and Unix machines around the world there is a native tool that is almost always present.  Amazingly it is called DIFF.

Like some other command-line tools, its interface is not really intuitive.  Lets walk through the basics of how to get use out of this handy file comparing tool.  (If you are working with and comparing EDI files, you might want to look at the post on how to unwrap your EDI file so that our line by line comparison is more meaningful.)

How to used “diff”

You can get the real basics by executing “diff –help” to get the basic help and options for this application.  But in short, here is the thumb nail. “diff” is followed by some options.  Options are designated by a “-” and then a letter indicating the option.  Any options are then followed by the two file names that are being compared.  Lets look at an example.

Example:

We have two files, file1.txt and file2.txt

When we issue this command:  “diff file1.txt file2.txt” we get this result.

2c2
< And this is the first line of the first file.
—
> And this is the first line of the second file.
3a4
> Again.

• The first thing we see is “2c2″  This is line 2 of the first file, compared or changed to line 2 of second file.
• Next we have a < indicating the first file, and the line echoed.
• Following this we have a “—” as a separator between the line compared.
• Next we have > indicating the second file, and then that line is echoed.
• This is a comparison between to lines that were found to be different.
• For the next line that is shown, we have “3a4″ that indicates that there is a line added to the file.
• Finally, > indicates the second file followed by the line being echoed.

If we were to compare them in the other order, we end with these two lines:

4d3
< Again.

• Here, “4d3″ that the 4th line on the first file is deleted from the second file.
• Following this is < indicating the first file, and echoing the line.

Regular Options

Here are the list of options that “–help” gives you, with maybe some more explanation.

diff [-b] [-i] [-t] [-w] [-c] [-C] [-e] [-f] [-h] [-n] [-D string] [-l] [-r] [-s] [-S name] [fileone filetwo ] [directoryone directorytwo]

For comparing file, the first four options (-b, -i, -t, -w) are the most useful.  I don’t start with any options and add them as I need them to reduce the amount of change noise reported in the result set.

diff is your friend

Like many basic tools, “diff” is almost always there. And if you know how to use it effectively, it can really save time and frustration. Sure there are other cool file comparison tools. Some are even embedded into other products. But knowing how to use the basic tools that are always there will be a life saver in a crisis situation. And the only way to know how to use them is to actually use them sometimes.

Do you use “diff” with a set of options that does a specific task for you? If so, what are they, please share. And what other basic tools do you use?

Take a look at this and tell me what you think.

There are two options with different benefits that I have used.  One is to build a actual file format that holds your canonical data.  Another is to use a database to act as your canonical.  Both of these have trade offs.

File based Canonical:

To make a canonical file format you will need to pick the type of file that you want all of your applications to be receiving either directly or through an adapter of some kind.  Building from scratch a flat file or XML file is the most flexible, but requires you to do a bunch of planning.  And after it is done, this format must be maintained.

Using a file based canonical does allow you a fairly easy way to find the state of a failed step, as you can look at the file and identify what is wrong.  You can also correct the data there and allow the process to continue.  You can also make copies of these files for your monitoring so that tracking your data and transactions becomes easy, and you performance metrics become rich with data.

Database based Canonical:

Sometimes people, DBAs especially, get excited when we talk about doing this.  They are visualizing one massive Canonical Database that holds all of the transactions and is accessed by all of the applications.  And there are many products that work this way internally.  But this is not the only approach.

The one database to rule all canonical, or as I like to call it “Lord of the Databases”, requires a DBA to pay attention to optimizing, backing up, and all of the other care and feeding tasks that go along with having a database that you maintain for the long haul.  This is efficient in that you can get all of your performance data from one place, and monitoring is one connection.  However, some times applications have limitations in how they talk to a database that is not theirs, and this can make implementation complex.

Another way to use a Database based Canonical model is to use disposable databases.  In the Disposable Database implementation, you create a database that is small, only contains the structures and tables for the one transaction, and gets destroyed at the end of the transaction life cycle.  Using the Disposable Database, you don’t ever have to optimize them, back them up, or any of the other care and feeding tasks that are part of the LOTDB implementation.

Comparative implementations:

I want to examine and compair the File vs DB canonical implementations in more detail in another article.  If you have another Canonical implementation that I haven’t seen, please let me know.  I would love to examine that as well.

What is Canonical Data?

Canonical Data is the data that you or your business needs to complete the job you have to do with it.  If we are talking about order processing, then the Canonical Data will comprise the data that is used to complete the order.  This is not the minimal data set, this is the whole data set.  This is not necessarily the EDI enveloping data, it may be Identifiers that relate to the TPIDs, and it may not contain control numbers and other things that may only be found in the EDI file.  But it will contain information that you need for the order, PO Number, Line Item data, and so forth.  All of this data will need to be passed from your integration, translation, and or communication software, to your order processing systems.  And it may be passed around between systems as the order is filled and processed or what ever else you are doing with it.

What this data is, becomes defined based on the requirements of your internal systems, software and data needs.  One company may take shipping data and stick it into a data base outside of the canonical data.  It gets retrieved later, but the internal applications don’t have to deal with and preserve it.  Others may include it and leverage it on some internal aspects of their order fulfilment.  But the Canonical Dataset that your business needs and uses will be defined by the internal systems so that they can do what you need them to do.

What form should it take?

This is largely a choice that is up to you and you organization.  There will probably be some formats that are native to some applications.  As long as these fill the requirements of encompassing the data that you need to process on, these are fine choices.  Also, looking at working with these internally through upgrades to 3rd party applications, and possible inclusion of new applications, a flexible format that can be updated is important.

For me, in my experience I have seen flat file and XML used with a good deal of success.  EDI may have a comprehensive set of data, but can become really clumsy when working with internal applications that need to be extended by adding data to the canonical file.  So I would discourage EDI or a canonized XML like cXML to be used at the canonical

Who sees the Canonical Documents?

Please keep your Canonical Documents for internal consumption only.  It is not that they contain secret information, (they may have confidential data)  but they are designed just for you and  your applications.  I worked with a supply chain company once that developed their internal XML format, and then published it out to a couple of trading partners.  These partners integrated to this.  Eighteen months later, when the company was doing some growing, they were stuck supporting this one-off format that was no longer used as the internal canonical.

Developers, and those supporting the applications are going to see and deal with the canonical data and data files.  Monitoring and reporting systems may represent the canonical data, but it is rare that you need to invest time training and supporting bringing people outside of this group up to a familiar speed on your canonical file format.

What have you seen done?

Does your company have a formal canonical dataset?  Or what have you seen done that works to fill the need of canonical data?

The Target

Open Office tables are divided into two tables. Invoice and Invoice Details. This can be mapped in two ways; The first way is to map the data into one common format and rely on whatever ETL tool is importing the data to catch and split the data. Second, a key can be acquired or constructed in the transformation and then the the data can be divided in to matching input formats. Then when these inputs are moved into the database, they will relate to each other on this key.

The choice of how you will do this will depend on your environment. Questions like, “Will I have enough data to provide a unique key?”, or “is there a way to get a key with an API call or database query?” The answers to these questions will determine what course you will take.

If the system ultimately receiving the data is asynchronous to the transformation, and you need to send the invoice and invoice details data separately, some care needs to be taken to ensure that the data can be related after it is separated.

So what data in the invoice can be used to tie the invoice to the invoice details? The first answer might be, “The Invoice Number.” But this number is not guaranteed to be unique across multiple vendors.  In EDI and cXML there are document unique identifiers.  Since we are using EDI, we can use a combination of the ISA Sender, Receiver, and Control number.  We will also want to use the GS control number, and ST control number in the event that more than one invoice is sent in a single envelope.  And we might as well tack on the actual invoice number from the BIG_02.

Database Tables

Invoice Table:	Invoice Details Table:

The Paper Map

Now that we know what the target looks like, we fill out the target side of the paper map.  Since we will create two “files” in our output.  We are creating the Invoice and the InvoiceDetails file, but we can use one paper map for both, and will distinguish this with a bar between the two “files”.  (I am saying files, but this could be a queue, or a post, or an insert over odbc, etc)

What’s Next

Today we went through the process of identifying the target, and creating a paper map with the target format identified.  We talked about some of the strategy that we use in deciding what to map and how to map it.  Next time we will identify the source, and begin mapping data from the source.

1.  A big Whiteboard

This is probably my number one requirement.  When I am thinking, I like to draw it out.  I haven’t found an application that gives me the same creative release and adaptability as my whiteboard.  After starting to do some of my work from home, I went out and acquired a 10 X 4 whiteboard to put in my home office.  Having the extra room is essential.  I can get a call, and walk over to the whiteboard and start drawing out what needs to be built to solve the problems while I am still on the call.

You may not need a white board as big as mine.  And you may have an electronic solution that you like better.  If so, please let me know, I like to try out gadgets.

2.  Spreadsheet

Now this may not sound earth shattering, but we are not just talking about the basics.  You will need to learn to write filters, import data, link cells and perform calculations.  If you think that a spreadsheet is like a ledger, then you are missing the power of a spreadsheet.  If you don’t think you have the skills you need, here are some links to tutorials for the two most popular spreadsheet software.

• Very Basic Open Office Tutorial http://www.tutorialsforopenoffice.org/
• More specific/advanced tutorials http://openoffice.blogs.com/openoffice/
• Some basic and advanced help for MS Excel http://www.internet4classrooms.com

3.  Text editor.

Familiarity with more than one is needed as you will find yourself on Windows and Unix servers and they will have different sets of tools.  One of the things that is the most frustrating is to not know how to use the native editor of the system you are on.  So get familiar with Notepad, and then get familiar with VI.  You can add in other tools like UltraEdit, TextPad, and more, but you should know the native ones first, if not best.

• Ultra Edit is a popular tool in some circles.  http://www.ultraedit.com/
• Text Pad is also popular.  http://www.textpad.com/
• Believe it or not, notepad has some tutorials.  http://bink.nu/news
• And here is a cheat sheet for VI commands.  http://downloads.techrepublic.com

4.  File compare.

One task that will need to be done is to compare a file with another file to detect changes or differences.  This happens in both new integrations, and in trouble shooting or investigating existing ones.  Some systems have native comparison tools, others don’t.  And there is much variety in how they work.  Here are some of the tools I have seen and used.

• Wiki has a great list.  I don’t know that I can improve on.

5.  DB query

Much of the time, integration involves a database somewhere sometime.  To work on an integration and not have to have a DBA sitting in your lap, you need to be competent to query the database.  And this involves using some tool.  Sometimes systems will have native tools, other times you will need to connect your own.  Here is a list of tutorials for DB Query tools that I have seen and used.

• Squirrel SQL http://squirrel-sql.sourceforge.net/
• SQL Worksheet
• TOAD
  

Summary

This is by no means attempting to be a comprehensive list of tools.  Such a list would be long, if it were possible.  And I don’t think that it is.  There are however some tools/skills that help us to be more effective as Integration Engineers.  Seeing what others use is helpful especially when we find that the tool we used to use is not longer around.

What tools, applications, or skills do you find you are falling back on often, on more than one project?  Or what new tools have you found that you think you will use often in the future?

Many moons ago, I was shown an database that was constructed back in the 50s.  It was hand held and consisted of a stack of cards that contained information about plant biology.  There was a series of holes that wrapped around the cards, some of the holes were notches, and others were not.

To query the database, one placed a pin through one of the wholes and let the cards that had a notch fall out of the stack.  You could continue this process by removing and adding pins to select different combination of data.

Once you had narrowed your search, you could read the cards, and retrieve the data.

This was a very manual process, and I doubt that anyone today would take the time to learn to use such a tool, let alone update or add records to it.

More Modern Databases

Replacing Card Catalogs in libraries, Rolodex on desktops, and filing rooms in offices, is our new electronic concept of databases.  At a rudimentary level, and fitting under the definition of the database that we started with fall many simple documents.

A post-it note is not a database, but a list of names and numbers on a contact list is.  It has regular structure, and the data can be retrieved using a routine.  And this is as far as most people need to go.  They see databases like spreadsheets.  They even use filters and link cells for calculations.

More than just a list

A database that just holds a list of records is a single table Database.  This is like a spreadsheet and the only real advantage is that Databases on computers are generally designed to be queried by other applications.  The contact list in your email client is not much more than a flat table.  But it is queried and updated from the email application.  This makes the application more useful.

Again, long ago, I had a watch that held phone numbers.  This worked pretty well, and had an alpha-numeric keyboard.  But the data was in a silo.  There was no way to get the data in or out other than the small screen and keypad.  Application bound, embedded databases are also silos of data.

Many applications now use, or have the option to use, an embedded database.  But databases that can be used by more than one application, and are treated like an object are even more useful.  When a database is shared between applications, we can gain exponential utility.  Every new application that can query the shared database becomes more efficient.

RDBMS More than a single table.

One of the things that we will discuss more later, is the concept of a relational database.  What this means is that we have more than one table, that have related fields.  A analogous example is the an email system with an integrated calender.  Now we have the schema or table that contains the contact and relate them to people invited to the events.  These systems have been around for quite a while and gives us a conceptual model of how related tables bring power to a Relational Database Management System (RDBMS).

Data in a Hierarchy

RDBMS is not the only way to organize data.  One way that some databases organize data is in a hierarchical schema.  In this fashion instead of tables, we have a conceptual model like a directory tree.  Data is located in a name space that is organized like files in directories.  Data in this type of structure gains some implicit structure and relationship as a parent child relationships exists in the data naturally.  For small sets of data this can make the database small and fast.  However the ability to build abstract structures, relationships and queries are more difficult with this structure, and the database really grows when extended to cover the features of multiple relational data reference.

All Shapes and Sizes

More basic than the most simple table or hierarchy based database is the file based system.  This is really what it sounds like.  A simple text file or an XML file can be used as a database.  These can support queries, inserts and joins.  Even though the database is in a standard file that can be opened and accessed with a common text editor, it has a structure and can be used to keep the application data organized.

Databases for the Integration Engineer

As integration Engineers, we will sometimes find ourselves working directly with and application’s database.  Sometimes this database will be a full blown enterprise level database implementation.  Many times, however, it will be something more simple like an embedded table or xml file that the application treats as its database.  Whatever the case, we need to learn and respect the structure of the data, and work to ensure that our integration preserves the integrity of the data structure.

RFID is exciting technology for integration engineers.  All of this data coming in will have to be aggregated and integrated by someone.  Also, one of the focuses of integration is to provide more and better information to people and systems.  With more and better information people, businesses and systems can make better choices and decisions.

This is a good thing.

People talk about privacy issues and consumer protection.  I am sure that debate will continue to rage on long after the keyboard and mouse you are using have RFID tags embedded.  But the focus of this blog is how these technologies can be used for the collection and integration of information.  Implementing RFID technologies provides a hugely beneficial and accurate stream of data.

A character set is a collection or library of characters, (letters and symbols), and their identifying number.  Included with the printable characters, (letters and punctuation) are some unprintable yet important characters.  Characters are used to form messages.

Characters are not fonts.  Characters exist under the font that represent the definition of the character the  font is attempting to display.  When you change the font on a document the A is changed to an A, but the underlying character that identifies its meaning remains the same.  The font identifies how the character is displayed.  You can even convert to Wing Dings and the underlying character remains the same.

We can imagine that if I wrote this post using a character set that I created myself.  And then you came and tried you read it, without knowing what my character set was, you would see a bunch of garbage on the screen like if you go to a foreign language web page without the correct fonts loaded.  Even worse would be if you used the same characters, but had different Identifiers for them.  If an A is 001 (my set starts at A and moves on numerically) and you try to read it, (but in your character set you numbered the vowels after the consonants) and 001 to you is B.  Now all of the letters will be wrong.  And we get garbage.

Fortunately, some people got together early on and created a standard for characters.  The American Standard Code for Information Interchange created the character set we call ASCII.  The Extended Binary Coded Decimal Information Code was created by IBM, but they use ASCII now as well.

What is ASCII

ASCII is the acronym for American Standard Code for Information Interchange, and is a collection of characters defined from 0 to 127.  These definitions represent all of the standard English characters, numbers and symbols.  A number of other, unprintable, characters are also included.  You use one or two of these each time you hit the “Enter” key on your keyboard.  Depending on your operating systems, this sends the “carriage return” and or “line feed”

A “carriage return” comes from a printer where the head would move back and forth on the roller.  CR would tell the printer to move the head all the way to the left of its printing area.  A “line feed” is also from a printer perspective.  This tells the printer to roll the paper so that the head will be writing on the next line.  These are both examples of unprintable characters.  You can probably think of others.  For a complete list of ASCII characters, you can check out this table in my toolbox.

What is EPSIDIC

EPSIDIC  is the acronym for Extended Binary Coded Decimal Information Code.  This was created by IBM back in the day.  IBM now uses ASCII just like everyone else, but there are legacies that are still with us.  Old terminals like VT100 and some legacy communications equipment still expect messages using the EPSIDIC character set.

What is the big deal

As I said, some systems still want to use some of the characters in the EPSIDIC system.  Even fancy new systems producing XML will sometimes fall into this trap and cause problems.  The one that I have run into is the use of | called ‘pipe’  ASCII and EPSIDIC use different character IDs for this character.  And I have seen e-commerce systems, that are using ASCII for everything else, throw in an EPSIDIC pipe as a control character.  When this happens, other systems will choke on it.

When you find yourself getting an invalid character message, but the characters look fine.  Remember that there are some twists that may exist in the underlying character set.  If you can, manually replace the character with the character that it looks like, (in my case the EPSIDIC | with a ASCII | )  and see if the parser likes the file now.  If it does, you have encountered the character set problem as I have.  This can be a difficult problem to solve if you have never encountered it.

If the character that is causing problems is not a pipe, you may want to look at IBM’s ASCII to EPSIDIC conversion table.  This can be difficult to communicate with others that have never encountered it, so using the ACSII and EPSIDIC identifier designation can help explain what we are saying in email and documentation when we are trying to correct the issue.

What is a Circular File?

This is not like sending the log data to /dev/null or some other black hole.  It is a file that can’t grow beyond a specified size, but never refuses to accept new data.  This is not a paradox.  Visualizing this file like a roll of paper instead of a sheet of paper.  On the roll, there is no end, it just goes around and around.

Say you have a small circular file, 10 MB in our example.  Then lets say, every minute, you add 1 MB of data to your file. For 9 minutes after you make a log entry, you can see this entry in the file.  Each time it moves down on minutes worth of space on the log.  At 10+ minutes, it is gone.  The circular file has rolled over and overwritten that location with more current entry.

Okay, so a 10 minute log may not be that useful, and we would probably want to used a bigger size.  But the point is, that if disaster strikes, the log won’t grow like crazy and create an even bigger problem by filling up the disk.

Why aren’t all logs like this?

Using a circular file for a log is very useful, but if you have an error, and then the log scrolls on for long enough for the error to be lost, all you have are the symptoms not the cause.  So you have saved yourself the problem of making, “The smtp server failed, and the Web tool started logging errors that it couldn’t send emails.  People kept clicking, resend mail until the log filled up the disk, and the app died.” explanations.  But they are replaced with the, “Yes we logged the error, and then the app started logging all of the following actions and the error fell out of the log.”  followed by an explanation of what a circular file is and why this bad news is really good news.

Its best to use more than one logging method.  Say we have a circular log that allows us to see a week of normal activity.  Lets pretend that is 10 GB.  And we have a log that is flat, and only logs critical errors.  Now we have a way to not get clobbered by all the actions that start happening when the rain comes, and we don’t lose that original error that started the mess.

Utopalog

Okay, I am making this up, but here is my dream strategy.  First, we use a circular log that can be size configured on the fly.  Second we use an error database.  We have two table structures; First Occurrence, and Last Occurrence.  Just as they sound, when we have a new error, debug, whatever, it gets logged in the First and Last Occurrence tables.  But the Next time it happens, the time on the Last Occurrence table is the only thing that gets updated.

To use this, we periodically truncate or archive the tables.  The log is self cleaning.  We can do this each night, or on demand, or pick your own schedule.  Now when a problem occurs, we can look for errors that happened before the beginning of the log, but we won’t have a mountain of data that will crush us.

Files are called “Flat Files” when they contain a single data structure.  Generally this structure is the column and row structure like a spreadsheet or table, but a file in binary or encrypted with a single encryption key could also be called a flat file.  Files that are not flat; marked up files like XML or HTML, EDI files, other formats like HL7 or SEF files and others.  Here I am going to briefly discuss two flat file types; Delimited Files, and Fixed Width Files.

What is a Delimited File?

Ok, to describe it briefly, a delimited file is a file where the data is organized in rows and columns.  Each row has a set of data, and each column has a type of data.  If it sounds like I am describing a spreadsheet, you are right on the money.  To make the column, each row has the columns separated with a character called a delimiter.  See the example below.

Tables of data and spreadsheets are both similar to a delimited file in the way they organize data.  In the delimited file all of the empty space, or white space is removed.  What we see here is a classic example of exporting a spreadsheet table as a comma delimited file.  In theory, this data can be imported by any other application that can read a delimited file.

Believe it of not, a space is a character, and takes up space in a file.  Back in the day people went out of their way to save space so that files could be send over slow modem connections.

What is a Fixed Width File?

There is another type of file, is is called a Fixed Width or Fixed Position file.  It is different from a delimited file in that the data fields are defined by the character position.  See the example below.

In a fixed width file, the delimiter characters are eliminated.  If the data is formulated such that the data fields are the same size, this format can be more compact than a delimited file. You can see here that we know the size of the Birthdate data, so we eliminate all the spaces between the Bdate and Department fields.  If all of the data was formatted for size like this, we could really make this file small, so that it only contains the data.

We also eliminate the pesky problem of delimiters found in data.  The issue of a comma delimited file containing a field that has a comma in the data.  How does the parser know that this comma is not really a delimiter, but is part of the data?  Anyway, that problem is eliminated in a fixed width file.

Comparison

This is not a contest of which format is superior.  Both file architectures are useful and both are used commonly enough that you need to be at ease working with both.  Delimited files are really easy to work with as long as your data is clean of the delimiter character.  Doing quick integration of data common in ETL tasks, delimited files are far more common that Fixed Width.  Continuous operations of data integration and importation many times find that Fixed Width or Position files are more reliable for the unattended operation, even ETL if it is unattended.

As with many things in integration work, we want to pick the best option.  Knowing and working with both fixed and delimited files will help you determine which is the right choice for the task you have before you.

– Data, Star Trek: Next Generation: “Where Silence Has Lease“

If the beginning of wisdom is to realize what it is that we do not know. NULL, by its definition is this not knowing.  We do not know what NULL is, this is why it is NULL.

What is this?

Null is not a number, or letter.  It may not even be a character.  Using Occam’s razor, things are either NULL or NOT NULL.  Things that are NULL are completely unknown at the time they are NULL.  And things that are NOT NULL are not completely unknown when they are NOT NULL.

I feel the hair splitting on my head, so let me explain one important point.  Things that are NULL are not destined to stay that way.  Where /dev/null/ is the black hole of output that we don’t need, NULL is not the data equivalent of a black hole.  Things that are currently NULL may become NOT NULL at any time, as soon as we know something about them.  Pretty much anything really.

Empty String Theory

Unlike string theory, which attempts to define the nature of the universe, the ‘empty string theory’ is that empty strings are the same thing as NULL.  They are not.  If they were NULL, we would not know that they were strings.  This seems quite clear.  NULL is NULL and an empty string is NOT NULL.

“But wait!”  I hear a Database Developer cry.  “I can create a field in my database that is a string, and allow it to be NULL.”  And this is correct, but this is not a contradiction.  When you allow a database field to be NULL you have allowed it to receive NULL as an input.  But it may or may not give NULL as an output.  Because we can put NULL into a variable, when we query for that variable, element, whatever, we may get NULL, or we may get an empty string or property defined value of that data type of the field, that just happens to be empty.

In final reply to this inquiry I must observe that NULL is not equal to anything.  Any conditional statement where NULL is compared to something will be false.  Where, “” represents an empty string.  If one writes the statement, ["" == ""], or in English, “if an empty string is equal to an empty string,” it evaluates as a true statement.  However if one writes the statement [NULL == NULL], or in English, “if NULL is equal to NULL,” it evaluates to a false statement.  Since an empty string is equal to another empty string, but NULL is not equal to NULL, then NULL cannot be the same thing as an empty string.

Why NULL is important

Just as early civilizations had no concept of zero, early discourses of NULL struggle with it.  Where we can argue if you have zero apples, is the same as having nothing.  Yet it can be the absence of something that is known.  Zero can be having none of something.  But NULL is not even knowing what the something is that you don’t have.

An apple basket can contain 0 apples as a way to say, “Hey, this basket is for apples!”  So is 0 greater than NULL.  Because with null we don’t know what the basket is for.  We may not even have a basket at all.

There are a great number of operations that we couldn’t do well or efficiently if we didn’t have NULL.  So understanding what we are asking when we look for NULL is important.  Whenever we have a search for things that don’t match something else, we are searching for NULL, even if the values themselves are not NULL.  We do this a lot, and we couldn’t do it without NULL.