Category Archives: Discussion

Complacency RE: TSA

This past weekend I was on a trip to San Francisco. I was only staying for the weekend and hadn’t packed much. Everything I needed fit into a carry-on. This also meant that everything I needed would have to be loaded onto the TSA conveyor-belt to ensure that I wouldn’t be bringing anything dangerous into the passenger cabin of the plane. To my surprise, my bag was flagged and my tube of toothpaste was deemed “too large” and had to be taken away from me.

Upon returning home a few days later, I relayed the story to a colleague, who said something along the lines of “The only one to blame is yourself.” After unsuccessfully trying to argue my point that the TSA should not be able to take away toothpaste that is obviously toothpaste [1], I realized that my colleague had simply grown complacent with the TSA.

I believe strongly that the TSA is a good example of the people giving up freedoms for “protection,” something that should not happen. [2] This blog post, therefore, serves as a reminder to the reader that the people should not be willing to sacrifice freedoms for safety. The people should only be willing to accept safety precautions that do not encroach upon their freedoms. The TSA and NSA, unfortunately, do not fall into this category and should not be accepted. [3]

   [ + ]

1. I had asked the TSA agent if I could squeeze toothpaste out such that, when folded, the tube would meet the maximum size restrictions. They said this was not allowed.
2. A fantastic explanation of this can be seen in Glen Greenwald’s TED Talk about privacy
3. Unfortunately, I am not aware of a good way to fight the TSA. As a side thought, however, I wonder how many innocent tubes of toothpaste must be taken away until a tube of toothpaste is considered to be a safe item

We Are All Humans

As a citizen of the United States, it is no secret that my privacy has been in
constant violation for the entirety of my life. Despite claims of
All-American freedom, the only freedom I seem to have regarding my privacy is
the freedom to have no say into whether my privacy is breached.

The privacy issue began to be brought into the common light when Edward Snowden
revealed the ongoings of the NSA and its gratuitous spying on the American
public. This was a few years ago. Recently, however, it was revealed that AT&T
and the NSA share an agreement wherein AT&T will voluntarily aid the NSA in the
collection of data. Indeed, in several court cases against AT&T regarding their
data sharing, the United States provided AT&T with immunity, leaving them
unpunishable for their sharing of customer information.

It is easy to quickly agree that all AT&T customers should simply switch service
providers, taking their money to companies who do not have agreements with the
NSA, and thereby solving the problem. However, it isn’t that simple. If AT&T has
an agreement with the NSA that supposedly grants them immunity in court, not
many other companies would refuse such a good deal.

This raises a very big question: What gives AT&T the power to share other
peoples’ information with the government. What’s more: What gives the NSA
the right to demand this information?

What is privacy?

A longwithstanding fact is that people need some sort of privacy. Whether it
be their rooms, the bathroom, or simply privacy of mind, humans need some
place to be able to think and ponder without being watched.

Most Americans believe that they have a certain amount of privacy. For instance,
after work most Americans return to their private homes, where only a select few
individuals are allowed access. Even then, humans tend to wish for “private
time”, wherein they sit alone and contemplate things far beyond their own
personal experience.

Not only this, however. Many Americans yearn for a privacy of record. That is,
there are some things that simply need to be unexposed to everyone else. Phone
call transcripts, chat history, internet history, medical records, letters,
photos, and passwords are all examples of this. This is something that most
Americans believe they have as well. For instance, it is often considered too
Orwellian to admit that every word you say is being watched. This consideration
is testament to how much privacy Americans think that they have.

This, of course, is all understood. When it comes to the question of sharing
this privacy, many Americans will respond with something along the line of
“I have nothing to hide”! These same people, however, are reluctant in sharing
all of their personal information, passwords, and private chat transcripts
with random individuals on the street. I thought you had nothing to hide!

Governments are People

It has long been said that the United States is a nation run “by the people,
for the people”. In its literal sense, this statement simply means that the
government, the body that supposedly runs the entire country, is made up of
people. Of course, the statement was meant to be more of a democratic ideal,
showing that the same people that must follow laws have the power to change

Looking at the literal interpretation makes sense, though. After all, the
government is just a large collection of people who do various things. In
addition, the government is a small subset of the entire human population. Thus,
the government is simply a collection of humans. Just like the group it governs.

I’m not saying that the concept of a government is wrong, however. It should be
fairly obvious that without a central source of rule, things go haywire. There
is no standardization of units, no agreed upon rules, and no way to make sure
that the gullible are not abused by the persuading. This governmental group
of humans, however, are not special in any way. They, as humans, do not have
any advantages over the people they govern. They were not blessed by a god,
they are not more intelligent, they are not more knowledgeable, and they are
not more important. With seven billion people on the planet, how is it possible
that one human is more important than another? It isn’t.

With that being said, why would a certain group of humans be allowed to violate
the privacy of another group of humans? The answer is simple: They shouldn’t.
After all, privacy is something that all humans need, and for one group of
humans to deny this from another group of humans simply isn’t right.

The Current Situation

Currently, it is the case that this exact situation is occurring. A group of
humans, the United States Government, is violating the privacy of the humans
that it governs. It is not doing so in the simplistic sense that it is listening
for certain keywords to prevent terrorist attacks, but rather it is doing so in
the sense that it is storing everything. With its NSA program, the government is
storing your location of every moment of the day (via cellphone GPS), your
calls, your texts, every photo you take, every minute you spend using water,
every thing you purchase, and every person you interact with. With this, it
is creating a searchable profile for you, wherein any government official can
search for you, by name, and find out everything about you, including the things
you do in “private”.

Of course, the humans that are being governed don’t have much of a choice. By
simply living in the United States, they signed an invisible contract saying
that another group of humans, the government, had the right to invade every
aspect of their private lives.

This, of course, should not be happening. Following the ideals of all men
being created equal, one group of humans should not be able to invade the
privacy and the lives of another group of humans.

We are all humans. We are all the same. No one should have privilege over others
in the magnitude that the United States government has privilege over its

The Power of Markup Languages

An Anecdote

Recently, I’ve been trying to make myself learn how to write rich documents within plaintext files. I want to do this for a few reasons:

  • I can write everything in vim. Let’s face it — Word processors are pretty ugly. I really don’t like working on documents in Microsoft Word or LibreOffice when I can instead work on my documents in vim. Not only the look, but also the speed. I am able to edit so much faster using vim than any other editor on the market.

  • Portability is key. Have you ever received a paper from a colleague only to be found that it is in some format that you can’t read? (Cough Pages Cough). I, personally, really hate when this happens. In order to solve the problem, why not just write everything in plaintext and distribute it that way?

  • It prepares for the future. In the future, Microsoft Office, Pages, LibreOffice, and the like will probably be out the window. In fact, Windows, Mac OSX, UNIX, or anything you hold dear in the computing world will probably be thrown out the window. If this is the case, the text that we write needs to be unformatted. That way, the text can be viewed on any operating system with any text editor.

The Solution

The solution, I have found, is to write everything using Markdown (Using the CommonMark Spec) and LaTeX. In this way, I will be able to express all of my thoughts in a clear, succinct, portable, and easy-to-read fashion.

One of the great things about these two markup languages is that they are everywhere. You don’t really know until you start using it without thinking, but almost every program supports it. It’s great expressing your thoughts in Skype or GChat because you can bold important words or italicize others. What a good way to express your thoughts!

Because of my recent change in heart, I will be writing all of my blog posts in plaintext from now on and leaving it to the WordPress text rendering system to render everything (hopefully properly). There are also many, many plugins making LaTeX and Markdown rendering possible. It’s really great.

Look how easy it is to express my favorite finite automata:
$M_{favorite} = {Q, \Sigma, \delta, q_{0}, F}$
M_{favorite} = \{Q, \Sigma, \delta, q_{0}, F\}

I will probably report back about this venture as I learn more.

Why Everyone Should Learn Latin

One of the first posts on this blog discussed the interest that I had in reading pieces written by writers who lived some 2,500 years ago, mainly those who lived in ancient Rome. The post can be found here.

One of the main things that I found to be interesting about reading the works of those who wrote complex anecdotes in Latin is that the topics they discussed are extremely similar to the topics that are discussed and debated about today. For instance, authors often joked about the cruelty of the government, discussed the meaning of life, and wrote reports on the actions and customs of other nations. As a race and society as a whole, we are often claimed to have advanced by an incredible amount; however, upon analyzing the texts of ancient Roman writers, we learn that, especially with social issues, we have barely turned a pebble.

The Grammar

Before I even delve into the world of social issues and Latin, I want to discuss how much of a benefit learning Latin is from a linguistics perspective. To put things in perspective, most people I know are native English speakers; however, they do not know the inner workings of the language. For instance, ask them to construct a sentence using the pluperfect. Most will just sit and stare. “What’s a pluperfect?”. Exactly.

After learning a good bit of Spanish, I always thought it was weird how they put so much emphasis on the conjugation of verbs. Every time you used a verb you have to conjugate it? How strange!! How naïve I was. We conjugate verbs in English, too! (He runs, I run, they run) – it just took Latin to really hammer this idea into my head.

Latin has also taught me a lot about how other languages are able to work. I always figured that all languages work in a strict subject+verb pattern. That is, just like English. However, Latin showed that word order doesn’t even have to matter! Word order is just a preference in some languages, and endings of words determines what is the subject and what is the verb. This allows authors to declare their own style and allows for a true freedom of language. For instance, take the following example of English and Latin.

I ran with my friends.

Ego cum meis amicis cucurri.

As you can see, the English works in a subject+verb structure, where the additional information is provided after the fact. In Latin, the subject is at the beginning of the sentence, the verb at the end, and all additional information is packed in the middle. It really is different from English and shows the true stylistic differences that exist between the two languages.

Before I get talking about the social implications of Latin, I just want to mention that learning Latin has also allowed me to become more knowledgeable about other things in English such as the cases of words, moods of verbs, tenses of verbs, and many, many word roots that are very interesting. (Presidio is derived from the Latin word Praesedens meaning “stand before” – translating into something that stands before other things or defends!)


The Social Implications

Think of the world. Think about your existence. Think about the people around you. They all have their own standards, morals, thoughts, and ways of life. Now think about the people that existed before you. Do they have their own standards, morals, and thoughts? Surely. Now think about the people that lived in ancient Rome. Do they have standards, morals, and thoughts? Most people would not imagine so. Most people could not even imagine them living in the same way that we live today (I know I have difficulties with this).

Reading Latin opens your mind to this. Reading the thoughts and words of people who lived in ancient Rome makes one come to the realization that even 2,500 years ago, people were just like we are today. They loved their wives, family, and children. They squabbled over the same things. They came home every night for dinner. It is simply hard to imagine that they lived out a daily life, though. One often thinks of Romans in battle, in court, or attending some sort of toga party, but one never thinks of Romans as people who woke up in the morning, pondered the details of life, and went to bed at night.

Isn’t it weird to think about that? Some many thousands of years ago, a whole different set of people walked the Earth, and they thought and ate and used the restroom just like we do today. Realizing this thing was very humbling to me. All of this realization was able to occur due to the stories, opinions, and anecdotes that I read.

Discovering all of these things was a wonderful and unexpected side effect of learning Latin. I believe that it has led me to a much more open mind and has allowed me to look at the world, especially humanity, in a whole new light. Because of this, I recommend that everyone learn Latin. Learning Latin is learning more about the humble origins of modern humanity.

Building an Offline Program with Online Syncing

As I become more and more experienced with software development, I am very quickly discovering the limitations of the web. Having a desktop application that constantly needs to retrieve large amounts of data from the Internet is very, very slow. Sometimes, when network speeds are spotty, a simple interaction can take up to 30 seconds, which is definitely unacceptable for the end-user.

In order to solve this problem, I decided to restrict myself from looking at online solutions. I wanted to create a solution on my own.

First, I wanted to create a robust system for managing a database for an offline program. I looked into several different services, including Microsoft’s SQL Stack and a local MongoDB server. However, I found that most of these solutions were either too difficult to learn (I was used to setting up a MySQL server using cPanel and phpMyAdmin) or that they over-complicated the issue. Then, I came across SQLite, which happened to be exactly what I was looking for. It was a lightweight, speedy, local replica of MySQL. After spending about an hour reading the documentation, I realized that it was also super easy to setup. I began working on a library that would make working with a local SQLite database super easy.

Thus, SQLiteDatabaseManager was born. The project was meant to house functionality that would be used in all of my projects, and here are some of the key features that were packed into it:

  • The ability to quickly create a local database
  • The ability to quickly insert, delete, and update records knowing the table names, the fields, and the new values.
  • The ability to have a small table-verification system that allowed the user to define table schemas and check the existing SQLite tables against these schemas for integrity verification.
  • The ability to retry operations when they fail (the fail could be a result of a spontaneous locked file and a retry could fix everything)

SQLiteDatabaseManager worked well because all you needed to do was create a new instance of it, and everything worked out of the box. A new SQLite database was setup and managed by the library. After rigorous testing, this worked perfectly. Of course, the library still needs major work and many more features, but it does what it was intended to do at the moment. My offline data management system worked.

Now the problem was not just managing data offline, but getting it to sync to an online counter-part when a network was available (In a perfect world, all operations would be done on the local SQLite database (fast) and then they would be replicated on the duplicate remote MySQL database (slower) on a background thread). The idea was simple.
Local SQL and Online SQLThe SQLite database and the MySQL database would communicate with eachother via a simple REST API. The databases would be identical and the ID numbers created by the SQLite database would simply be moved to the MySQL database.


Creating the REST API for the remote MySQL portion of this project was rather simple. Relying on the methods of the LAMP stack, I used a set of PHP files that would receive GET, POST and DELETE requests so that data could be managed and manipulated fairly easily. Using PHP’s json_encode() function also proved very useful for creating readable responses.

Thus, with the creation of a working SQLite local database and a working and accessible remote MySQL database, I went ahead with the first iteration of implementing this idea. So far, I have run into a few problems.


An easily-solvable problem arose when thinking about how to handle many, many clients. Since there was only one remote MySQL database and many, many instances of the local SQLite database, it was a pain tracking when the local client’s changes actually had to be applied or if the remote version was actually newer. This problem was solved by creating a dateAltered field in both the remote and local databases that would contain the last date of modification of the data that it pertained to. Thus, the data with the latest dateAltered value was put permanently into the remote MySQL database.

But what about when there are many, many clients creating information. Surely, some of the client’s SQLite databases will assign ID numbers that coincide with other clients’ SQLite databases. Thus, when information is uploaded to the remote server, different pieces of information may have the same ID numbers. But since all data is modifiable, how is this detectable? This is a problem that I have not yet worked out a solution to since the first implementation of this design has a one-client one-server relationship. However, at the moment, I am hypothesizing that each data-entry contain a unique hash of its original state. Thus, database operations can be performed by referencing the ID of the element, but conflict-resolutions will use this hashed code. Thus, we will always be able to track if a certain piece of information has been modified from its original form or not. Thus, when uploading to the remote server, the server will manage some conflict resolutions and return the ID number of the object. The local clients will then reassign the ID number of the object to that ID number in order to match with the remote MySQL database.


I will continue to work on this project in the coming weeks, and I plan on making some detailed blog posts about it, so stay tuned! Eventually, I hope to have this process wrapped up in an easy-to-install and easy-to-implement library. We will see how that turns out.